mirror of
https://github.com/lcn2/calc.git
synced 2025-08-16 01:03:29 +03:00
503 lines
18 KiB
C
503 lines
18 KiB
C
/*
|
|
* Copyright (c) 1997 David I. Bell
|
|
* Permission is granted to use, distribute, or modify this source,
|
|
* provided that this copyright notice remains intact.
|
|
*
|
|
* Definitions of general values and related routines used by the calculator.
|
|
*/
|
|
|
|
|
|
#if !defined(__VALUE_H__)
|
|
#define __VALUE_H__
|
|
|
|
|
|
#include "cmath.h"
|
|
#include "config.h"
|
|
#include "shs.h"
|
|
#include "calcerr.h"
|
|
#include "hash.h"
|
|
#include "block.h"
|
|
#include "nametype.h"
|
|
#include "string.h"
|
|
|
|
#define MAXDIM 4 /* maximum number of dimensions in matrices */
|
|
#define USUAL_ELEMENTS 4 /* usual number of elements for objects */
|
|
|
|
|
|
/*
|
|
* Flags to modify results from the printvalue routine.
|
|
* These flags are OR'd together.
|
|
*/
|
|
#define PRINT_NORMAL 0x00 /* print in normal manner */
|
|
#define PRINT_SHORT 0x01 /* print in short format (no elements) */
|
|
#define PRINT_UNAMBIG 0x02 /* print in non-ambiguous manner */
|
|
|
|
|
|
/*
|
|
* Definition of values of various types.
|
|
*/
|
|
typedef struct value VALUE;
|
|
typedef struct object OBJECT;
|
|
typedef struct matrix MATRIX;
|
|
typedef struct list LIST;
|
|
typedef struct assoc ASSOC;
|
|
typedef long FILEID;
|
|
typedef struct rand RAND;
|
|
typedef struct random RANDOM;
|
|
|
|
|
|
/*
|
|
* calc values
|
|
*
|
|
* See below for information on what needs to be added for a new type.
|
|
*/
|
|
struct value {
|
|
short v_type; /* type of value */
|
|
short v_subtype; /* other data related to some types */
|
|
union { /* types of values (see V_XYZ below) */
|
|
long vv_int; /* 1: small integer value */
|
|
NUMBER *vv_num; /* 2, 21: real number */
|
|
COMPLEX *vv_com; /* 3: complex number */
|
|
VALUE *vv_addr; /* 4, 18: address of variable value */
|
|
STRING *vv_str; /* 5, 20: string value */
|
|
MATRIX *vv_mat; /* 6: address of matrix */
|
|
LIST *vv_list; /* 7: address of list */
|
|
ASSOC *vv_assoc; /* 8: address of association */
|
|
OBJECT *vv_obj; /* 9: address of object */
|
|
FILEID vv_file; /* 10: id of opened file */
|
|
RAND *vv_rand; /* 11: additive 55 random state */
|
|
RANDOM *vv_random; /* 12: Blum random state */
|
|
CONFIG *vv_config; /* 13: configuration state */
|
|
HASH *vv_hash; /* 14: hash state */
|
|
BLOCK *vv_block; /* 15: memory block */
|
|
OCTET *vv_octet; /* 16, 19: octet addr (unsigned char) */
|
|
NBLOCK *vv_nblock; /* 17: named memory block */
|
|
} v_union;
|
|
};
|
|
|
|
|
|
/*
|
|
* For ease in referencing
|
|
*/
|
|
#define v_int v_union.vv_int
|
|
#define v_file v_union.vv_file
|
|
#define v_num v_union.vv_num
|
|
#define v_com v_union.vv_com
|
|
#define v_addr v_union.vv_addr
|
|
#define v_str v_union.vv_str
|
|
#define v_mat v_union.vv_mat
|
|
#define v_list v_union.vv_list
|
|
#define v_assoc v_union.vv_assoc
|
|
#define v_obj v_union.vv_obj
|
|
#define v_valid v_union.vv_int
|
|
#define v_rand v_union.vv_rand
|
|
#define v_random v_union.vv_random
|
|
#define v_config v_union.vv_config
|
|
#define v_hash v_union.vv_hash
|
|
#define v_block v_union.vv_block
|
|
#define v_octet v_union.vv_octet
|
|
#define v_nblock v_union.vv_nblock
|
|
|
|
|
|
/*
|
|
* Value types.
|
|
*
|
|
* NOTE: The following files should be checked/adjusted for a new type:
|
|
*
|
|
* size.c - elm_count(), lsizeof()
|
|
* help/size - update what the size() builtin will report
|
|
* hash.c - hash_value()
|
|
* quickhash.c - hashvalue()
|
|
* value.c - freevalue(), copyvalue(), comparevalue(),
|
|
* printvalue(),
|
|
* and other as needed such as testvalue(), etc.
|
|
*
|
|
* There may be others, but at is at least a start.
|
|
*/
|
|
#define V_NULL 0 /* null value */
|
|
#define V_INT 1 /* normal integer */
|
|
#define V_NUM 2 /* number */
|
|
#define V_COM 3 /* complex number */
|
|
#define V_ADDR 4 /* address of variable value */
|
|
#define V_STR 5 /* address of string */
|
|
#define V_MAT 6 /* address of matrix structure */
|
|
#define V_LIST 7 /* address of list structure */
|
|
#define V_ASSOC 8 /* address of association structure */
|
|
#define V_OBJ 9 /* address of object structure */
|
|
#define V_FILE 10 /* opened file id */
|
|
#define V_RAND 11 /* address of additive 55 random state */
|
|
#define V_RANDOM 12 /* address of Blum random state */
|
|
#define V_CONFIG 13 /* configuration state */
|
|
#define V_HASH 14 /* hash state */
|
|
#define V_BLOCK 15 /* memory block */
|
|
#define V_OCTET 16 /* octet (unsigned char) */
|
|
#define V_NBLOCK 17 /* named memory block */
|
|
#define V_VPTR 18 /* value address as pointer */
|
|
#define V_OPTR 19 /* octet address as pointer */
|
|
#define V_SPTR 20 /* string address as pointer */
|
|
#define V_NPTR 21 /* number address as pointer */
|
|
#define V_MAX 21 /* highest legal value */
|
|
|
|
#define V_NOSUBTYPE 0 /* subtype has no meaning */
|
|
#define V_NOASSIGNTO 1 /* protection status 1 */
|
|
#define V_NONEWVALUE 2 /* protection status 2 */
|
|
#define V_NONEWTYPE 4 /* protection status 4 */
|
|
#define V_NOERROR 8 /* protection status 8 */
|
|
#define V_NOCOPYTO 16 /* protection status 16 */
|
|
#define V_NOREALLOC 32 /* protection status 32 */
|
|
#define V_NOASSIGNFROM 64 /* protection status 64 */
|
|
#define V_NOCOPYFROM 128 /* protection status 128 */
|
|
#define V_PROTECTALL 256 /* protection status 256 */
|
|
|
|
#define MAXPROTECT 511
|
|
|
|
/*
|
|
* At present protect(var, sts) determines bits in var->v_subtype
|
|
* corresponding to 4 * sts. MAXPROTECT is the sum of the simple
|
|
* (power of two) protection status values.
|
|
*/
|
|
|
|
|
|
#define TWOVAL(a,b) ((a) << 5 | (b)) /* for switch of two values */
|
|
|
|
#define NULL_VALUE ((VALUE *) 0)
|
|
|
|
|
|
/*
|
|
* value functions
|
|
*/
|
|
extern void freevalue(VALUE *vp);
|
|
extern void copyvalue(VALUE *vp, VALUE *vres);
|
|
extern void negvalue(VALUE *vp, VALUE *vres);
|
|
extern void addvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void addnumeric(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void subvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void mulvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void orvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void andvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void compvalue(VALUE *vp, VALUE *vres);
|
|
extern void xorvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void squarevalue(VALUE *vp, VALUE *vres);
|
|
extern void invertvalue(VALUE *vp, VALUE *vres);
|
|
extern void roundvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void broundvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void setminusvalue(VALUE *, VALUE *, VALUE *);
|
|
extern void backslashvalue(VALUE *, VALUE *);
|
|
extern void contentvalue(VALUE *, VALUE *);
|
|
extern void hashopvalue(VALUE *, VALUE *, VALUE *);
|
|
extern void apprvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void intvalue(VALUE *vp, VALUE *vres);
|
|
extern void fracvalue(VALUE *vp, VALUE *vres);
|
|
extern void incvalue(VALUE *vp, VALUE *vres);
|
|
extern void decvalue(VALUE *vp, VALUE *vres);
|
|
extern void conjvalue(VALUE *vp, VALUE *vres);
|
|
extern void sqrtvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void rootvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void absvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void normvalue(VALUE *vp, VALUE *vres);
|
|
extern void shiftvalue(VALUE *v1, VALUE *v2, BOOL rightshift, VALUE *vres);
|
|
extern void scalevalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void powivalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void powervalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void divvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void quovalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern void modvalue(VALUE *v1, VALUE *v2, VALUE *v3, VALUE *vres);
|
|
extern BOOL testvalue(VALUE *vp);
|
|
extern BOOL comparevalue(VALUE *v1, VALUE *v2);
|
|
extern BOOL acceptvalue(VALUE *v1, VALUE *v2);
|
|
extern void relvalue(VALUE *v1, VALUE *v2, VALUE *vres);
|
|
extern void sgnvalue(VALUE *vp, VALUE *vres);
|
|
extern QCKHASH hashvalue(VALUE *vp, QCKHASH val);
|
|
extern void printvalue(VALUE *vp, int flags);
|
|
extern BOOL precvalue(VALUE *v1, VALUE *v2);
|
|
extern VALUE error_value(int e);
|
|
extern int set_errno(int e);
|
|
extern int set_errcount(int e);
|
|
extern int set_errmax(int e);
|
|
extern long countlistitems(LIST *lp);
|
|
extern void addlistitems(LIST *lp, VALUE *vres);
|
|
extern void addlistinv(LIST *lp, VALUE *vres);
|
|
extern void copy2octet(VALUE *, OCTET *);
|
|
extern int copystod(VALUE *, long, long, VALUE *, long);
|
|
extern void protectall(VALUE *, int);
|
|
extern void set_update(int);
|
|
|
|
|
|
/*
|
|
* Structure of a matrix.
|
|
*/
|
|
struct matrix {
|
|
long m_dim; /* dimension of matrix */
|
|
long m_size; /* total number of elements */
|
|
long m_min[MAXDIM]; /* minimum bound for indices */
|
|
long m_max[MAXDIM]; /* maximum bound for indices */
|
|
VALUE m_table[1]; /* actually varying length table */
|
|
};
|
|
|
|
#define matsize(n) (sizeof(MATRIX) - sizeof(VALUE) + ((n) * sizeof(VALUE)))
|
|
|
|
|
|
extern MATRIX *matadd(MATRIX *m1, MATRIX *m2);
|
|
extern MATRIX *matsub(MATRIX *m1, MATRIX *m2);
|
|
extern MATRIX *matmul(MATRIX *m1, MATRIX *m2);
|
|
extern MATRIX *matneg(MATRIX *m);
|
|
extern MATRIX *matalloc(long size);
|
|
extern MATRIX *matcopy(MATRIX *m);
|
|
extern MATRIX *matinit(MATRIX *m, VALUE *v1, VALUE *v2);
|
|
extern MATRIX *matsquare(MATRIX *m);
|
|
extern MATRIX *matinv(MATRIX *m);
|
|
extern MATRIX *matscale(MATRIX *m, long n);
|
|
extern MATRIX *matshift(MATRIX *m, long n);
|
|
extern MATRIX *matmulval(MATRIX *m, VALUE *vp);
|
|
extern MATRIX *matpowi(MATRIX *m, NUMBER *q);
|
|
extern MATRIX *matconj(MATRIX *m);
|
|
extern MATRIX *matquoval(MATRIX *m, VALUE *vp, VALUE *v3);
|
|
extern MATRIX *matmodval(MATRIX *m, VALUE *vp, VALUE *v3);
|
|
extern MATRIX *matint(MATRIX *m);
|
|
extern MATRIX *matfrac(MATRIX *m);
|
|
extern MATRIX *matappr(MATRIX *m, VALUE *v2, VALUE *v3);
|
|
extern VALUE mattrace(MATRIX *m);
|
|
extern MATRIX *mattrans(MATRIX *m);
|
|
extern MATRIX *matcross(MATRIX *m1, MATRIX *m2);
|
|
extern BOOL mattest(MATRIX *m);
|
|
extern void matsum(MATRIX *m, VALUE *vres);
|
|
extern BOOL matcmp(MATRIX *m1, MATRIX *m2);
|
|
extern int matsearch(MATRIX *m, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern int matrsearch(MATRIX *m, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern VALUE matdet(MATRIX *m);
|
|
extern VALUE matdot(MATRIX *m1, MATRIX *m2);
|
|
extern void matfill(MATRIX *m, VALUE *v1, VALUE *v2);
|
|
extern void matfree(MATRIX *m);
|
|
extern void matprint(MATRIX *m, long max_print);
|
|
extern VALUE *matindex(MATRIX *mp, BOOL create, long dim, VALUE *indices);
|
|
extern void matreverse(MATRIX *m);
|
|
extern void matsort(MATRIX *m);
|
|
extern BOOL matisident(MATRIX *m);
|
|
extern MATRIX *matround(MATRIX *m, VALUE *v2, VALUE *v3);
|
|
extern MATRIX *matbround(MATRIX *m, VALUE *v2, VALUE *v3);
|
|
|
|
|
|
/*
|
|
* List definitions.
|
|
* An individual list element.
|
|
*/
|
|
typedef struct listelem LISTELEM;
|
|
struct listelem {
|
|
LISTELEM *e_next; /* next element in list (or NULL) */
|
|
LISTELEM *e_prev; /* previous element in list (or NULL) */
|
|
VALUE e_value; /* value of this element */
|
|
};
|
|
|
|
|
|
/*
|
|
* Structure for a list of elements.
|
|
*/
|
|
struct list {
|
|
LISTELEM *l_first; /* first list element (or NULL) */
|
|
LISTELEM *l_last; /* last list element (or NULL) */
|
|
LISTELEM *l_cache; /* cached list element (or NULL) */
|
|
long l_cacheindex; /* index of cached element (or undefined) */
|
|
long l_count; /* total number of elements in the list */
|
|
};
|
|
|
|
|
|
extern void insertlistfirst(LIST *lp, VALUE *vp);
|
|
extern void insertlistlast(LIST *lp, VALUE *vp);
|
|
extern void insertlistmiddle(LIST *lp, long index, VALUE *vp);
|
|
extern void removelistfirst(LIST *lp, VALUE *vp);
|
|
extern void removelistlast(LIST *lp, VALUE *vp);
|
|
extern void removelistmiddle(LIST *lp, long index, VALUE *vp);
|
|
extern void listfree(LIST *lp);
|
|
extern void listprint(LIST *lp, long max_print);
|
|
extern int listsearch(LIST *lp, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern int listrsearch(LIST *lp, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern BOOL listcmp(LIST *lp1, LIST *lp2);
|
|
extern VALUE *listfindex(LIST *lp, long index);
|
|
extern LIST *listalloc(void);
|
|
extern LIST *listcopy(LIST *lp);
|
|
extern void listreverse(LIST *lp);
|
|
extern void listsort(LIST *lp);
|
|
extern LIST *listappr(LIST *lp, VALUE *v2, VALUE *v3);
|
|
extern LIST *listround(LIST *m, VALUE *v2, VALUE *v3);
|
|
extern LIST *listbround(LIST *m, VALUE *v2, VALUE *v3);
|
|
extern LIST *listquo(LIST *lp, VALUE *v2, VALUE *v3);
|
|
extern LIST *listmod(LIST *lp, VALUE *v2, VALUE *v3);
|
|
extern BOOL evp(LISTELEM *cp, LISTELEM *x, VALUE *vres);
|
|
extern BOOL evalpoly(LIST *clist, LISTELEM *x, VALUE *vres);
|
|
extern void insertitems(LIST *lp1, LIST *lp2);
|
|
extern LISTELEM *listelement(LIST *, long);
|
|
extern LIST *listsegment(LIST *, long, long);
|
|
|
|
|
|
/*
|
|
* Structures for associations.
|
|
* Associations are "indexed" by one or more arbitrary values, and are
|
|
* stored in a hash table with their hash values for quick indexing.
|
|
*/
|
|
typedef struct assocelem ASSOCELEM;
|
|
struct assocelem {
|
|
ASSOCELEM *e_next; /* next element in list (or NULL) */
|
|
long e_dim; /* dimension of indexing for this element */
|
|
QCKHASH e_hash; /* hash value for this element */
|
|
VALUE e_value; /* value of association */
|
|
VALUE e_indices[1]; /* index values (variable length) */
|
|
};
|
|
|
|
|
|
struct assoc {
|
|
long a_count; /* number of elements in the association */
|
|
long a_size; /* current size of association hash table */
|
|
ASSOCELEM **a_table; /* current hash table for elements */
|
|
};
|
|
|
|
|
|
extern ASSOC *assocalloc(long initsize);
|
|
extern ASSOC *assoccopy(ASSOC *ap);
|
|
extern void assocfree(ASSOC *ap);
|
|
extern void assocprint(ASSOC *ap, long max_print);
|
|
extern int assocsearch(ASSOC *ap, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern int assocrsearch(ASSOC *ap, VALUE *vp, long start, long end, ZVALUE *index);
|
|
extern BOOL assoccmp(ASSOC *ap1, ASSOC *ap2);
|
|
extern VALUE *assocfindex(ASSOC *ap, long index);
|
|
extern VALUE *associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices);
|
|
|
|
|
|
/*
|
|
* Object actions.
|
|
*/
|
|
#define OBJ_PRINT 0 /* print the value */
|
|
#define OBJ_ONE 1 /* create the multiplicative identity */
|
|
#define OBJ_TEST 2 /* test a value for "zero" */
|
|
#define OBJ_ADD 3 /* add two values */
|
|
#define OBJ_SUB 4 /* subtrace one value from another */
|
|
#define OBJ_NEG 5 /* negate a value */
|
|
#define OBJ_MUL 6 /* multiply two values */
|
|
#define OBJ_DIV 7 /* divide one value by another */
|
|
#define OBJ_INV 8 /* invert a value */
|
|
#define OBJ_ABS 9 /* take absolute value of value */
|
|
#define OBJ_NORM 10 /* take the norm of a value */
|
|
#define OBJ_CONJ 11 /* take the conjugate of a value */
|
|
#define OBJ_POW 12 /* take the power function */
|
|
#define OBJ_SGN 13 /* return the sign of a value */
|
|
#define OBJ_CMP 14 /* compare two values for equality */
|
|
#define OBJ_REL 15 /* compare two values for inequality */
|
|
#define OBJ_QUO 16 /* integer quotient of values */
|
|
#define OBJ_MOD 17 /* remainder of division of values */
|
|
#define OBJ_INT 18 /* integer part of */
|
|
#define OBJ_FRAC 19 /* fractional part of */
|
|
#define OBJ_INC 20 /* increment by one */
|
|
#define OBJ_DEC 21 /* decrement by one */
|
|
#define OBJ_SQUARE 22 /* square value */
|
|
#define OBJ_SCALE 23 /* scale by power of two */
|
|
#define OBJ_SHIFT 24 /* shift left (or right) by number of bits */
|
|
#define OBJ_ROUND 25 /* round to specified decimal places */
|
|
#define OBJ_BROUND 26 /* round to specified binary places */
|
|
#define OBJ_ROOT 27 /* take nth root of value */
|
|
#define OBJ_SQRT 28 /* take square root of value */
|
|
#define OBJ_OR 29 /* take bitwise or of values */
|
|
#define OBJ_AND 30 /* take bitwise and of values */
|
|
#define OBJ_NOT 31 /* take logical not of value */
|
|
#define OBJ_FACT 32 /* factorial or postfix ! */
|
|
#define OBJ_MIN 33 /* minimum value */
|
|
#define OBJ_MAX 34 /* maximum value */
|
|
#define OBJ_SUM 35 /* sum value */
|
|
#define OBJ_ASSIGN 36 /* assign value */
|
|
#define OBJ_XOR 37 /* ~ difference of values */
|
|
#define OBJ_COMP 38 /* ~ complement of value */
|
|
#define OBJ_CONTENT 39 /* unary hash op */
|
|
#define OBJ_HASHOP 40 /* binary hash op */
|
|
#define OBJ_BACKSLASH 41 /* unary backslash op */
|
|
#define OBJ_SETMINUS 42 /* binary backslash op */
|
|
#define OBJ_PLUS 43 /* unary + op */
|
|
#define OBJ_MAXFUNC 43 /* highest function */
|
|
|
|
|
|
/*
|
|
* Definition of an object type.
|
|
* This is actually a varying sized structure.
|
|
*/
|
|
typedef struct {
|
|
char *name; /* name of object */
|
|
int count; /* number of elements defined */
|
|
long actions[OBJ_MAXFUNC+1]; /* function indices for actions */
|
|
int elements[1]; /* element indexes (MUST BE LAST) */
|
|
} OBJECTACTIONS;
|
|
|
|
#define objectactionsize(elements) \
|
|
(sizeof(OBJECTACTIONS) + ((elements) - 1) * sizeof(int))
|
|
|
|
|
|
/*
|
|
* Structure of an object.
|
|
* This is actually a varying sized structure.
|
|
* However, there are always at least USUAL_ELEMENTS values in the object.
|
|
*/
|
|
struct object {
|
|
OBJECTACTIONS *o_actions; /* action table for this object */
|
|
VALUE o_table[USUAL_ELEMENTS]; /* object values (MUST BE LAST) */
|
|
};
|
|
|
|
#define objectsize(elements) \
|
|
(sizeof(OBJECT) + ((elements) - USUAL_ELEMENTS) * sizeof(VALUE))
|
|
|
|
|
|
extern OBJECT *objcopy(OBJECT *op);
|
|
extern OBJECT *objalloc(long index);
|
|
extern VALUE objcall(int action, VALUE *v1, VALUE *v2, VALUE *v3);
|
|
extern void objfree(OBJECT *op);
|
|
extern void objuncache(void);
|
|
extern int addelement(char *name);
|
|
extern void defineobject(char *name, int indices[], int count);
|
|
extern int checkobject(char *name);
|
|
extern void showobjfuncs(void);
|
|
extern void showobjtypes(void);
|
|
extern int findelement(char *name);
|
|
extern int objoffset(OBJECT *op, long index);
|
|
|
|
|
|
/*
|
|
* Configuration parameter name and type.
|
|
*/
|
|
extern NAMETYPE configs[];
|
|
extern void config_value(CONFIG *cfg, int type, VALUE *ret);
|
|
extern void setconfig(int type, VALUE *vp);
|
|
extern void config_print(CONFIG *cfg); /* the CONFIG to print */
|
|
|
|
|
|
/*
|
|
* size, memsize and sizeof support
|
|
*/
|
|
extern long elm_count(VALUE *vp);
|
|
extern long lsizeof(VALUE *vp);
|
|
extern long memsize(VALUE *vp);
|
|
|
|
/*
|
|
* String functions
|
|
*/
|
|
extern STRING *stringadd(STRING *, STRING *);
|
|
extern STRING *stringcopy(STRING *);
|
|
extern STRING *stringsub(STRING *, STRING *);
|
|
extern STRING *stringmul(NUMBER *, STRING *);
|
|
extern STRING *stringand(STRING *, STRING *);
|
|
extern STRING *stringor(STRING *, STRING *);
|
|
extern STRING *stringxor(STRING *, STRING *);
|
|
extern STRING *stringdiff(STRING *, STRING *);
|
|
extern STRING *stringsegment(STRING *, long, long);
|
|
extern STRING *stringshift(STRING *, long);
|
|
extern STRING *stringcomp(STRING *);
|
|
extern STRING *stringneg(STRING *);
|
|
extern STRING *stringcpy(STRING *, STRING *);
|
|
extern STRING *stringncpy(STRING *, STRING *, long);
|
|
extern long stringcontent(STRING *s);
|
|
extern long stringlowbit(STRING *s);
|
|
extern long stringhighbit(STRING *s);
|
|
extern BOOL stringcmp(STRING *, STRING *);
|
|
extern BOOL stringrel(STRING *, STRING *);
|
|
extern int stringbit(STRING *, long);
|
|
extern BOOL stringtest(STRING *);
|
|
extern int stringsetbit(STRING *, long, BOOL);
|
|
extern int stringsearch(STRING *, STRING *, long, long, ZVALUE *);
|
|
extern int stringrsearch(STRING *, STRING *, long, long, ZVALUE *);
|
|
|
|
#endif /* !__VALUE_H__ */
|