APPENDIX A: CURRENT ORGANIZATIONS AND OPERATIONS IN C AND C++

ZZ_ORG_SINGLE_RING(id,type); ZZ_HYPER_SINGLE_RING(id,type);

type *entry,*p;
int (cmpF*)(const void*,const void*);

ZZ_ORG_DOUBLE_RING(id,type); ZZ_HYPER_DOUBLE_RING(id,type);

type *entry,*p,*next;
int (cmpF*)(const void*,const void*);

ZZ_ORG_SINGLE_TRIANGLE (id,parT,chiT); ZZ_HYPER_SINGLE_TRIANGLE(id,parT,chiT);

parT *p,*p1,*p2;
chiT *c,*s;
int (cmpF*)(const void*,const void*);

ZZ_ORG_SINGLE_COLLECT(id,parT,chiT); ZZ_HYPER_SINGLE_COLLECT(id,parT,chiT);

parT *p,*p1,*p2;
chiT *c,*s;
int (cmpF*)(const void*,const void*);

ZZ_ORG_DOUBLE_COLLECT(id,parT,chiT); ZZ_HYPER_DOUBLE_COLLECT(id,parT,chiT);

parT *p,*p1,*p2;
chiT *c,*s;
int (cmpF*)(const void*,const void*);

ZZ_ORG_NAME(id,type); ZZ_HYPER_NAME(id,type);

type *p;
char *n;

ZZ_ORG_SINGLE_LINK(id,sourT,targT); ZZ_HYPER_SINGLE_LINK(id,sourT,targT);

sourT *s;
targT *t;

ZZ_ORG_LIFO(id,type); ZZ_HYPER_LIFO(id,type);

type *p; /* an object */
type *entry; /* entry into the stack */

ZZ_ORG_FIFO(id,type); ZZ_HYPER_FIFO(id,type);

type *p; /* an object */
type *entry; /* entry into the stack */

ZZ_ORG_DOUBLE_LINK(id,sourT,targT); ZZ_HYPER_DOUBLE_LINK(id,sourT,targT);

sourT *s;
targT *t;

ZZ_ORG_GENERAL_LINK(id,sourT); ZZ_HYPER_GENERAL_LINK(id,sourT);

sourT *s;
char *t;

ZZ_ORG_REFERENCE(id,sourT,targT); ZZ_HYPER_REFERENCE(id,sourT,targT);

sourT *s; targT *t; int count;

ZZ_ORG_SINGLE_TREE(id,obj); ZZ_HYPER_SINGLE_TREE(id,obj);

obj *p,*c,*s;

ZZ_ORG_DOUBLE_TREE(id,obj); ZZ_HYPER_DOUBLE_TREE(id,obj);

obj *p,*c,*s;

ZZ_ORG_SINGLE_GRAPH(id,vertex,edge); ZZ_HYPER_SINGLE_GRAPH(id,vertex,edge);

vertex *v,*t[2];
edge *e,*s;

ZZ_ORG_DIRECT_GRAPH(id,vertex,edge); ZZ_HYPER_DIRECT_GRAPH(id,vertex,edge);

vertex *v,*t[2];
edge *e,*s;

ZZ_ORG_1_TO_1(id,srs,rel,targ); ZZ_HYPER_1_TO_1(id,src,rel,targ);

ZZ_ORG_1_TO_N(id,src,rel,targ); ZZ_HYPER_1_TO_N(id,src,rel,targ);

ZZ_ORG_M_TO_1(id,src,rel,targ); ZZ_HYPER_M_TO_1(id,src,rel,targ);

ZZ_ORG_M_TO_N(id,src,rel,targ); ZZ_HYPER_M_TO_N(id,src,rel,targ);

Source *s; Relation *r; Target *t;

ZZ_ORG_ARRAY(id,holder,obj); ZZ_HYPER_ARRAY(id,holder,obj);

int sz,incr,wMark;			/* size, increment, waterMark */
int i; 					/* index */
int (cmpF*)(const void*,const void*); 	/* function to compare two objects */
void (bck*)(void *,int); 		/* callback function */
holder *hp;
obj *a; 				/* start of the array */
obj *e; 				/* pointer to an object/array */
obj r; 					/* element of the array */
void *vp;				/* pointer to be NULL or undetermined value*/

ZZ_HYPER_HASH(id,holder,obj); ZZ_HYPER_HASH(id,holder,obj);

int sz,num,slot;	/* size, number, slot */
holder *hp;		/* holder object */
obj *p,*s;		/* objects */
obj *t;			/* object template with a search key */
void *vp;		/* pointer to be NULL or undetermined value*/

ZZ_ORG_TIME_STAMP(obj); ZZ_HYPER_TIME_STAMP(obj);

char ts[6]; /* time record, byte encoded numbers: Y M D H M S */
obj *p,*s; /* two objects */

ZZ_ORG_PROPERTY(obj); ZZ_HYPER_PROPERTY(obj);

TEXT prop;	/* property type, for example: int */
char *pTyp;	/* property type as string, for example:"int"*/ 
obj *p;		/* given object */
char *label;	/* property label */
char **val;	/* property value always treated as an array */
int n;		/* size of the array */
FILE *fp;	/* output file for the print */

ZZ_ORG_PAGER(id,hp); ZZ_HYPER_PAGER(id,hp);

Holder *hp;		/* holder object */
char *fn;		/* file name */
int ps;			/* page size */
int np;			/* number of pages */
int ii;			/* 0= not initialized, 1= by '\0', 2= by' ' */ 
long ind;		/* byte address within the file */
char *buff;		/* memory buffer */
int n;			/* object size */
int mode;		/* 0=read 1=write */
char *ptr;		/* returned pointer to 'ind' location */

ZZ_HYPER_TYPE(id);

This organization works in C++ only

int n;				// total number of types used
int tp,tt;			// index into the internal type table
text objType;			// object type
void *vp;			// object pointer
void **vv;			// pointer to a pointer
void *r1,*r2;			// range limits of the v.f.table
zzTypeInfo inf;			// type info structure

n=id.num();			// returns number of types
tp=ZZgetType(objType);		// gets type index
id.trueType(&vp,&tp);		// updates vp and tp to the
true pointer and type id.info(tp,&inf);// returns info for type tp
id.virtRange(&r1,&r2);		// returns the range of v.f.pointers for all types
id_iterate it(tp);		// iterates through the base classes and members of tp

while((tt= ++it)=0){ ... }

type_pointers ptrs(vp,tp);	// traverse HYPER pointers on vp
while(vv= ++ptrs){ ... }

struct zzTypeInfo {		// structure which keeps the type info 
char *name;			// class name
int size;			// size of this class
char *mask1;			// 0-filled object with correct v.f/v.c. pointers
char *mask2;			// 'F' or 'C' for bytes that start v.f./v.c. pointers
int virt;			// bin packed:
	// 01=abstr.class,02=virt.base class,04=virt.functions present
};

ZZ_ORG_UTILITIES(id); ZZ_HYPER_UTILITIES(id);

char *s,*p;		/* strings */
int i,mSz,pSz;		/* int memory size, page size */
int fmt,mode,ver;	/* format, mode, and version for open/save */ 
char *file;
int fc;			/*file control */
char *bn;		/* name or address of memory block */
void *hook;		/* hook to private data */
char *obj;		/* general object */
FILE *fp;		/* file to print on */
char *lb,*tp;		/* label and type of the property */
void *val;		/* array of property values */
int n;			/* size of the property array */
void fun(char *obj,int typeInd,int size,char *priv);
type *r;

int n;      /* number of key entries (roots) */
void* v[]; /* array of pointers to key entries */
char* t[]; /* array of type names for key entries */

Chapter 19: Revision History

Appendix B: References