From b026f85683cafd682e19afe98ac38a6db4ae3394 Mon Sep 17 00:00:00 2001 From: Dave Beazley Date: Tue, 3 Aug 1999 22:39:23 +0000 Subject: [PATCH] Initial revision git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@2 626c5289-ae23-0410-ae9c-e8d60b6d4f22 --- SWIG/Source/DOH/Doh/Makefile | 56 +++ SWIG/Source/DOH/Doh/Makefile.in | 95 +++++ SWIG/Source/DOH/Doh/base.c | 623 ++++++++++++++++++++++++++++ SWIG/Source/DOH/Doh/file.c | 194 +++++++++ SWIG/Source/DOH/Doh/hash.c | 492 ++++++++++++++++++++++ SWIG/Source/DOH/Doh/list.c | 360 +++++++++++++++++ SWIG/Source/DOH/Doh/main.c | 30 ++ SWIG/Source/DOH/Doh/string.c | 697 ++++++++++++++++++++++++++++++++ SWIG/Source/DOH/Include/doh.h | 261 ++++++++++++ 9 files changed, 2808 insertions(+) create mode 100644 SWIG/Source/DOH/Doh/Makefile create mode 100644 SWIG/Source/DOH/Doh/Makefile.in create mode 100644 SWIG/Source/DOH/Doh/base.c create mode 100644 SWIG/Source/DOH/Doh/file.c create mode 100644 SWIG/Source/DOH/Doh/hash.c create mode 100644 SWIG/Source/DOH/Doh/list.c create mode 100644 SWIG/Source/DOH/Doh/main.c create mode 100644 SWIG/Source/DOH/Doh/string.c create mode 100644 SWIG/Source/DOH/Include/doh.h diff --git a/SWIG/Source/DOH/Doh/Makefile b/SWIG/Source/DOH/Doh/Makefile new file mode 100644 index 000000000..3542e211f --- /dev/null +++ b/SWIG/Source/DOH/Doh/Makefile @@ -0,0 +1,56 @@ +####################################################################### +# $Header$ +# Simplified Wrapper and Interface Generator (SWIG) +# +# Makefile for version 1.0 Final +# Dave Beazley +# August 1, 1996 +# +####################################################################### + +#.KEEP_STATE: + +# Set your C++ compiler here. g++ works on most machines, +# but you might have to change it depending on your installation. +# +CC = cc +prefix = /usr/local + +# Comment out the following line if you're on an SGI or don't have ranlib! +RANLIB = ranlib +AR = ar + +######################################################################## +# Normally, you shouldn't have to change anything below this point # +######################################################################## + +LIBOBJS = base.o file.o list.o hash.o string.o + +LIBSRCS = base.c file.c list.c hash.c string.c + +LIBHEADERS = ../Include/doh.h +LIB = ../libdoh.a +INCLUDE = -I../Include +CFLAGS = +SHELL = /bin/sh + +# +# +# +# Rules for creation of a .o file from .cxx +.SUFFIXES: .c +.c.o: + $(CC) $(INCLUDE) $(CFLAGS) -c -o $*.o $< + +all: $(LIB) + +$(LIB): $(LIBOBJS) + @echo "Building library" + $(AR) cr $(LIB) $(LIBOBJS) + $(RANLIB) $(LIB) + +clean:: + rm -f *.o ../libdoh.a +nuke:: + rm -f Makefile *~ #* core a.out + diff --git a/SWIG/Source/DOH/Doh/Makefile.in b/SWIG/Source/DOH/Doh/Makefile.in new file mode 100644 index 000000000..3f30259bc --- /dev/null +++ b/SWIG/Source/DOH/Doh/Makefile.in @@ -0,0 +1,95 @@ +####################################################################### +# $Header$ +# Simplified Wrapper and Interface Generator (SWIG) +# +# Makefile for version 1.0 Final +# Dave Beazley +# August 1, 1996 +# +####################################################################### + +#.KEEP_STATE: + + +srcdir = @srcdir@ +VPATH = @srcdir@ + +# Set your C++ compiler here. g++ works on most machines, +# but you might have to change it depending on your installation. +# +CC = @CC@ + +# +# Set the prefix below to indicate where you want SWIG to install its +# files. Normally this is /usr/local +# + +prefix = @prefix@ + +# Location of the SWIG library. Is normally put in /usr/local/lib/swig_lib +# The SWIG library contains configuration files and library modules +# so you should install it someplace where it can be easily accessed. + +SWIG_LIB = $(prefix)/lib/@SWIGLIBDIR@ + +# YACC parser. Use bison by default. if this doesn't work, switch +# it over to yacc. If that still doesn't work, let me know... + +YACC = @YACC@ + +# Comment out the following line if you're on an SGI or don't have ranlib! +RANLIB = @RANLIB@ +AR = @AR@ + +######################################################################## +# Normally, you shouldn't have to change anything below this point # +######################################################################## + + +LIBOBJS = scanner.o parms.o types.o error.o module.o getopt.o file.o string.o list.o hash.o base.o main.o + +LIBSRCS = scanner.c parms.c types.c error.c module.c getopt.c file.c string.c list.c hash.c base.c main.c + +LIBHEADERS = ../Include/swig.h +LIB = ../libswig.a +PARSER = parser.y +INCLUDE = -I../Include +CFLAGS = @CFLAGS@ -DSWIG_LIB='"$(SWIG_LIB)"' -DSWIG_CC='"$(CC)"' @DEFS@ +SHELL = /bin/sh + +# +# +# +# Rules for creation of a .o file from .cxx +.SUFFIXES: .c +.c.o: + $(CC) $(INCLUDE) $(CFLAGS) -c -o $*.o $< + +all: + @cd ..; $(MAKE) + + +build: $(LIB) + #$(CC) $(LIBOBJS) -o swig -ldl + +py: $(LIB) + /usr/local/bin/swig -python -o swig_wrap.c ../Include/swig.h + $(CC) $(INCLUDE) -I/usr/local/include/python1.5 $(CFLAGS) -c swig_wrap.c + ld -G $(LIBOBJS) swig_wrap.o -o swigmodule.so + +$(LIB): $(LIBOBJS) + @echo "Building library" + $(AR) cr $(LIB) $(LIBOBJS) + $(RANLIB) $(LIB) + +Makefile: $(srcdir)/Makefile.in ../config.status + (cd ..; CONFIG_FILES=SWIG/Makefile $(SHELL) config.status) + +.PRECIOUS: Makefile + +clean:: + rm -f *.o libswig.a y.tab.c y.tab.h + +nuke:: + rm -f Makefile *~ #* core a.out + diff --git a/SWIG/Source/DOH/Doh/base.c b/SWIG/Source/DOH/Doh/base.c new file mode 100644 index 000000000..90a97cda6 --- /dev/null +++ b/SWIG/Source/DOH/Doh/base.c @@ -0,0 +1,623 @@ +/**************************************************************************** + * DOH (Dynamic Object Hack) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + ****************************************************************************/ + +/******************************************************************************* + * $Header$ + * + * File : base.c + * + * Methods for base objects + *******************************************************************************/ + +#include "doh.h" + +static DohObjInfo DohBaseType = { + "Base", /* objname */ + 0, /* objsize */ + 0, /* doh_del */ + 0, /* doh_copy */ + 0, /* doh_clear */ + 0, /* doh_str */ + 0, /* doh_aschar */ + 0, /* doh_len */ + 0, /* doh_hash */ + 0, /* doh_cmp */ + 0, /* doh_mapping */ + 0, /* doh_sequence */ + 0, /* doh_file */ + 0, /* reserved2 */ + 0, /* reserved3 */ + 0, /* reserved4 */ + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, +}; + +int DohCheck(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!b) return 0; + if (b->magic != DOH_MAGIC) return 0; + if (!b->objinfo) return 0; + return 1; +} + +int DohIsMapping(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return 0; + if (b->objinfo->doh_mapping) return 1; + else return 0; +} + +int DohIsSequence(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return 0; + if (b->objinfo->doh_sequence) return 1; + else return 0; +} + +/* ----------------------------------------------------------------------------- + String objects + + The following structure maps raw char * entries to string objects. + ----------------------------------------------------------------------------- */ + +typedef struct StringNode { + char *cstr; + DOH *sstr; + struct StringNode *left; + struct StringNode *right; +} StringNode; + +static StringNode *root = 0; + +static DOH *find_internal(DOH *co) { + StringNode *r, *s; + int d; + char *c; + if (DohCheck(co)) return co; + c = (char *) co; + r = root; + s = 0; + while (r) { + s = r; + /* printf("checking %s\n", r->cstr);*/ + d = strcmp(r->cstr,c); + if (d == 0) return r->sstr; + if (d < 0) r = r->left; + else r = r->right; + } + r = (StringNode *) malloc(sizeof(StringNode)); + r->cstr = (char *) malloc(strlen(c)+1); + strcpy(r->cstr,c); + r->sstr = NewString(c); + Incref(r->sstr); + r->left = 0; + r->right = 0; + if (!s) { root = r; } + else { + if (d < 0) s->left = r; + else s->right = r; + } + return r->sstr; +} + +/* Destroy an object */ +void DohDestroy(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return; + b->refcount--; + if (b->refcount <= 0) { + if (b->objinfo->doh_del) { + (b->objinfo->doh_del)(obj); + return; + } + free(b); + } +} + +/* Copy an object */ +DOH *DohCopy(DOH *obj) { + DOH *result; + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return 0; + if (b->objinfo->doh_copy) { + return (b->objinfo->doh_copy)(obj); + } + printf("No copy method defined for type '%s'\n", b->objinfo->objname); + return 0; +} + +void DohClear(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return; + if (b->objinfo->doh_clear) { + (b->objinfo->doh_clear)(obj); + return; + } + printf("No clear method defined for type '%s'\n", b->objinfo->objname); +} + +/* Turn an object into a string */ +DOH *DohStr(DOH *obj) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohCheck(b)) { + if (b->objinfo->doh_str) { + return (b->objinfo->doh_str)(b); + } + s = NewString("", b->objinfo->objname, b); + return s; + } else { + return NewString(obj); + } +} + +/* Get the length */ +int DohLen(DOH *obj) { + int s; + DohBase *b = (DohBase *) obj; + if (DohCheck(b)) { + if (b->objinfo->doh_len) { + return (b->objinfo->doh_len)(obj); + } + } + printf("No len method defined for type '%s'\n", b->objinfo->objname); + return 0; +} + +/* Get the hash value */ +int DohHashval(DOH *obj) { + int s; + DohBase *b = (DohBase *) obj; + if (DohCheck(b)) { + if (b->objinfo->doh_hash) { + return (b->objinfo->doh_hash)(obj); + } + printf("No hash method defined for type '%s'\n", b->objinfo->objname); + } + return 0; +} + +/* Get raw data */ +void *DohData(DOH *obj) { + char *c; + char *s; + DohBase *b = (DohBase *) obj; + c = (char *) obj; + if (!c) return 0; + if (*c == DOH_MAGIC) { + if (b->objinfo) { + if (b->objinfo->doh_data) { + return (b->objinfo->doh_data)(obj); + } + } + printf("No data method defined for type '%s'\n", b->objinfo->objname); + return 0; + } + return c; +} + +/* Get the line number */ +int DohGetline(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (DohCheck(obj)) { + return b->line; + } + return 0; +} + +/* Set the line number */ +void DohSetline(DOH *obj, int line) { + DohBase *b = (DohBase *) obj; + if (DohCheck(obj)) { + b->line = line; + } +} + +/* Get the file name */ +DOH *DohGetfile(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (DohCheck(obj)) { + return b->file; + } + return 0; +} + +/* Set the file */ +void DohSetfile(DOH *obj, DOH *file) { + DOH *nf; + DohBase *b = (DohBase *) obj; + if (DohCheck(obj)) { + if (file) { + nf = find_internal(file); + Incref(nf); + if (b->file) Delete(b->file); + b->file = nf; + } else { + Delete(b->file); + b->file = 0; + } + } +} + +/* Get an attribute from an object */ +int DohCmp(DOH *obj1, DOH *obj2) { + int s; + DohBase *b1, *b2; + b1 = (DohBase *) obj1; + b2 = (DohBase *) obj2; + if (!DohCheck(b1)) { + b1 = find_internal(b1); + } + if (!DohCheck(b2)) { + b2 = find_internal(b2); + } + if (b1->objinfo == b2->objinfo) { + if (b1->objinfo->doh_cmp) { + return (b1->objinfo->doh_cmp)(b1,b2); + } + printf("No cmp method defined for type '%s'\n", b1->objinfo->objname); + } + printf("Can't compare type '%s' with type '%s'\n", b1->objinfo->objname, b2->objinfo->objname); + return 0; +} + +/* ---------------------------------------------------------------------- + * Mapping Interface + * ---------------------------------------------------------------------- */ + +/* Get an attribute from an object */ +DOH *DohGetattr(DOH *obj, DOH *name) { + DOH *s; + DOH *name_obj; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(b)) { + name_obj = find_internal(name); + if (b->objinfo->doh_mapping->doh_getattr) { + return (b->objinfo->doh_mapping->doh_getattr)(obj,name_obj); + } + return 0; + } + return 0; +} + +/* Set an attribute in an object */ +int DohSetattr(DOH *obj, DOH *name, DOH *value) { + int s; + DOH *name_obj, *value_obj; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(b)) { + name_obj = find_internal(name); + value_obj = find_internal(value); + if (b->objinfo->doh_mapping->doh_setattr) { + return (b->objinfo->doh_mapping->doh_setattr)(obj,name_obj,value_obj); + } + printf("No setattr method defined for type '%s'\n", b->objinfo->objname); + } + return 0; +} + +/* Delete an attribute from an object */ +void DohDelattr(DOH *obj, DOH *name) { + DOH *name_obj; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(obj)) { + name_obj = find_internal(name); + if (b->objinfo->doh_mapping->doh_delattr) { + (b->objinfo->doh_mapping->doh_delattr)(obj,name_obj); + return; + } + printf("No delattr method defined for type '%s'\n", b->objinfo->objname); + } +} + + +/* Get first item in an object */ +DOH *DohFirst(DOH *obj) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(obj)) { + if (b->objinfo->doh_mapping->doh_firstkey) { + return DohGetattr(obj,(b->objinfo->doh_mapping->doh_firstkey)(obj)); + } + printf("No firstkey method defined for type '%s'\n", b->objinfo->objname); + return 0; + } + return 0; +} + +/* Get next item in an object */ +DOH *DohNext(DOH *obj) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(obj)) { + if (b->objinfo->doh_mapping->doh_nextkey) { + return DohGetattr(obj,(b->objinfo->doh_mapping->doh_nextkey)(obj)); + } + printf("No nextkey method defined for type '%s'\n", b->objinfo->objname); + return 0; + } + return 0; +} + + +/* Get first item in an object */ +DOH *DohFirstkey(DOH *obj) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(obj)) { + if (b->objinfo->doh_mapping->doh_firstkey) { + return (b->objinfo->doh_mapping->doh_firstkey)(obj); + } + printf("No firstkey method defined for type '%s'\n", b->objinfo->objname); + return 0; + } + return 0; +} + +/* Get next item in an object */ +DOH *DohNextkey(DOH *obj) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohIsMapping(obj)) { + if (b->objinfo->doh_mapping->doh_nextkey) { + return (b->objinfo->doh_mapping->doh_nextkey)(obj); + } + printf("No nextkey method defined for type '%s'\n", b->objinfo->objname); + return 0; + } + return 0; +} + +/* ---------------------------------------------------------------------- + * Sequence Interface + * ---------------------------------------------------------------------- + +/* Get an item from an object */ +DOH *DohGetitem(DOH *obj, int index) { + DOH *s; + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_getitem) { + return (b->objinfo->doh_sequence->doh_getitem)(obj,index); + } + printf("No getitem method defined for type '%s'\n", b->objinfo->objname); + } + return 0; +} + +/* Set an item in an object */ +void DohSetitem(DOH *obj, int index, DOH *value) { + DOH *value_obj; + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + value_obj = find_internal(value); + if (b->objinfo->doh_sequence->doh_setitem) { + (b->objinfo->doh_sequence->doh_setitem)(obj,index,value_obj); + return; + } + printf("No setitem method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Delete an item from an object */ +void DohDelitem(DOH *obj, int index) { + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_delitem) { + (b->objinfo->doh_sequence->doh_delitem)(obj,index); + return; + } + printf("No delitem method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Set an item in an object */ +void DohInsertitem(DOH *obj, int index, DOH *value) { + DOH *value_obj; + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + value_obj = find_internal(value); + if (b->objinfo->doh_sequence->doh_insitem) { + (b->objinfo->doh_sequence->doh_insitem)(obj,index,value_obj); + return; + } + printf("No insitem method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Set an item in an object */ +void DohInsertitemf(DOH *obj, int index, char *format, ...) { + va_list ap; + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_insertf) { + va_start(ap,format); + (b->objinfo->doh_sequence->doh_insertf)(obj,index,format,ap); + va_end(ap); + return; + } + printf("No insertf method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Set an item in an object */ +void DohvInsertitemf(DOH *obj, int index, char *format, va_list ap) { + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_insertf) { + (b->objinfo->doh_sequence->doh_insertf)(obj,index,format,ap); + return; + } + printf("No insertf method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Append an item to an object */ +void DohAppendf(DOH *obj, char *format, ...) { + va_list ap; + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_insertf) { + va_start(ap,format); + (b->objinfo->doh_sequence->doh_insertf)(obj,DOH_END,format,ap); + va_end(ap); + return; + } + printf("No appendf method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* Append an item to an object */ +void DohvAppendf(DOH *obj, char *format, va_list ap) { + DohBase *b = (DohBase *) obj; + if (DohIsSequence(obj)) { + if (b->objinfo->doh_sequence->doh_insertf) { + (b->objinfo->doh_sequence->doh_insertf)(obj,DOH_END,format,ap); + return; + } + printf("No appendf method defined for type '%s'\n", b->objinfo->objname); + } +} + +/* ----------------------------------------------------------------------------- + * File methods + * ----------------------------------------------------------------------------- */ + +int DohIsFile(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (!DohCheck(b)) return 0; + if (b->objinfo->doh_file) return 1; + else return 0; +} + +/* Read */ +int DohRead(DOH *obj, void *buffer, int length) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_read) { + return (b->objinfo->doh_file->doh_read)(obj,buffer,length); + } + printf("No read method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* Write */ +int DohWrite(DOH *obj, void *buffer, int length) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_write) { + return (b->objinfo->doh_file->doh_write)(obj,buffer,length); + } + printf("No write method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* Seek */ +int DohSeek(DOH *obj, long offset, int whence) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_seek) { + return (b->objinfo->doh_file->doh_seek)(obj,offset,whence); + } + printf("No seek method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* Tell */ +long DohTell(DOH *obj) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_tell) { + return (b->objinfo->doh_file->doh_tell)(obj); + } + printf("No tell method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* Printf */ +int DohPrintf(DOH *obj, char *format, ...) { + va_list ap; + int ret; + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_printf) { + va_start(ap,format); + ret = (b->objinfo->doh_file->doh_printf)(obj,format,ap); + va_end(ap); + return ret; + } + printf("No printf method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* vPrintf */ +int DohvPrintf(DOH *obj, char *format, va_list ap) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_printf) { + return (b->objinfo->doh_file->doh_printf)(obj,format,ap); + } + printf("No printf method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + + +/* Printf */ +int DohScanf(DOH *obj, char *format, ...) { + va_list ap; + int ret; + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_scanf) { + va_start(ap,format); + ret = (b->objinfo->doh_file->doh_scanf)(obj,format,ap); + va_end(ap); + return ret; + } + printf("No scanf method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + +/* vPrintf */ +int DohvScanf(DOH *obj, char *format, va_list ap) { + DohBase *b = (DohBase *) obj; + if (DohIsFile(obj)) { + if (b->objinfo->doh_file->doh_scanf) { + return (b->objinfo->doh_file->doh_scanf)(obj,format,ap); + } + printf("No scanf method defined for type '%s'\n", b->objinfo->objname); + } + return -1; +} + + +void DohInit(DOH *b) { + DohBase *bs = (DohBase *) b; + bs->refcount =0; + bs->objinfo = &DohBaseType; + bs->magic = DOH_MAGIC; + bs->moremagic[0] = 0; + bs->moremagic[1] = 0; + bs->moremagic[2] = 0; + bs->line = 0; + bs->file = 0; +} diff --git a/SWIG/Source/DOH/Doh/file.c b/SWIG/Source/DOH/Doh/file.c new file mode 100644 index 000000000..d39583c28 --- /dev/null +++ b/SWIG/Source/DOH/Doh/file.c @@ -0,0 +1,194 @@ +/**************************************************************************** + * DOH (Dynamic Object Hack) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + ****************************************************************************/ + +#include "doh.h" + +/* --------------------------------------------------------------------------- + * $Header$ + * string.c + * + * String support. + * --------------------------------------------------------------------------- */ + +typedef struct File { + DOHCOMMON; + FILE *filep; +} File; + +/* Forward references */ + +void DelFile(DOH *s); +int File_read(DOH *s, void *buffer, int length); +int File_write(DOH *s, void *buffer, int length); +int File_seek(DOH *s, long offset, int whence); +long File_tell(DOH *s); +int File_printf(DOH *s, char *fmt, va_list ap); + +static DohFileMethods FileFileMethods = { + File_read, + File_write, + File_seek, + File_tell, + File_printf, +}; + +static DohObjInfo FileType = { + "File", /* objname */ + 0, + DelFile, /* sm_del */ + 0, /* sm_copy */ + 0, /* sm_clear */ + 0, /* sm_str */ + 0, /* doh_data */ + 0, /* sm_len */ + 0, /* sm_hash */ + 0, /* doh_cmp */ + 0, /* doh_mapping */ + 0, /* doh_sequence */ + &FileFileMethods,/* doh_file */ + 0, + 0, + 0, + 0, +}; + +DohObjInfo *File_type() { + return &FileType; +} + +/* ----------------------------------------------------------------------------- + * NewFile(char *filename, char *mode) + * ----------------------------------------------------------------------------- */ +DOH * +NewFile(char *filename, char *mode) +{ + File *f; + FILE *file; + file = fopen(filename,mode); + if (!file) return 0; + + f = (File *) malloc(sizeof(File)); + DohInit(f); + f->objinfo = &FileType; + f->filep = file; + return (DOH *) f; +} + +/* ----------------------------------------------------------------------------- + * NewFileFromFile(FILE *f) + * + * ----------------------------------------------------------------------------- */ + +DOH * +NewFileFromFile(FILE *file) +{ + File *f; + f = (File *) malloc(sizeof(File)); + DohInit(f); + f->objinfo = &FileType; + f->filep = file; + return (DOH *) f; +} + +/* ----------------------------------------------------------------------------- + * DelFile(DOH *s) - Delete a file + * ----------------------------------------------------------------------------- */ +void +DelFile(DOH *so) { + File *f = (File *) so; + assert(f->refcount <= 0); + fclose(f->filep); + free(f); +} + +/* ----------------------------------------------------------------------------- + * int File_check(DOH *f) - Check if f is a file + * ----------------------------------------------------------------------------- */ +int +File_check(DOH *f) +{ + return 0; +} + +/* ----------------------------------------------------------------------------- + * int File_read(DOH *so, void *buffer, int len) + * + * Read data from the File + * ----------------------------------------------------------------------------- */ +int +File_read(DOH *so, void *buffer, int len) { + File *s = (File *) so; + return (size_t) fread(buffer,len,1,s->filep); +} + +/* ----------------------------------------------------------------------------- + * int File_write(DOH *so, void *buffer, int len) + * + * Write data to the File + * ----------------------------------------------------------------------------- */ +int +File_write(DOH *so, void *buffer, int len) { + File *s = (File *) so; + return (size_t) fwrite(buffer,len,1,s->filep); +} + +/* ----------------------------------------------------------------------------- + * int File_seek(DOH *so, long offset, int whence) + * + * Seek to a new position + * ----------------------------------------------------------------------------- */ +int +File_seek(DOH *so, long offset, int whence) { + File *s = (File *) so; + return fseek(s->filep,offset,whence); +} + +/* ----------------------------------------------------------------------------- + * long File_tell(DOH *so) + * + * Return current position + * ----------------------------------------------------------------------------- */ +long +File_tell(DOH *so) { + File *s = (File *) so; + return ftell(s->filep); +} + +/* ----------------------------------------------------------------------------- + * int File_printf(DOH *so, char *format, ...) + * + * ----------------------------------------------------------------------------- */ + +int +File_printf(DOH *so, char *format, va_list ap) +{ + int len, wlen; + DOH *nso; + File *s = (File *) so; + nso = NewString(""); + vAppendf(nso,format,ap); + len = Len(nso); + wlen = File_write(so,Data(nso),len); + Delete(nso); + return wlen; +} + + + + + + + + diff --git a/SWIG/Source/DOH/Doh/hash.c b/SWIG/Source/DOH/Doh/hash.c new file mode 100644 index 000000000..702b3b152 --- /dev/null +++ b/SWIG/Source/DOH/Doh/hash.c @@ -0,0 +1,492 @@ +/**************************************************************************** + * Simplified Wrapper and Interface Generator (SWIG) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + ****************************************************************************/ + +#include "doh.h" + +/*********************************************************************** + * $Header$ + * + * hash.c + * + * Hash table implementation. + ***********************************************************************/ + +/* Hash node */ +typedef struct HashNode { + DOH *key; + DOH *object; + struct HashNode *next; +} HashNode; + +/* Hash object */ +typedef struct Hash { + DOHCOMMON; + HashNode **hashtable; + int hashsize; + int currentindex; + int nitems; + HashNode *current; +} Hash; + +/* Forward references */ +DOH *CopyHash(DOH *h); +void DelHash(DOH *h); +void Hash_clear(DOH *); +int Hash_setattr(DOH *, DOH *k, DOH *obj); +DOH *Hash_getattr(DOH *h, DOH *k); +int Hash_delattr(DOH *h, DOH *k); +DOH *Hash_firstkey(DOH *h); +DOH *Hash_nextkey(DOH *h); +DOH *Hash_str(DOH *h); +int Hash_len(DOH *h); + +#define HASH_INIT_SIZE 7 + +static HashNode *NewNode(DOH *k, void *obj) +{ + HashNode *hn = (HashNode *) malloc(sizeof(HashNode)); + hn->key = k; + Incref(hn->key); + hn->object = obj; + Incref(obj); + hn->next = 0; + return hn; +} + +static void DelNode(HashNode *hn) +{ + Delete(hn->key); + Delete(hn->object); + free(hn); +} + + +static DohMappingMethods HashMappingMethods = { + Hash_getattr, + Hash_setattr, + Hash_delattr, + Hash_firstkey, + Hash_nextkey, +}; + +static DohObjInfo HashType = { + "Hash", /* objname */ + 0, + DelHash, /* sm_del */ + CopyHash, /* sm_copy */ + Hash_clear, /* sm_clear */ + Hash_str, /* sm_str */ + 0, /* doh_data */ + Hash_len, /* sm_len */ + 0, /* sm_hash */ + 0, /* doh_cmp */ + &HashMappingMethods, /* doh_mapping */ + 0, /* doh_sequence */ + 0, + 0, + 0, + 0, + 0, +}; + +DohObjInfo *Hash_type() { + return &HashType; +} + +int Hash_check(DOH *so) { + Hash *h = (Hash *) so; + if (!h) return 0; + if (h->magic != DOH_MAGIC) return 0; + if (h->objinfo != &HashType) return 0; + return 1; +} + +/* ----------------------------------------------------------------------------- + * NewHash() - Create a new hash table + * ----------------------------------------------------------------------------- */ + +DOH *NewHash() { + Hash *h; + int i; + h = (Hash *) malloc(sizeof(Hash)); + DohInit(h); + h->hashsize = HASH_INIT_SIZE; + h->hashtable = (HashNode **) malloc(h->hashsize*sizeof(HashNode *)); + for (i = 0; i < h->hashsize; i++) { + h->hashtable[i] = 0; + } + h->currentindex = -1; + h->current = 0; + h->nitems = 0; + h->objinfo = &HashType; + return (DOH *) h; +} + +/* ----------------------------------------------------------------------------- + * DOH *CopyHash(DOH *ho) - Copy a hash table + * ----------------------------------------------------------------------------- */ + +DOH *CopyHash(DOH *ho) { + Hash *h, *nh; + HashNode *n; + int i; + DOH *key; + + h = (Hash *) ho; + nh = (Hash *) malloc(sizeof(Hash)); + DohInit(nh); + + nh->hashsize = h->hashsize; + nh->hashtable = (HashNode **) malloc(nh->hashsize*sizeof(HashNode *)); + for (i = 0; i < nh->hashsize; i++) { + nh->hashtable[i] = 0; + } + nh->currentindex = -1; + nh->current = 0; + nh->nitems = 0; + nh->objinfo = h->objinfo; + + for (i = 0; i < h->hashsize; i++) { + if (n = h->hashtable[i]) { + while (n) { + Hash_setattr(nh, n->key, n->object); + n = n->next; + } + } + } + return (DOH *) nh; +} + +/* ----------------------------------------------------------------------------- + * DelHash() - Delete a hash table + * ----------------------------------------------------------------------------- */ + +void DelHash(DOH *ho) +{ + Hash *h; + HashNode *n,*next; + int i; + + h = (Hash *) ho; + for (i = 0; i < h->hashsize; i++) { + if (n = h->hashtable[i]) { + while (n) { + next = n->next; + DelNode(n); + n = next; + } + } + } + free(h->hashtable); + free(h); +} + +/* ----------------------------------------------------------------------------- + * Hash_clear(DOH *ho) - Clear all entries in a hash table + * ----------------------------------------------------------------------------- */ + +void Hash_clear(DOH *ho) +{ + Hash *h; + HashNode *n,*next; + int i; + + h = (Hash *) ho; + for (i = 0; i < h->hashsize; i++) { + if (n = h->hashtable[i]) { + while (n) { + next = n->next; + DelNode(n); + n = next; + } + } + h->hashtable[i] = 0; + } + h->nitems = 0; +} + +/* ----------------------------------------------------------------------------- + * static resize(Hash *h) - Resizes the hash table + * ----------------------------------------------------------------------------- */ + +static void resize(Hash *h) { + HashNode *n, *next, **table; + int oldsize, newsize; + int i, p, hv; + + if (h->nitems < 2*h->hashsize) return; + + /* Too big. We have to rescale everything now */ + oldsize = h->hashsize; + + /* Calculate a new size */ + newsize = 2*oldsize+1; + p = 3; + while (p < (newsize >> 1)) { + if (((newsize/p)*p) == newsize) { + newsize+=2; + p = 3; + continue; + } + p = p + 2; + } + + table = (HashNode **) malloc(newsize*sizeof(HashNode *)); + for (i = 0; i < newsize; i++ ) { + table[i] = 0; + } + + /* Walk down the old set of nodes */ + + h->hashsize = newsize; + for (i = 0; i < oldsize; i++) { + n = h->hashtable[i]; + while (n) { + hv = Hashval(n->key) % newsize; + next = n->next; + n->next = table[hv]; + table[hv] = n; + n = next; + } + } + free(h->hashtable); + h->hashtable = table; +} + +/* ----------------------------------------------------------------------------- + * int Hash_setattr(DOH *h, DOH *k, DOH *obj) - Adds an object to a hash + * ----------------------------------------------------------------------------- */ + +int +Hash_setattr(DOH *ho, DOH *k, DOH *obj) { + int hv; + HashNode *n, *prev; + Hash *h; + + h = (Hash *) ho; + hv = (Hashval(k)) % h->hashsize; + n = h->hashtable[hv]; + prev = 0; + while (n) { + if (Cmp(n->key,k) == 0) { + HashNode *nn; + if (prev) { + prev->next = n->next; + h->hashtable[hv] = n->next; + } else { + h->hashtable[hv] = n->next; + } + nn = n->next; + DelNode(n); + h->nitems--; + n = nn; + } else { + prev = n; + n = n->next; + } + } + /* Add this to the table */ + n = NewNode(k,obj); + if (prev) prev->next = n; + else h->hashtable[hv] = n; + h->nitems++; + resize(h); + return 0; +} + +/* ----------------------------------------------------------------------------- + * DOH *Hash_getattr(DOH *ho, DOH *k) - Get an item from the hash table + * ----------------------------------------------------------------------------- */ + +DOH * +Hash_getattr(DOH *ho, DOH *k) { + int hv; + HashNode *n; + Hash *h; + + + h = (Hash *) ho; + hv = Hashval(k) % h->hashsize; + n = h->hashtable[hv]; + while (n) { + if (Cmp(n->key, k) == 0) return n->object; + n = n->next; + } + return 0; +} + +/* ----------------------------------------------------------------------------- + * void Hash_delattr(DOH *ho, DOH *k) - Delete an element from the table + * ----------------------------------------------------------------------------- */ + +int +Hash_delattr(DOH *ho, DOH *k) +{ + HashNode *n, *prev; + int hv; + Hash *h; + + h = (Hash *) ho; + hv = Hashval(k) % h->hashsize; + n = h->hashtable[hv]; + prev = 0; + while (n) { + if (Cmp(n->key, k) == 0) { + /* Found it, kill it */ + if (prev) { + prev->next = n->next; + } else { + h->hashtable[hv] = n->next; + } + DelNode(n); + h->nitems--; + return 1; + } + prev = n; + n = n->next; + } + return 0; +} + +/* ----------------------------------------------------------------------------- + * Iterators + * ----------------------------------------------------------------------------- */ + +static HashNode *hash_first(DOH *ho) { + Hash *h = (Hash *) ho; + h->currentindex = 0; + h->current = 0; + while (!h->hashtable[h->currentindex] && (h->currentindex < h->hashsize)) + h->currentindex++; + if (h->currentindex >= h->hashsize) return 0; + h->current = h->hashtable[h->currentindex]; + return h->current; +} + +static HashNode *hash_next(DOH *ho) { + Hash *h = (Hash *) ho; + if (h->currentindex < 0) return hash_first(h); + + /* Try to move to the next entry */ + h->current = h->current->next; + if (h->current) { + return h->current; + } + h->currentindex++; + while ((h->currentindex < h->hashsize) && !h->hashtable[h->currentindex]) + h->currentindex++; + if (h->currentindex >= h->hashsize) return 0; + h->current = h->hashtable[h->currentindex]; + return h->current; +} + +DOH * +Hash_first(DOH *ho) { + HashNode *hn = hash_first(ho); + if (hn) return hn->object; + return 0; +} + +DOH * +Hash_next(DOH *ho) +{ + HashNode *hn = hash_next(ho); + if (hn) return hn->object; + return 0; +} + +DOH * +Hash_firstkey(DOH *ho) +{ + HashNode *hn = hash_first(ho); + if (hn) return hn->key; + return 0; +} + +DOH * +Hash_nextkey(DOH *ho) +{ + HashNode *hn = hash_next(ho); + if (hn) return hn->key; + return 0; +} + +/* ----------------------------------------------------------------------------- + * String *Hash_str(DOH *ho) - Create a string representation of a hash + * ----------------------------------------------------------------------------- */ +DOH * +Hash_str(DOH *ho) { + int i; + HashNode *n; + DOH *s; + Hash *h; + + h = (Hash *) ho; +#ifdef OLD + s = NewString("Hash {\n"); + for (i = 0; i < h->hashsize; i++) { + n = h->hashtable[i]; + while (n) { + Appendf(s," '%o' : %o, \n", n->key, n->object); + n = n->next; + } + } + Append(s,"}\n"); +#else + s = NewString("Hash"); + Appendf(s,"(%x) {",h); + for (i = 0; i < h->hashsize; i++) { + n = h->hashtable[i]; + while (n) { + Appendf(s,"'%o',", n->key); + n = n->next; + } + } + Appendf(s,"}"); +#endif + return s; +} + +/* ----------------------------------------------------------------------------- + * Hash_len(DOH *) + * ----------------------------------------------------------------------------- */ + +int Hash_len(DOH *ho) { + Hash *h = (Hash *) ho; + return h->nitems; +} + +/* ----------------------------------------------------------------------------- + * Hash_keys(DOH *) + * + * Return a list of keys + * ----------------------------------------------------------------------------- */ + +DOH *Hash_keys(DOH *so) { + DOH *keys; + DOH *k; + + keys = NewList(); + k = Firstkey(so); + while (k) { + Append(keys,k); + k = Nextkey(so); + } + /* List_sort(keys); */ + return keys; +} + + + diff --git a/SWIG/Source/DOH/Doh/list.c b/SWIG/Source/DOH/Doh/list.c new file mode 100644 index 000000000..655203994 --- /dev/null +++ b/SWIG/Source/DOH/Doh/list.c @@ -0,0 +1,360 @@ +/**************************************************************************** + * Simplified Wrapper and Interface Generator (SWIG) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + ****************************************************************************/ + +/******************************************************************************* + * $Header$ + * + * File : list.c + * + * General purpose structure for keeping a list of reference counted Swig objects. + *******************************************************************************/ + +#include "doh.h" + +typedef struct List { + DOHCOMMON; + int maxitems; /* Max size */ + int nitems; /* Num items */ + int iter; /* Iterator */ + DOH **items; +} List; + +/* Forward references */ + +DOH *CopyList(DOH *); +void DelList(DOH *); +void List_clear(DOH *); +DOH *List_get(DOH *, int pos); +int List_set(DOH *, int pos, DOH *obj); +int List_insert(DOH *, int pos, DOH *item); +int List_remove(DOH *, int pos); +int List_len(DOH *); +DOH *List_first(DOH *); +DOH *List_next(DOH *); +DOH *List_str(DOH *); + +#define MAXLISTITEMS 8 + +static DohSequenceMethods ListSeqMethods = { + List_get, + List_set, + List_remove, + List_insert, + 0, + List_first, + List_next, +}; + +static DohObjInfo ListType = { + "List", /* objname */ + 0, + DelList, /* sm_del */ + CopyList, /* sm_copy */ + List_clear, /* sm_clear */ + List_str, /* sm_str */ + 0, /* doh_data */ + List_len, /* sm_len */ + 0, /* sm_hash */ + 0, /* doh_cmp */ + 0, /* doh_mapping */ + &ListSeqMethods, /* doh_sequence */ + 0, + 0, + 0, + 0, + 0, +}; + +DohObjInfo *List_type() { + return &ListType; +} + +/* Internal function. Doubles amount of memory in a list */ +static +void more(List *l) { + int i; + void **newitems; + + newitems = (void **) malloc(l->maxitems*2*sizeof(void *)); + for (i = 0; i < l->maxitems; i++) { + newitems[i] = l->items[i]; + } + for (i = l->maxitems; i < 2*l->maxitems; i++) { + newitems[i] = (void *) 0; + } + l->maxitems *= 2; + free(l->items); + l->items = newitems; +} + +/* ----------------------------------------------------------------------------- + * List_check(DOH *lo) - Check to see if an object is a list + * ----------------------------------------------------------------------------- */ + +int +List_check(DOH *lo) { + List *l = (List *) lo; + if (!l) return 0; + if (l->magic != DOH_MAGIC) return 0; + if (l->objinfo != &ListType) return 0; + return 1; +} + +/* ----------------------------------------------------------------------------- + * NewList() - Create a new list + * ----------------------------------------------------------------------------- */ + +DOH * +NewList() { + List *l; + int i; + l = (List *) malloc(sizeof(List)); + DohInit(l); + l->objinfo = &ListType; + l->nitems = 0; + l->maxitems = MAXLISTITEMS; + l->items = (void **) malloc(l->maxitems*sizeof(void *)); + for (i = 0; i < MAXLISTITEMS; i++) { + l->items[i] = 0; + } + l->iter = 0; + return (DOH *) l; +} + +/* ----------------------------------------------------------------------------- + * DOH *CopyList(DOH *l) - Copy a list + * ----------------------------------------------------------------------------- */ + +DOH * +CopyList(DOH *lo) { + List *l,*nl; + int i; + l = (List *) lo; + nl = (List *) malloc(sizeof(List)); + DohInit(nl); + nl->objinfo = l->objinfo; + nl->nitems = l->nitems; + nl->maxitems = l->maxitems; + nl->items = (void **) malloc(l->maxitems*sizeof(void *)); + nl->iter = 0; + for (i = 0; i < l->maxitems; i++) { + nl->items[i] = l->items[i]; + if (nl->items[i]) { + Incref(nl->items[i]); + } + } + return (DOH *) nl; +} + +/* ----------------------------------------------------------------------------- + * void DelList(DOH *l) - Delete a list + * ----------------------------------------------------------------------------- */ + +void +DelList(DOH *lo) { + List *l; + int i; + l = (List *) lo; + assert(l->refcount <= 0); + for (i = 0; i < l->nitems; i++) { + Delete(l->items[i]); + } + free(l->items); + free(l); +} + +/* ----------------------------------------------------------------------------- + * void List_clear(DOH *l) - Clear all elements in the list + * ----------------------------------------------------------------------------- */ + +void +List_clear(DOH *lo) { + List *l; + int i; + l = (List *) lo; + for (i = 0; i < l->nitems; i++) { + Delete(l->items[i]); + l->items[i] = 0; + } + l->nitems = 0; +} + +/* ----------------------------------------------------------------------------- + * void List_insert(DOH *lo, int pos, DOH *item) - Insert an element + * ----------------------------------------------------------------------------- */ + +int +List_insert(DOH *lo, int pos, DOH *item) +{ + List *l; + DohBase *b; + int i; + + if (!item) return; + b = (DohBase *) item; + l = (List *) lo; + + if (pos == DOH_END) pos = l->nitems; + if (pos < 0) pos = 0; + if (pos > l->nitems) pos = l->nitems; + if (l->nitems == l->maxitems) more(l); + for (i = l->nitems; i > pos; i--) { + l->items[i] = l->items[i-1]; + } + l->items[pos] = item; + b->refcount++; + l->nitems++; + return 0; +} + +/* ----------------------------------------------------------------------------- + * void List_remove(DOH *lo, int pos) - Remove an element + * ----------------------------------------------------------------------------- */ + +int +List_remove(DOH *lo, int pos) +{ + List *l; + DOH *item; + int i; + + l = (List *) lo; + if (pos == DOH_END) pos = l->nitems-1; + if (pos == DOH_BEGIN) pos = 0; + if ((pos < 0) || (pos >= l->nitems)) return; + item = l->items[pos]; + for (i = pos; i < l->nitems-1; i++) { + l->items[i] = l->items[i+1]; + } + l->nitems--; + Delete(item); + return 0; +} + +/* ----------------------------------------------------------------------------- + * int List_len(DOH *l) - List length + * ----------------------------------------------------------------------------- */ + +int +List_len(DOH *lo) +{ + return ((List *) lo)->nitems; +} + +/* ----------------------------------------------------------------------------- + * DOH *List_get(DOH *lo, int n) - Get an item + * ----------------------------------------------------------------------------- */ + +DOH * +List_get(DOH *lo, int n) +{ + List *l; + l = (List *) lo; + if (n == DOH_END) n = l->nitems-1; + if (n == DOH_BEGIN) n = 0; + if ((n < 0) || (n >= l->nitems)) { + printf("List_get : Invalid list index %d\n", n); + } + return l->items[n]; +} + +/* ----------------------------------------------------------------------------- + * int List_set(DOH *lo, int n, DOH *val) - Set an item + * ----------------------------------------------------------------------------- */ + +int +List_set(DOH *lo, int n, DOH *val) +{ + List *l; + + l = (List *) lo; + if ((n < 0) || (n >= l->nitems)) { + printf("List_set : Invalid list index %d\n", n); + } + Delete(l->items[n]); + l->items[n] = val; + Incref(val); + return 0; +} + +/* ----------------------------------------------------------------------------- + * Iterators + * ----------------------------------------------------------------------------- */ + +DOH * +List_first(DOH *lo) +{ + List *l; + l = (List *) lo; + l->iter = 0; + if (l->iter >= l->nitems) return 0; + return l->items[l->iter]; +} + +DOH * +List_next(DOH *lo) +{ + List *l; + l = (List *) lo; + l->iter++; + if (l->iter >= l->nitems) return 0; + return l->items[l->iter]; +} + +/* ----------------------------------------------------------------------------- + * String *List_str() - Create a string representation + * ----------------------------------------------------------------------------- */ + +DOH * +List_str(DOH *lo) +{ + DOH *s; + int i; + + List *l = (List *) lo; + s = NewString(""); + for (i = 0; i < l->nitems; i++) { + Appendf(s, "%o", l->items[i]); + if ((i+1) < l->nitems) + Append(s,", "); + } + return s; +} + +#ifdef SORT +/* ----------------------------------------------------------------------------- + * void List_sort(DOH *DOH) + * + * Sorts a list + * ----------------------------------------------------------------------------- */ + +int objcmp(const void *s1, const void *s2) { + DOH **so1, **so2; + so1 = (DOH **) s1; + so2 = (DOH **) s2; + return Cmp(*so1,*so2); +} + +void List_sort(DOH *so) { + List *l; + if (!List_check(so)) return; + l = (List *) so; + qsort(l->items,l->nitems,sizeof(DOH *), objcmp); +} +#endif + + + + diff --git a/SWIG/Source/DOH/Doh/main.c b/SWIG/Source/DOH/Doh/main.c new file mode 100644 index 000000000..35c08baa9 --- /dev/null +++ b/SWIG/Source/DOH/Doh/main.c @@ -0,0 +1,30 @@ +#include "doh.h" + +int main() { + DOH *d1, *d2, *d3; + DOH *f; + DOH *l; + DOH *h; + + printf("starting...\n"); + f = NewFile("foo","w"); + printf("%x\n",f); + d1 = NewString("Hello"); + d2 = NewString("World"); + Append(d1,d2); + Printf(d1,"This is a test %d", 42); + Setattr(d1,"foo",d2); + Printf(f,"Hello World\n"); + Printf(f,"%s\n",d1); + l = NewList(); + Append(l,d1); + Append(l,d2); + Append(l,f); + h = NewHash(); + Setattr(h,"foo",d1); + Setattr(h,"bar",l); + Printf(f,"%o\n",l); + Printf(f,"%o\n",h); + Printf(f,"%o\n", Getattr(h,"bar")); +} + diff --git a/SWIG/Source/DOH/Doh/string.c b/SWIG/Source/DOH/Doh/string.c new file mode 100644 index 000000000..1051b4ab7 --- /dev/null +++ b/SWIG/Source/DOH/Doh/string.c @@ -0,0 +1,697 @@ +/**************************************************************************** + * DOH (Dynamic Object Hack) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + ****************************************************************************/ + +#include "doh.h" + +/* --------------------------------------------------------------------------- + * $Header$ + * string.c + * + * String support. + * --------------------------------------------------------------------------- */ + +typedef struct String { + DOHCOMMON; + int maxsize; /* Max size allocated */ + int len; /* Current length */ + int hashkey; /* Hash key value */ + int sp; /* Current position */ + int lsp; /* Last returned position */ + char *str; /* String data */ +} String; + +/* Forward references */ + +void DelString(DOH *s); +DOH *CopyString(DOH *s); +void String_clear(DOH *s); +DOH *String_str(DOH *s); +int String_delitem(DOH *s, int where); +int String_len(DOH *s); +void String_appendfv(DOH *s, char *fmt, va_list ap); +int String_insertfv(DOH *s, int pos, char *fmt, va_list ap); +int String_insert(DOH *s, int pos, DOH *DOH); +void *String_data(DOH *s); +int String_cmp(DOH *, DOH *); +int String_hash(DOH *s); +int String_read(DOH *s, void *buffer, int length); +int String_write(DOH *s, void *buffer, int length); +int String_seek(DOH *s, long offset, int whence); +long String_tell(DOH *s); +int String_printf(DOH *s, char *fmt, va_list ap); + +static DohSequenceMethods StringSeqMethods = { + 0, + 0, + String_delitem, + String_insert, + String_insertfv, + 0, + 0, +}; + +static DohFileMethods StringFileMethods = { + String_read, + String_write, + String_seek, + String_tell, + String_printf, +}; + +static DohObjInfo StringType = { + "String", /* objname */ + 0, + DelString, /* sm_del */ + CopyString, /* sm_copy */ + String_clear, /* sm_clear */ + String_str, /* sm_str */ + String_data, /* doh_data */ + String_len, /* sm_len */ + String_hash, /* sm_hash */ + String_cmp, /* doh_cmp */ + 0, /* doh_mapping */ + &StringSeqMethods, /* doh_sequence */ + &StringFileMethods,/* doh_file */ + 0, + 0, + 0, + 0, +}; + +#define INIT_MAXSIZE 16 + +DohObjInfo *String_type() { + return &StringType; +} + +/* ----------------------------------------------------------------------------- + * void *String_data(DOH *so) - Return as a 'void *' + * ----------------------------------------------------------------------------- */ +void *String_data(DOH *so) { + return (void *) ((String *) so)->str; +} + +/* ----------------------------------------------------------------------------- + * NewString(const char *c) - Create a new string + * ----------------------------------------------------------------------------- */ +DOH * +NewString(char *s) +{ + int l, max; + String *str; + str = (String *) malloc(sizeof(String)); + DohInit(str); + str->objinfo = &StringType; + str->hashkey = -1; + str->sp = 0; + str->lsp = 0; + str->line = 1; + max = INIT_MAXSIZE; + if (s) { + l = (int) strlen(s); + if ((l+1) > max) max = l+1; + } + str->str = (char *) malloc(max); + str->maxsize = max; + if (s) { + strcpy(str->str,s); + str->len = l; + } else { + str->str[0] = 0; + str->len = 0; + } + return (DOH *) str; +} + +/* ----------------------------------------------------------------------------- + * CopyString(DOH *s) - Copy a string + * ----------------------------------------------------------------------------- */ +DOH * +CopyString(DOH *so) { + String *s; + int l, max; + String *str; + s = (String *) so; + str = (String *) malloc(sizeof(String)); + DohInit(str); + str->objinfo = &StringType; + str->hashkey = -1; + str->sp = 0; + str->lsp = 0; + str->line = 1; + max = s->maxsize; + str->str = (char *) malloc(max); + memmove(str->str, s->str, max); + str->maxsize= max; + return (DOH *) str; +} + +/* ----------------------------------------------------------------------------- + * DelString(DOH *s) - Delete a string + * ----------------------------------------------------------------------------- */ +void +DelString(DOH *so) { + String *s; + s = (String *) so; + assert(s->refcount <= 0); + free(s->str); + free(s); +} + +/* ----------------------------------------------------------------------------- + * int String_check(DOH *s) - Check if s is a string + * ----------------------------------------------------------------------------- */ +int +String_check(DOH *s) +{ + char *c = (char *) s; + if (!s) return 0; + if (*c == DOH_MAGIC) { + if (((String *) c)->objinfo == &StringType) + return 1; + return 0; + } + else return 0; +} + +/* ----------------------------------------------------------------------------- + * int String_len(DOH *s) - Length of a string + * ----------------------------------------------------------------------------- */ + +int +String_len(DOH *so) { + String *s = (String *)so; + return s->len; +} + + +/* ----------------------------------------------------------------------------- + * int String_cmp(DOH *s1, DOH *s2) - Compare two strings + * ----------------------------------------------------------------------------- */ + +int +String_cmp(DOH *so1, DOH *so2) +{ + String *s1, *s2; + s1 = (String *) so1; + s2 = (String *) so2; + return strcmp(s1->str,s2->str); +} + +/* ----------------------------------------------------------------------------- + * int String_hash(DOH *s) - Compute string hash value + * ----------------------------------------------------------------------------- */ + +int String_hash(DOH *so) { + String *s = (String *) so; + char *c; + int i, h = 0, len; + if (s->hashkey >= 0) return s->hashkey; + c = s->str; + len = s->len > 50 ? 50 : s->len; + for (i = 0; i < len; i++) { + h = (((h << 5) + *(c++))); + } + h = h & 0x7fffffff; + s->hashkey = h; + return h; +} + +/* ----------------------------------------------------------------------------- + * static add(String *s, const char *newstr) - Append to s + * ----------------------------------------------------------------------------- */ + +static void +add(String *s, const char *newstr) { + int newlen, newmaxsize, l; + if (!newstr) return; + s->hashkey = -1; + l = (int) strlen(newstr); + newlen = s->len+l + 1; + if (newlen >= s->maxsize-1) { + newmaxsize = 2*s->maxsize; + if (newlen >= newmaxsize -1) newmaxsize = newlen + 1; + assert(s->str = (char *) realloc(s->str,newmaxsize)); + s->maxsize = newmaxsize; + } + strcpy(s->str+s->len,newstr); + s->len += l; +} + +static void +addstr(String *s, String *s1) { + int newlen, newmaxsize, l; + s->hashkey = -1; + l = s1->len; + newlen = s->len+l + 1; + if (newlen >= s->maxsize-1) { + newmaxsize = 2*s->maxsize; + if (newlen >= newmaxsize -1) newmaxsize = newlen + 1; + assert(s->str = (char *) realloc(s->str,newmaxsize)); + s->maxsize = newmaxsize; + } + memmove(s->str+s->len,s1->str,s1->len); + s->len += l; +} + + +/* Add a single character to s */ + +void +String_addchar(DOH *so, char c) { + String *s = (String *) so; + s->hashkey = -1; + if ((s->len+1) > (s->maxsize-1)) { + assert(s->str = (char *) realloc(s->str,2*s->maxsize)); + s->maxsize *= 2; + } + s->str[s->len++] = c; + s->str[s->len] = 0; +} + +/* ----------------------------------------------------------------------------- + * void String_clear(DOH *s) - Clear a string + * ----------------------------------------------------------------------------- */ + +void +String_clear(DOH *so) +{ + String *s; + s = (String *) so; + s->hashkey = -1; + s->len = 0; + s->str[0] = 0; + s->sp = 0; + s->lsp = 0; + s->line = 1; +} + +/* ----------------------------------------------------------------------------- + * void String_appendfv(DOH *so, char *format, ...) - Append to string + * -----------------------------------------------------------------------------*/ + +void +String_appendfv(DOH *so, char *format, va_list ap) +{ + char *p, *sval; + String *Sval; + DohBase *b; + int ival; + double dval; + char cval; + char temp[64]; + String *s; + + s = (String *) so; + + assert(s->refcount <= 1); + + for (p = format; *p; p++) { + if (*p != '%') { + String_addchar(s,*p); + continue; + } + switch(*++p) { + case 'c': + cval = va_arg(ap,char); + String_addchar(s,cval); + break; + case 'd': + ival = va_arg(ap,int); + sprintf(temp,"%d",ival); + add(s,temp); + break; + case 'x': + ival = va_arg(ap,int); + sprintf(temp,"%x", ival); + add(s,temp); + break; + case 'f': + dval = va_arg(ap,double); + sprintf(temp,"%f",dval); + add(s,temp); + break; + case 's': + Sval = va_arg(ap, String *); + if (String_check(Sval)) { + addstr(s,Sval); + } else { + add(s,(char *) Sval); + } + break; + case 'o': + b = va_arg(ap, DohBase *); + Sval = Str(b); + addstr(s, Sval); + Delete(Sval); + break; + + /* Automatically deletes whatever object was passed */ + case 'O': + b = va_arg(ap, DohBase *); + Sval = Str(b); + addstr(s, Sval); + Delete(Sval); + Delete(b); + break; + default: + String_addchar(s,*p); + break; + } + } +} + +void +raw_insert(String *s, int pos, char *data, int len) +{ + char *nstr; + nstr = s->str; + s->hashkey = -1; + if (pos == DOH_END) { + add(s, data); + return; + } + if (pos < 0) pos = 0; + else if (pos > s->len) pos = s->len; + + /* See if there is room to insert the new data */ + + while (s->maxsize <= s->len+len) { + assert(s->str = (char *) realloc(s->str,2*s->maxsize)); + s->maxsize *= 2; + } + memmove(s->str+pos+len, s->str+pos, (s->len - pos)); + memcpy(s->str+pos,data,len); + s->len += len; + s->str[s->len] = 0; +} + +/* ----------------------------------------------------------------------------- + * void String_insert(DOH *so, int pos, SO *str) - Insert a string + * ----------------------------------------------------------------------------- */ +int +String_insert(DOH *so, int pos, DOH *str) +{ + String *s, *s1; + char *c; + int len; + s = (String *) so; + assert(s->refcount <= 1); + s1 = (String *) str; + len = s1->len; + c = s1->str; + raw_insert(s,pos,c,len); + return 0; +} + +/* ----------------------------------------------------------------------------- + * void String_insertf(DOH *so, char *format, ...) - Insert a string + * -----------------------------------------------------------------------------*/ + +int +String_insertfv(DOH *so, int pos, char *format, va_list ap) +{ + String *s; + String *temp; + s = (String *) so; + if (pos == DOH_END) { + String_appendfv(so,format,ap); + return 0; + } + temp = NewString(""); + String_appendfv(temp,format,ap); + raw_insert(s,pos, temp->str,temp->len); + Delete(temp); + return 0; +} + +/* ----------------------------------------------------------------------------- + * int String_delitem(DOH *so, int pos) + * + * Delete an individual item + * ----------------------------------------------------------------------------- */ + +int String_delitem(DOH *so, int pos) +{ + String *s = (String *) so; + if (pos == DOH_END) pos = s->len-1; + if (pos == DOH_BEGIN) pos = 0; + + if (s->len == 0) return; + + memmove(s->str+pos, s->str+pos+1, ((s->len-1) - pos)); + s->len--; + s->str[s->len] = 0; + return 0; +} + +/* ----------------------------------------------------------------------------- + * DOH *String_str(DOH *so) - Returns a string (used by printing commands) + * ----------------------------------------------------------------------------- */ + +DOH * +String_str(DOH *so) { + DOH *nstr; + String *s = (String *) so; + nstr = NewString(s->str); + return nstr; +} + +/* ----------------------------------------------------------------------------- + * int String_read(DOH *so, void *buffer, int len) + * + * Read data from the string + * ----------------------------------------------------------------------------- */ +int +String_read(DOH *so, void *buffer, int len) { + int reallen; + String *s = (String *) so; + if ((s->sp + len) > s->len) reallen = (s->len - s->sp); + memmove(buffer, s->str+s->sp, reallen); + s->sp += reallen; + return reallen; +} + +/* ----------------------------------------------------------------------------- + * int String_write(DOH *so, void *buffer, int len) + * + * Write data to the string + * ----------------------------------------------------------------------------- */ +int +String_write(DOH *so, void *buffer, int len) { + int reallen, newlen, newmaxsize; + String *s = (String *) so; + newlen = s->sp + len + 1; + if (newlen > s->maxsize) { + assert(s->str = (char *) realloc(s->str,newlen)); + s->maxsize = newlen; + s->len = s->sp + len; + } + memmove(s->str+s->sp,buffer,len); + s->sp += len; + return len; +} + +/* ----------------------------------------------------------------------------- + * int String_seek(DOH *so, long offset, int whence) + * + * Seek to a new position + * ----------------------------------------------------------------------------- */ +int +String_seek(DOH *so, long offset, int whence) { + int pos; + String *s = (String *) so; + if (whence == SEEK_SET) pos = 0; + if (whence == SEEK_CUR) pos = s->sp; + if (whence == SEEK_END) { + pos = s->len; + offset = -offset; + } + s->sp = pos + offset; + if (s->sp < 0) s->sp = 0; + if (s->sp > s->len) s->sp = s->len; + return 0; +} + +/* ----------------------------------------------------------------------------- + * long String_seek(DOH *so) + * + * Return current position + * ----------------------------------------------------------------------------- */ +long +String_tell(DOH *so) { + String *s = (String *) so; + return (long) s->sp; +} + +/* ----------------------------------------------------------------------------- + * int String_printf(DOH *so, char *format, ...) + * + * ----------------------------------------------------------------------------- */ + +int +String_printf(DOH *so, char *format, va_list ap) +{ + int len; + DOH *nso; + String *s = (String *) so; + nso = NewString(""); + String_appendfv(nso,format,ap); + len = ((String *) nso)->len; + String_write(so,Data(nso),len); + Delete(nso); + return len; +} + +/* ----------------------------------------------------------------------------- + * static void replace_internal(String *str, char *token, char *rep, int flags, char *start, int count) + * + * Replaces token with rep. flags is as follows: + * + * REPLACE_ANY - Replace all occurrences + * REPLACE_NOQUOTE - Don't replace in quotes + * REPLACE_ID - Only replace valid identifiers + * REPLACE_FIRST - Only replace first occurrence + * + * start is a starting position. count is a count. + * ----------------------------------------------------------------------------- */ + +void replace_internal(String *str, char *token, char *rep, int flags, char *start, int count) +{ + char *s, *c, *t; + int tokenlen; + int state; + + /* Copy the current string representation */ + + s = str->str; + str->hashkey = -1; + + tokenlen = strlen(token); + + /* If a starting position was given, dump those characters first */ + + if (start) { + c = start; + } else { + c = s; + } + + /* Now walk down the old string and search for tokens */ + t = strstr(c,token); + if (t) { + str->len = 0; + str->str = (char *) malloc(str->maxsize); + if (start) { + char temp = *start; + *start = 0; + add(str,s); + *start = temp; + } + + /* Depending on flags. We compare in different ways */ + state = 0; + t = c; + while ((*c) && (count)) { + switch(state) { + case 0: + if (*c == *token) { + if (!(flags & DOH_REPLACE_ID)) { + if (strncmp(c,token,tokenlen) == 0) { + char temp = *c; + *c = 0; + add(str,t); + *c = temp; + add(str,rep); + c += (tokenlen-1); + t = c+1; + count--; + } + } else if (isalpha(*c) || (*c == '_') || (*c == '$')) { + char temp = *c; + *c = 0; + add(str,t); + *c = temp; + t = c; + state = 10; + } + } else if (flags & DOH_REPLACE_NOQUOTE) { + if (*c == '\"') state = 20; + else if (*c == '\'') state = 30; + } + break; + case 10: /* The start of an identifier */ + if (isalnum(*c) || (*c == '_') || (*c == '$')) state = 10; + else { + char temp = *c; + *c = 0; + if (strcmp(token,t) == 0) { + add(str,rep); + count--; + } else { + add(str,t); + } + *c = temp; + t = c; + state = 0; + } + break; + case 20: /* A string */ + if (*c == '\"') state = 0; + else if (*c == '\\') c++; + break; + case 30: /* A Single quoted string */ + if (*c == '\'') state = 0; + else if (*c == '\\') c++; + break; + } + c++; + } + if ((count) && (state == 10)) { + if (strcmp(token,t) == 0) { + add(str,rep); + } else { + add(str,t); + } + } else { + add(str,t); + } + free(s); + } +} + +/* ----------------------------------------------------------------------------- + * void String_replace(DOH *str, DOH *token, DOH *rep, int flags) + * ----------------------------------------------------------------------------- */ + +void +String_replace(DOH *stro, DOH *token, DOH *rep, int flags) +{ + int count = -1; + String *str; + if (!String_check(stro)) return; + str = (String *) stro; + assert(!str->refcount); + if (flags & DOH_REPLACE_FIRST) count = 1; + replace_internal(str,Char(token),Char(rep),flags,str->str,count); +} + + + + + + + + diff --git a/SWIG/Source/DOH/Include/doh.h b/SWIG/Source/DOH/Include/doh.h new file mode 100644 index 000000000..575063e8b --- /dev/null +++ b/SWIG/Source/DOH/Include/doh.h @@ -0,0 +1,261 @@ +/******************************************************************************* + * DOH (Dynamic Object Hack) + * + * Author : David Beazley + * + * Department of Computer Science + * University of Chicago + * 1100 E 58th Street + * Chicago, IL 60637 + * beazley@cs.uchicago.edu + * + * Please read the file LICENSE for the copyright and terms by which SWIG + * can be used and distributed. + *******************************************************************************/ + +/*********************************************************************** + * $Header$ + * + * doh.h + ***********************************************************************/ + +#include +#include +#include +#include +#include +#include + +typedef void DOH; + +#define DOH_BEGIN -1 +#define DOH_END -2 +#define DOH_CUR -3 + +#define DOH_MAGIC 0x04 + +/* ----------------------------------------------------------------------------- + * Object classes + * ----------------------------------------------------------------------------- */ + +/* Mapping Objects */ +typedef struct { + DOH *(*doh_getattr)(DOH *obj, DOH *name); /* Get attribute */ + int (*doh_setattr)(DOH *obj, DOH *name, DOH *value); /* Set attribute */ + int (*doh_delattr)(DOH *obj, DOH *name); /* Del attribute */ + DOH *(*doh_firstkey)(DOH *obj); /* First key */ + DOH *(*doh_nextkey)(DOH *obj); /* Next key */ +} DohMappingMethods; + +/* Sequence methods */ +typedef struct { + DOH *(*doh_getitem)(DOH *obj, int index); + int (*doh_setitem)(DOH *obj, int index, DOH *value); + int (*doh_delitem)(DOH *obj, int index); + int (*doh_insitem)(DOH *obj, int index, DOH *value); + int (*doh_insertf)(DOH *obj, int index, char *format, va_list ap); + DOH *(*doh_first)(DOH *obj); + DOH *(*doh_next)(DOH *obj); +} DohSequenceMethods; + +/* File methods */ +typedef struct { + int (*doh_read)(DOH *obj, void *buffer, int nbytes); + int (*doh_write)(DOH *obj, void *buffer, int nbytes); + int (*doh_seek)(DOH *obj, long offset, int whence); + long (*doh_tell)(DOH *obj); + int (*doh_printf)(DOH *obj, char *format, va_list ap); + int (*doh_scanf)(DOH *obj, char *format, va_list ap); + int (*doh_close)(DOH *obj); +} DohFileMethods; + +/* ----------------------------------------------------------------------------- + * DohObjInfo + * + * Included in all DOH types. + * ----------------------------------------------------------------------------- */ + +typedef struct DohObjInfo { + char *objname; /* Object name */ + int objsize; /* Object size */ + + /* Basic object methods */ + void (*doh_del)(DOH *obj); /* Delete object */ + DOH *(*doh_copy)(DOH *obj); /* Copy and object */ + void (*doh_clear)(DOH *obj); /* Clear an object */ + + /* Output methods */ + DOH *(*doh_str)(DOH *obj); /* Make a full string */ + void *(*doh_data)(DOH *obj); /* Return raw data */ + + /* Length and hash values */ + int (*doh_len)(DOH *obj); + int (*doh_hash)(DOH *obj); + + /* Compare */ + int (*doh_cmp)(DOH *obj1, DOH *obj2); + + DohMappingMethods *doh_mapping; /* Mapping methods */ + DohSequenceMethods *doh_sequence; /* Sequence methods */ + DohFileMethods *doh_file; /* File methods */ + void *reserved2; /* Number methods */ + void *reserved3; + void *reserved4; + void *user[16]; /* User extensions */ +} DohObjInfo; + +/* Low-level doh methods. Do not call directly (well, unless you want to). */ + +extern void DohDestroy(DOH *obj); +extern DOH *DohCopy(DOH *obj); +extern void DohClear(DOH *obj); +extern int DohCmp(DOH *obj1, DOH *obj2); +extern DOH *DohStr(DOH *obj); +extern DOH *DohGetattr(DOH *obj, DOH *name); +extern int DohSetattr(DOH *obj, DOH *name, DOH *value); +extern void DohDelattr(DOH *obj, DOH *name); +extern int DohHashval(DOH *obj); +extern DOH *DohGetitem(DOH *obj, int index); +extern void DohSetitem(DOH *obj, int index, DOH *value); +extern void DohDelitem(DOH *obj, int index); +extern void DohInsertitem(DOH *obj, int index, DOH *value); +extern void DohInsertf(DOH *obj, int index, char *format, ...); +extern void DohvInsertf(DOH *obj, int index, char *format, va_list ap); +extern void DohAppendf(DOH *obj, char *format, ...); +extern void DohvAppendf(DOH *obj, char *format, va_list ap); +extern int DohLen(DOH *obj); +extern DOH *DohFirst(DOH *obj); +extern DOH *DohNext(DOH *obj); +extern DOH *DohFirstkey(DOH *obj); +extern DOH *DohNextkey(DOH *obj); +extern void *DohData(DOH *obj); +extern int DohGetline(DOH *obj); +extern void DohSetline(DOH *obj, int line); +extern DOH *DohGetfile(DOH *obj); +extern void DohSetfile(DOH *obj, DOH *file); +extern int DohCheck(DOH *obj); +extern void DohInit(DOH *obj); + +/* File methods */ + +extern int DohWrite(DOH *obj, void *buffer, int length); +extern int DohRead(DOH *obj, void *buffer, int length); +extern int DohSeek(DOH *obj, long offser, int whence); +extern long DohTell(DOH *obj); +extern int DohPrintf(DOH *obj, char *format, ...); +extern int DohvPrintf(DOH *obj, char *format, va_list ap); +extern int DohScanf(DOH *obj, char *format, ...); +extern int DohvScanf(DOH *obj, char *format, va_list ap); + +/* Macros to invoke the above functions. Includes the location of + the caller to simplify debugging if something goes wrong */ + +#define Delete DohDestroy +#define Copy DohCopy +#define Clear DohClear +#define Str DohStr +#define Signature DohSignature +#define Getattr DohGetattr +#define Setattr DohSetattr +#define Delattr DohDelattr +#define Hashval DohHashval +#define Getitem DohGetitem +#define Setitem DohSetitem +#define Delitem DohDelitem +#define Insert DohInsertitem +#define Insertf DohInsertitemf +#define vInsertf DohvInsertitemf +#define Append(s,x) DohInsertitem(s,DOH_END,x) +#define Appendf DohAppendf +#define vAppendf DohvAppendf +#define Push(s,x) DohInsertitem(s,DOH_BEGIN,x) +#define Len DohLen +#define First DohFirst +#define Next DohNext +#define Firstkey DohFirstkey +#define Nextkey DohNextkey +#define Data DohData +#define Char (char *) Data +#define Cmp DohCmp +#define Setline DohSetline +#define Getline DohGetline +#define Setfile DohSetfile +#define Getfile DohGetfile +#define Write DohWrite +#define Read DohRead +#define Seek DohSeek +#define Tell DohTell +#define Printf DohPrintf +#define vPrintf DohvPrintf +#define Scanf DohScanf +#define vScanf DohvScanf + +/* ----------------------------------------------------------------------------- + * DohBase + * + * DohBase object type. Attributes common to all objects. + * ----------------------------------------------------------------------------- */ + +#define DOHCOMMON \ + char magic; \ + char moremagic[3]; \ + DohObjInfo *objinfo; \ + int refcount; \ + int line; \ + DOH *file + +typedef struct { + DOHCOMMON; +} DohBase; + +/* Macros for decrefing and increfing (safe for null objects). */ +#define Decref(a) if (a) ((DohBase *) a)->refcount--; +#define Incref(a) if (a) ((DohBase *) a)->refcount++; +#define Objname(a) ((DohBase *) a)->objinfo->objname + +/* ----------------------------------------------------------------------------- + * Strings. + * ----------------------------------------------------------------------------- */ + +extern DOH *NewString(char *c); +extern int String_check(DOH *s); +extern void String_replace(DOH *s, DOH *token, DOH *rep, int flags); +extern DohObjInfo *String_type(); + +/* String replacement flags */ + +#define DOH_REPLACE_ANY 0x00 +#define DOH_REPLACE_NOQUOTE 0x01 +#define DOH_REPLACE_ID 0x02 +#define DOH_REPLACE_FIRST 0x04 + +/* ----------------------------------------------------------------------------- + * Files + * ----------------------------------------------------------------------------- */ + +extern DOH *NewFile(char *file, char *mode); +extern DOH *NewFileFromFile(FILE *f); +extern DohObjInfo *File_type(); +/* ----------------------------------------------------------------------------- + * List + * ----------------------------------------------------------------------------- */ + +extern DOH *NewList(); +extern int List_check(DOH *); +extern void List_sort(DOH *); +extern DohObjInfo *List_type(); + +/* ----------------------------------------------------------------------------- + * Hash + * ----------------------------------------------------------------------------- */ + +extern DOH *NewHash(); +extern int Hash_check(DOH *h); +extern DOH *Hash_keys(DOH *); +extern DohObjInfo *Hash_type(); + + + + + +