/* ----------------------------------------------------------------------------- * This file is part of SWIG, which is licensed as a whole under version 3 * (or any later version) of the GNU General Public License. Some additional * terms also apply to certain portions of SWIG. The full details of the SWIG * license and copyrights can be found in the LICENSE and COPYRIGHT files * included with the SWIG source code as distributed by the SWIG developers * and at https://www.swig.org/legal.html. * * doh.h * * This file describes of the externally visible functions in DOH. * ----------------------------------------------------------------------------- */ #ifndef SWIG_DOH_H #define SWIG_DOH_H #include "swigconfig.h" #include #include #include /* Set the namespace prefix for DOH API functions. This can be used to control visibility of the functions in libraries */ /* Set this macro if you want to change DOH linkage. You would do this if you wanted to hide DOH in a library using a different set of names. Note: simply change "Doh" to a new name. */ /* #define DOH_NAMESPACE(x) Doh ## x */ #ifdef DOH_NAMESPACE /* Namespace control. These macros define all of the public API names in DOH */ #define DohCheck DOH_NAMESPACE(Check) #define DohIntern DOH_NAMESPACE(Intern) #define DohDelete DOH_NAMESPACE(Delete) #define DohCopy DOH_NAMESPACE(Copy) #define DohClear DOH_NAMESPACE(Clear) #define DohStr DOH_NAMESPACE(Str) #define DohData DOH_NAMESPACE(Data) #define DohDump DOH_NAMESPACE(Dump) #define DohLen DOH_NAMESPACE(Len) #define DohHashval DOH_NAMESPACE(Hashval) #define DohCmp DOH_NAMESPACE(Cmp) #define DohEqual DOH_NAMESPACE(Equal) #define DohIncref DOH_NAMESPACE(Incref) #define DohCheckattr DOH_NAMESPACE(Checkattr) #define DohSetattr DOH_NAMESPACE(Setattr) #define DohDelattr DOH_NAMESPACE(Delattr) #define DohKeys DOH_NAMESPACE(Keys) #define DohSortedKeys DOH_NAMESPACE(SortedKeys) #define DohGetInt DOH_NAMESPACE(GetInt) #define DohGetDouble DOH_NAMESPACE(GetDouble) #define DohGetChar DOH_NAMESPACE(GetChar) #define DohSetChar DOH_NAMESPACE(SetChar) #define DohSetInt DOH_NAMESPACE(SetInt) #define DohSetDouble DOH_NAMESPACE(SetDouble) #define DohSetVoid DOH_NAMESPACE(SetVoid) #define DohGetVoid DOH_NAMESPACE(GetVoid) #define DohGetitem DOH_NAMESPACE(Getitem) #define DohSetitem DOH_NAMESPACE(Setitem) #define DohDelitem DOH_NAMESPACE(Delitem) #define DohInsertitem DOH_NAMESPACE(Insertitem) #define DohDelslice DOH_NAMESPACE(Delslice) #define DohWrite DOH_NAMESPACE(Write) #define DohRead DOH_NAMESPACE(Read) #define DohSeek DOH_NAMESPACE(Seek) #define DohTell DOH_NAMESPACE(Tell) #define DohGetc DOH_NAMESPACE(Getc) #define DohPutc DOH_NAMESPACE(Putc) #define DohUngetc DOH_NAMESPACE(Ungetc) #define DohGetline DOH_NAMESPACE(Getline) #define DohSetline DOH_NAMESPACE(Setline) #define DohGetfile DOH_NAMESPACE(Getfile) #define DohSetfile DOH_NAMESPACE(Setfile) #define DohReplace DOH_NAMESPACE(Replace) #define DohChop DOH_NAMESPACE(Chop) #define DohGetmeta DOH_NAMESPACE(Getmeta) #define DohSetmeta DOH_NAMESPACE(Setmeta) #define DohDelmeta DOH_NAMESPACE(Delmeta) #define DohEncoding DOH_NAMESPACE(Encoding) #define DohPrintf DOH_NAMESPACE(Printf) #define DohvPrintf DOH_NAMESPACE(vPrintf) #define DohPrintv DOH_NAMESPACE(Printv) #define DohReadline DOH_NAMESPACE(Readline) #define DohIsMapping DOH_NAMESPACE(IsMapping) #define DohIsSequence DOH_NAMESPACE(IsSequence) #define DohIsString DOH_NAMESPACE(IsString) #define DohIsFile DOH_NAMESPACE(IsFile) #define DohNewString DOH_NAMESPACE(NewString) #define DohNewStringEmpty DOH_NAMESPACE(NewStringEmpty) #define DohNewStringWithSize DOH_NAMESPACE(NewStringWithSize) #define DohNewStringf DOH_NAMESPACE(NewStringf) #define DohStrcmp DOH_NAMESPACE(Strcmp) #define DohStrncmp DOH_NAMESPACE(Strncmp) #define DohStrstr DOH_NAMESPACE(Strstr) #define DohStrchr DOH_NAMESPACE(Strchr) #define DohNewFile DOH_NAMESPACE(NewFile) #define DohNewFileFromFile DOH_NAMESPACE(NewFileFromFile) #define DohNewFileFromFd DOH_NAMESPACE(NewFileFromFd) #define DohFileErrorDisplay DOH_NAMESPACE(FileErrorDisplay) #define DohCopyto DOH_NAMESPACE(Copyto) #define DohNewList DOH_NAMESPACE(NewList) #define DohNewHash DOH_NAMESPACE(NewHash) #define DohNewVoid DOH_NAMESPACE(NewVoid) #define DohSplit DOH_NAMESPACE(Split) #define DohSplitLines DOH_NAMESPACE(SplitLines) #define DohNone DOH_NAMESPACE(None) #define DohCall DOH_NAMESPACE(Call) #define DohObjMalloc DOH_NAMESPACE(ObjMalloc) #define DohObjFree DOH_NAMESPACE(ObjFree) #define DohMemoryDebug DOH_NAMESPACE(MemoryDebug) #define DohStringType DOH_NAMESPACE(StringType) #define DohListType DOH_NAMESPACE(ListType) #define DohHashType DOH_NAMESPACE(HashType) #define DohFileType DOH_NAMESPACE(FileType) #define DohVoidType DOH_NAMESPACE(VoidType) #define DohIterator DOH_NAMESPACE(Iterator) #define DohFirst DOH_NAMESPACE(First) #define DohNext DOH_NAMESPACE(Next) #define DohMalloc DOH_NAMESPACE(Malloc) #define DohRealloc DOH_NAMESPACE(Realloc) #define DohCalloc DOH_NAMESPACE(Calloc) #define DohFree DOH_NAMESPACE(Free) #define DohSetExitHandler DOH_NAMESPACE(SetExitHandler) #define DohExit DOH_NAMESPACE(Exit) #endif #define DOH_MAJOR_VERSION 0 #define DOH_MINOR_VERSION 1 typedef void DOH; /* * With dynamic typing, all DOH objects are technically of type 'void *'. * However, to clarify the reading of source code, the following symbolic * names are used. */ #define DOHString DOH #define DOHList DOH #define DOHHash DOH #define DOHFile DOH #define DOHVoid DOH #define DOHString_or_char DOH #define DOHObj_or_char DOH typedef const DOHString_or_char * const_String_or_char_ptr; typedef const DOHString_or_char * DOHconst_String_or_char_ptr; #define DOH_BEGIN -1 #define DOH_END -2 #define DOH_CUR -3 #define DOH_CURRENT -3 /* Iterator objects */ typedef struct { void *key; /* Current key (if any) */ void *item; /* Current item */ void *object; /* Object being iterated over */ void *_current; /* Internal use */ int _index; /* Internal use */ } DohIterator; /* Memory management */ /* Wrappers around malloc(), realloc() and calloc() which never return NULL. */ extern void *DohMalloc(size_t size); extern void *DohRealloc(void *ptr, size_t size); extern void *DohCalloc(size_t n, size_t size); #ifndef DohFree #define DohFree free #endif extern int DohCheck(const DOH *ptr); /* Check if a DOH object */ extern void DohIntern(DOH *); /* Intern an object */ /* Basic object methods. Common to most objects */ extern void DohDelete(DOH *obj); /* Delete an object */ extern DOH *DohCopy(const DOH *obj); extern void DohClear(DOH *obj); extern DOHString *DohStr(const DOH *obj); extern void *DohData(const DOH *obj); extern int DohDump(const DOH *obj, DOHFile * out); extern int DohLen(const DOH *obj); extern int DohHashval(const DOH *obj); extern int DohCmp(const DOH *obj1, const DOH *obj2); extern int DohEqual(const DOH *obj1, const DOH *obj2); extern void DohIncref(DOH *obj); /* Mapping methods */ extern DOH *DohGetattr(DOH *obj, const DOHString_or_char *name); extern int DohSetattr(DOH *obj, const DOHString_or_char *name, const DOHObj_or_char * value); extern int DohDelattr(DOH *obj, const DOHString_or_char *name); extern int DohCheckattr(DOH *obj, const DOHString_or_char *name, const DOHString_or_char *value); extern DOH *DohKeys(DOH *obj); extern DOH *DohSortedKeys(DOH *obj, int (*cmp) (const DOH *, const DOH *)); extern int DohGetInt(DOH *obj, const DOHString_or_char *name); extern void DohSetInt(DOH *obj, const DOHString_or_char *name, int); extern double DohGetDouble(DOH *obj, const DOHString_or_char *name); extern void DohSetDouble(DOH *obj, const DOHString_or_char *name, double); extern char *DohGetChar(DOH *obj, const DOHString_or_char *name); extern void DohSetChar(DOH *obj, const DOH *name, char *value); extern void *DohGetFlagAttr(DOH *obj, const DOHString_or_char *name); extern int DohGetFlag(DOH *obj, const DOHString_or_char *name); extern void DohSetFlagAttr(DOH *obj, const DOHString_or_char *name, const DOHString_or_char *attr); extern void DohSetFlag(DOH *obj, const DOHString_or_char *name); extern void *DohGetVoid(DOH *obj, const DOHString_or_char *name); extern void DohSetVoid(DOH *obj, const DOHString_or_char *name, void *value); /* Sequence methods */ extern DOH *DohGetitem(DOH *obj, int index); extern int DohSetitem(DOH *obj, int index, const DOHObj_or_char * value); extern int DohDelitem(DOH *obj, int index); extern int DohInsertitem(DOH *obj, int index, const DOHObj_or_char * value); extern int DohDelslice(DOH *obj, int sindex, int eindex); /* File methods */ extern int DohWrite(DOHFile * obj, const void *buffer, int length); extern int DohRead(DOHFile * obj, void *buffer, int length); extern int DohSeek(DOHFile * obj, long offset, int whence); extern long DohTell(DOHFile * obj); extern int DohGetc(DOHFile * obj); extern int DohPutc(int ch, DOHFile * obj); extern int DohUngetc(int ch, DOHFile * obj); /* Iterators */ extern DohIterator DohFirst(DOH *obj); extern DohIterator DohNext(DohIterator x); /* Positional */ extern int DohGetline(const DOH *obj); extern void DohSetline(DOH *obj, int line); extern DOH *DohGetfile(const DOH *obj); extern void DohSetfile(DOH *obj, DOH *file); /* String Methods */ extern int DohReplace(DOHString * src, const DOHString_or_char *token, const DOHString_or_char *rep, int flags); extern void DohChop(DOHString * src); /* Meta-variables */ extern DOH *DohGetmeta(DOH *, const DOH *); extern int DohSetmeta(DOH *, const DOH *, const DOH *value); extern int DohDelmeta(DOH *, const DOH *); /* Utility functions */ extern void DohEncoding(const char *name, DOH *(*fn) (DOH *s)); extern int DohPrintf(DOHFile * obj, const char *format, ...); extern int DohvPrintf(DOHFile * obj, const char *format, va_list ap); extern int DohPrintv(DOHFile * obj, ...); extern DOH *DohReadline(DOHFile * in); /* Miscellaneous */ extern int DohIsMapping(const DOH *obj); extern int DohIsSequence(const DOH *obj); extern int DohIsString(const DOH *obj); extern int DohIsFile(const DOH *obj); extern void DohSetMaxHashExpand(int count); extern int DohGetMaxHashExpand(void); extern void DohSetmark(DOH *obj, int x); extern int DohGetmark(DOH *obj); /* Set the function for DohExit() to call instead of exit(). * * The registered function can perform clean up, etc. It should simply * return when done and then exit() will get called. Bear in mind that * the handler function can be called after malloc() has failed, so it's * a good idea for it to avoid allocating additional memory. * * The registered handler function is unregistered by DohExit() before calling * it to avoid the potential for infinite loops. * * Note: This is sort of like C's atexit(), only for DohExit(). However * only one function can be registered (setting a new function overrides the * previous one) and the registered function is passed the exit status so can * vary its actions based on that. */ extern void DohSetExitHandler(void (*new_handler)(int)); extern void DohExit(int status); /* ----------------------------------------------------------------------------- * Strings. * ----------------------------------------------------------------------------- */ extern DOHString *DohNewStringEmpty(void); extern DOHString *DohNewString(const DOHString_or_char *c); extern DOHString *DohNewStringWithSize(const DOHString_or_char *c, int len); extern DOHString *DohNewStringf(const DOHString_or_char *fmt, ...); extern int DohStrcmp(const DOHString_or_char *s1, const DOHString_or_char *s2); extern int DohStrncmp(const DOHString_or_char *s1, const DOHString_or_char *s2, int n); extern char *DohStrstr(const DOHString_or_char *s1, const DOHString_or_char *s2); extern char *DohStrchr(const DOHString_or_char *s1, int ch); /* String replacement flags */ #define DOH_REPLACE_ANY 0x01 #define DOH_REPLACE_NOQUOTE 0x02 #define DOH_REPLACE_NOCOMMENT 0x04 #define DOH_REPLACE_ID 0x08 #define DOH_REPLACE_FIRST 0x10 #define DOH_REPLACE_ID_BEGIN 0x20 #define DOH_REPLACE_ID_END 0x40 #define DOH_REPLACE_NUMBER_END 0x80 #define Replaceall(s,t,r) DohReplace(s,t,r,DOH_REPLACE_ANY) #define Replaceid(s,t,r) DohReplace(s,t,r,DOH_REPLACE_ID) /* ----------------------------------------------------------------------------- * Files * ----------------------------------------------------------------------------- */ extern DOHFile *DohNewFile(DOHString *filename, const char *mode, DOHList *outfiles); extern DOHFile *DohNewFileFromFile(FILE *f); extern DOHFile *DohNewFileFromFd(int fd); extern void DohFileErrorDisplay(DOHString * filename); extern int DohCopyto(DOHFile * input, DOHFile * output); extern void DohCloseAllOpenFiles(void); /* ----------------------------------------------------------------------------- * List * ----------------------------------------------------------------------------- */ extern DOHList *DohNewList(void); extern void DohSortList(DOH *lo, int (*cmp) (const DOH *, const DOH *)); /* ----------------------------------------------------------------------------- * Hash * ----------------------------------------------------------------------------- */ extern DOHHash *DohNewHash(void); /* ----------------------------------------------------------------------------- * Void * ----------------------------------------------------------------------------- */ extern DOHVoid *DohNewVoid(void *ptr, void (*del) (void *)); extern DOHList *DohSplit(DOHFile * input, char ch, int nsplits); extern DOHList *DohSplitLines(DOHFile * input); extern DOH *DohNone; /* Helper union for converting between function and object pointers. */ typedef union DohFuncPtr { void* p; DOH *(*func)(DOH *); } DohFuncPtr_t; extern void DohMemoryDebug(void); #ifndef DOH_LONG_NAMES /* Macros to invoke the above functions. Includes the location of the caller to simplify debugging if something goes wrong */ #define Delete DohDelete #define Copy DohCopy #define Clear DohClear #define Str DohStr #define Dump DohDump #define Getattr DohGetattr #define Setattr DohSetattr #define Delattr DohDelattr #define Checkattr DohCheckattr #define Hashval DohHashval #define Getitem DohGetitem #define Setitem DohSetitem #define Delitem DohDelitem #define Insert DohInsertitem #define Delslice DohDelslice #define Append(s,x) DohInsertitem(s,DOH_END,x) #define Push(s,x) DohInsertitem(s,DOH_BEGIN,x) #define Len DohLen #define Data DohData #define Char(X) ((char *) Data(X)) #define Cmp DohCmp #define Equal DohEqual #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 Printv DohPrintv #define Getc DohGetc #define Putc DohPutc #define Ungetc DohUngetc /* #define StringPutc DohStringPutc */ /* #define StringGetc DohStringGetc */ /* #define StringUngetc DohStringUngetc */ /* #define StringAppend Append */ /* #define StringLen DohStringLen */ /* #define StringChar DohStringChar */ /* #define StringEqual DohStringEqual */ #define vPrintf DohvPrintf #define GetInt DohGetInt #define GetDouble DohGetDouble #define GetChar DohGetChar #define GetVoid DohGetVoid #define GetFlagAttr DohGetFlagAttr #define GetFlag DohGetFlag #define SetInt DohSetInt #define SetDouble DohSetDouble #define SetChar DohSetattr #define SetVoid DohSetVoid #define SetFlagAttr DohSetFlagAttr #define SetFlag DohSetFlag #define UnsetFlag(o,n) DohSetFlagAttr(o,n,NULL) #define ClearFlag(o,n) DohSetFlagAttr(o,n,"") #define Readline DohReadline #define Replace DohReplace #define Chop DohChop #define Getmeta DohGetmeta #define Setmeta DohSetmeta #define Delmeta DohDelmeta #define NewString DohNewString #define NewStringEmpty DohNewStringEmpty #define NewStringWithSize DohNewStringWithSize #define NewStringf DohNewStringf #define NewHash DohNewHash #define NewList DohNewList #define NewFile DohNewFile #define NewFileFromFile DohNewFileFromFile #define NewFileFromFd DohNewFileFromFd #define FileErrorDisplay DohFileErrorDisplay #define NewVoid DohNewVoid #define Keys DohKeys #define SortedKeys DohSortedKeys #define Strcmp DohStrcmp #define Strncmp DohStrncmp #define Strstr DohStrstr #define Strchr DohStrchr #define Copyto DohCopyto #define CloseAllOpenFiles DohCloseAllOpenFiles #define Split DohSplit #define SplitLines DohSplitLines #define Setmark DohSetmark #define Getmark DohGetmark #define SetMaxHashExpand DohSetMaxHashExpand #define GetMaxHashExpand DohGetMaxHashExpand #define None DohNone #define Call DohCall #define First DohFirst #define Next DohNext #define Iterator DohIterator #define SortList DohSortList #define Malloc DohMalloc #define Realloc DohRealloc #define Calloc DohCalloc #define Free DohFree #define SetExitHandler DohSetExitHandler #define Exit DohExit #endif #ifdef NIL #undef NIL #endif #define NIL (char *) NULL /* Defines to allow use of poisoned identifiers. * * For DOH-internal use only! */ #define doh_internal_calloc calloc #define doh_internal_exit exit /* doh_internal_free not needed as Free() is a macro defined above. */ #define doh_internal_malloc malloc #define doh_internal_realloc realloc #if defined __GNUC__ && defined DOH_POISON /* Use Malloc(), Realloc(), Calloc(), and Free() instead (which will exit with * an error rather than return NULL). */ # ifndef DOH_NO_POISON_MALLOC_FREE /* This works around bison's template checking if malloc and free are defined, * which triggers GCC's poison checks. */ # pragma GCC poison malloc free # endif # pragma GCC poison realloc calloc /* Use Exit() instead (which will remove output files on error). */ # pragma GCC poison abort exit #endif #endif /* SWIG_DOH_H */