/tags/rel-1-3-24/SWIG/Source/DOH/doh.h

# · C++ Header · 404 lines · 285 code · 63 blank · 56 comment · 0 complexity · e0fd076cef4bb1f246d0fa2fbbf61b7a MD5 · raw file 

    

  1. /* -----------------------------------------------------------------------------
    2. 

  2.  * doh.h
    3. 

  3.  *
    4. 

  4.  *     This file describes of the externally visible functions in DOH.
    5. 

  5.  *
    6. 

  6.  * Author(s) : David Beazley (beazley@cs.uchicago.edu)
    7. 

  7.  *
    8. 

  8.  * Copyright (C) 1999-2000.  The University of Chicago
    9. 

  9.  * See the file LICENSE for information on usage and redistribution.
    10. 

  10.  *
    11. 

  11.  * $Header$
    12. 

  12.  * ----------------------------------------------------------------------------- */
    13. 

  13. 

  14. #ifndef _DOH_H
    15. 

  15. #define _DOH_H
    16. 

  16. 

  17. /* Set the namespace prefix for DOH API functions. This can be used to control
    18. 

  18.    visibility of the functions in libraries */
    19. 

  19. 

  20. /* Set this macro if you want to change DOH linkage. You would do this if you
    21. 

  21.    wanted to hide DOH in a library using a different set of names.  Note: simply
    22. 

  22.    change "Doh" to a new name. */
    23. 

  23. 

  24. /*
    25. 

  25. #define DOH_NAMESPACE(x) Doh ## x
    26. 

  26. */
    27. 

  27. 

  28. #ifdef DOH_NAMESPACE
    29. 

  29. 

  30. /* Namespace control.  These macros define all of the public API names in DOH */
    31. 

  31. 

  32. #define DohCheck           DOH_NAMESPACE(Check)
    33. 

  33. #define DohIntern          DOH_NAMESPACE(Intern)
    34. 

  34. #define DohDelete          DOH_NAMESPACE(Delete)
    35. 

  35. #define DohCopy            DOH_NAMESPACE(Copy)
    36. 

  36. #define DohClear           DOH_NAMESPACE(Clear)
    37. 

  37. #define DohStr             DOH_NAMESPACE(Str)
    38. 

  38. #define DohData            DOH_NAMESPACE(Data)
    39. 

  39. #define DohDump            DOH_NAMESPACE(Dump)
    40. 

  40. #define DohLen             DOH_NAMESPACE(Len)
    41. 

  41. #define DohHashval         DOH_NAMESPACE(Hashval)
    42. 

  42. #define DohCmp             DOH_NAMESPACE(Cmp)
    43. 

  43. #define DohIncref          DOH_NAMESPACE(Incref)
    44. 

  44. #define DohGetattr         DOH_NAMESPACE(Getattr)
    45. 

  45. #define DohSetattr         DOH_NAMESPACE(Setattr)
    46. 

  46. #define DohDelattr         DOH_NAMESPACE(Delattr)
    47. 

  47. #define DohKeys            DOH_NAMESPACE(Keys)
    48. 

  48. #define DohGetInt          DOH_NAMESPACE(GetInt)
    49. 

  49. #define DohGetDouble       DOH_NAMESPACE(GetDouble)
    50. 

  50. #define DohGetChar         DOH_NAMESPACE(GetChar)
    51. 

  51. #define DohSetChar         DOH_NAMESPACE(SetChar)
    52. 

  52. #define DohSetInt          DOH_NAMESPACE(SetInt)
    53. 

  53. #define DohSetDouble       DOH_NAMESPACE(SetDouble)
    54. 

  54. #define DohSetVoid         DOH_NAMESPACE(SetVoid)
    55. 

  55. #define DohGetVoid         DOH_NAMESPACE(GetVoid)
    56. 

  56. #define DohGetitem         DOH_NAMESPACE(Getitem)
    57. 

  57. #define DohSetitem         DOH_NAMESPACE(Setitem)
    58. 

  58. #define DohDelitem         DOH_NAMESPACE(Delitem)
    59. 

  59. #define DohInsertitem      DOH_NAMESPACE(Insertitem)
    60. 

  60. #define DohDelslice        DOH_NAMESPACE(Delslice)
    61. 

  61. #define DohWrite           DOH_NAMESPACE(Write)
    62. 

  62. #define DohRead            DOH_NAMESPACE(Read)
    63. 

  63. #define DohSeek            DOH_NAMESPACE(Seek)
    64. 

  64. #define DohTell            DOH_NAMESPACE(Tell)
    65. 

  65. #define DohGetc            DOH_NAMESPACE(Getc)
    66. 

  66. #define DohPutc            DOH_NAMESPACE(Putc)
    67. 

  67. #define DohUngetc          DOH_NAMESPACE(Ungetc)
    68. 

  68. #define DohGetline         DOH_NAMESPACE(Getline)
    69. 

  69. #define DohSetline         DOH_NAMESPACE(Setline)
    70. 

  70. #define DohGetfile         DOH_NAMESPACE(Getfile)
    71. 

  71. #define DohSetfile         DOH_NAMESPACE(Setfile)
    72. 

  72. #define DohReplace         DOH_NAMESPACE(Replace)
    73. 

  73. #define DohChop            DOH_NAMESPACE(Chop)
    74. 

  74. #define DohGetmeta         DOH_NAMESPACE(Getmeta)
    75. 

  75. #define DohSetmeta         DOH_NAMESPACE(Setmeta)
    76. 

  76. #define DohDelmeta         DOH_NAMESPACE(Delmeta)
    77. 

  77. #define DohEncoding        DOH_NAMESPACE(Encoding)
    78. 

  78. #define DohPrintf          DOH_NAMESPACE(Printf)
    79. 

  79. #define DohvPrintf         DOH_NAMESPACE(vPrintf)
    80. 

  80. #define DohPrintv          DOH_NAMESPACE(Printv)
    81. 

  81. #define DohReadline        DOH_NAMESPACE(Readline)
    82. 

  82. #define DohIsMapping       DOH_NAMESPACE(IsMapping)
    83. 

  83. #define DohIsSequence      DOH_NAMESPACE(IsSequence)
    84. 

  84. #define DohIsString        DOH_NAMESPACE(IsString)
    85. 

  85. #define DohIsFile          DOH_NAMESPACE(IsFile)
    86. 

  86. #define DohNewString       DOH_NAMESPACE(NewString)
    87. 

  87. #define DohNewStringWithSize  DOH_NAMESPACE(NewStringWithSize)
    88. 

  88. #define DohNewStringf      DOH_NAMESPACE(NewStringf)
    89. 

  89. #define DohStrcmp          DOH_NAMESPACE(Strcmp)
    90. 

  90. #define DohStrncmp         DOH_NAMESPACE(Strncmp)
    91. 

  91. #define DohStrstr          DOH_NAMESPACE(Strstr)
    92. 

  92. #define DohStrchr          DOH_NAMESPACE(Strchr)
    93. 

  93. #define DohNewFile         DOH_NAMESPACE(NewFile)
    94. 

  94. #define DohNewFileFromFile DOH_NAMESPACE(NewFileFromFile)
    95. 

  95. #define DohNewFileFromFd   DOH_NAMESPACE(NewFileFromFd)
    96. 

  96. #define DohClose           DOH_NAMESPACE(Close)
    97. 

  97. #define DohCopyto          DOH_NAMESPACE(Copyto)
    98. 

  98. #define DohNewList         DOH_NAMESPACE(NewList)
    99. 

  99. #define DohNewHash         DOH_NAMESPACE(NewHash)
    100. 

  100. #define DohNewVoid         DOH_NAMESPACE(NewVoid)
    101. 

  101. #define DohSplit           DOH_NAMESPACE(Split)
    102. 

  102. #define DohSplitLines      DOH_NAMESPACE(SplitLines)
    103. 

  103. #define DohNone            DOH_NAMESPACE(None)
    104. 

  104. #define DohCall            DOH_NAMESPACE(Call)
    105. 

  105. #define DohObjMalloc       DOH_NAMESPACE(ObjMalloc)
    106. 

  106. #define DohObjFree         DOH_NAMESPACE(ObjFree)
    107. 

  107. #define DohMemoryDebug     DOH_NAMESPACE(MemoryDebug)
    108. 

  108. #define DohStringType      DOH_NAMESPACE(StringType)
    109. 

  109. #define DohListType        DOH_NAMESPACE(ListType)
    110. 

  110. #define DohHashType        DOH_NAMESPACE(HashType)
    111. 

  111. #define DohFileType        DOH_NAMESPACE(FileType)
    112. 

  112. #define DohVoidType        DOH_NAMESPACE(VoidType)
    113. 

  113. #define DohIterator        DOH_NAMESPACE(Iterator)
    114. 

  114. #define DohFirst           DOH_NAMESPACE(First)
    115. 

  115. #define DohNext            DOH_NAMESPACE(Next)
    116. 

  116. #endif
    117. 

  117. 

  118. #include <stdio.h>
    119. 

  119. #include <stdarg.h>
    120. 

  120. 

  121. #define DOH_MAJOR_VERSION 0
    122. 

  122. #define DOH_MINOR_VERSION 1
    123. 

  123. 

  124. typedef void DOH;
    125. 

  125. 

  126. /*
    127. 

  127.  * With dynamic typing, all DOH objects are technically of type 'void *'.
    128. 

  128.  * However, to clarify the reading of source code, the following symbolic
    129. 

  129.  * names are used.
    130. 

  130.  */
    131. 

  131. 

  132. #define DOHString          DOH
    133. 

  133. #define DOHList            DOH
    134. 

  134. #define DOHHash            DOH
    135. 

  135. #define DOHFile            DOH
    136. 

  136. #define DOHVoid            DOH
    137. 

  137. #define DOHString_or_char  DOH
    138. 

  138. #define DOHObj_or_char     DOH
    139. 

  139. 

  140. #define DOH_BEGIN          -1
    141. 

  141. #define DOH_END            -2
    142. 

  142. #define DOH_CUR            -3
    143. 

  143. #define DOH_CURRENT        -3
    144. 

  144. 

  145. /* Iterator objects */
    146. 

  146. 

  147. typedef struct {
    148. 

  148.   void   *key;             /* Current key (if any)       */
    149. 

  149.   void   *item;            /* Current item               */
    150. 

  150.   void   *object;          /* Object being iterated over */
    151. 

  151.   void   *_current;        /* Internal use */
    152. 

  152.   int    _index;           /* Internal use */
    153. 

  153. } DohIterator;
    154. 

  154. 

  155. /* Memory management */
    156. 

  156. 

  157. #ifndef DohMalloc
    158. 

  158. #define DohMalloc malloc
    159. 

  159. #endif
    160. 

  160. #ifndef DohRealloc
    161. 

  161. #define DohRealloc realloc
    162. 

  162. #endif
    163. 

  163. #ifndef DohFree
    164. 

  164. #define DohFree free
    165. 

  165. #endif
    166. 

  166. 

  167. extern int           DohCheck(const DOH *ptr);           /* Check if a DOH object */
    168. 

  168. extern void          DohIntern(DOH *);                   /* Intern an object      */
    169. 

  169. 

  170. /* Basic object methods.  Common to most objects */
    171. 

  171. 

  172. extern void          DohDelete(DOH *obj);                /* Delete an object      */
    173. 

  173. extern DOH          *DohCopy(const DOH *obj);
    174. 

  174. extern void          DohClear(DOH *obj);
    175. 

  175. extern DOHString    *DohStr(const DOH *obj);
    176. 

  176. extern void         *DohData(const DOH *obj);
    177. 

  177. extern int           DohDump(const DOH *obj, DOHFile *out);
    178. 

  178. extern int           DohLen(const DOH *obj);
    179. 

  179. extern int           DohHashval(const DOH *obj);
    180. 

  180. extern int           DohCmp(const DOH *obj1, const DOH *obj2);
    181. 

  181. extern void          DohIncref(DOH *obj);
    182. 

  182. 

  183. /* Mapping methods */
    184. 

  184. 

  185. extern DOH          *DohGetattr(DOH *obj, const DOHString_or_char *name);
    186. 

  186. extern int           DohSetattr(DOH *obj, const DOHString_or_char *name, const DOHObj_or_char *value);
    187. 

  187. extern int           DohDelattr(DOH *obj, const DOHString_or_char *name);
    188. 

  188. extern DOH          *DohKeys(DOH *obj);
    189. 

  189. extern int           DohGetInt(DOH *obj, const DOHString_or_char *name);
    190. 

  190. extern double        DohGetDouble(DOH *obj, const DOHString_or_char *name);
    191. 

  191. extern char         *DohGetChar(DOH *obj, const DOHString_or_char *name);
    192. 

  192. extern void          DohSetInt(DOH *obj, const DOHString_or_char *name, int);
    193. 

  193. extern void          DohSetDouble(DOH *obj, const DOHString_or_char *name, double);
    194. 

  194. extern void         *DohGetVoid(DOH *obj, const DOHString_or_char *name);
    195. 

  195. extern void          DohSetVoid(DOH *obj, const DOHString_or_char *name, void *value);
    196. 

  196. 

  197. /* Sequence methods */
    198. 

  198. 

  199. extern DOH          *DohGetitem(DOH *obj, int index);
    200. 

  200. extern int           DohSetitem(DOH *obj, int index, const DOHObj_or_char *value);
    201. 

  201. extern int           DohDelitem(DOH *obj, int index);
    202. 

  202. extern int           DohInsertitem(DOH *obj, int index, const DOHObj_or_char *value);
    203. 

  203. extern int           DohDelslice(DOH *obj, int sindex, int eindex);
    204. 

  204. 

  205. /* File methods */
    206. 

  206. 

  207. extern int           DohWrite(DOHFile *obj, void *buffer, int length);
    208. 

  208. extern int           DohRead(DOHFile *obj, void *buffer, int length);
    209. 

  209. extern int           DohSeek(DOHFile *obj, long offset, int whence);
    210. 

  210. extern long          DohTell(DOHFile *obj);
    211. 

  211. extern int           DohGetc(DOHFile *obj);
    212. 

  212. extern int           DohPutc(int ch, DOHFile *obj);
    213. 

  213. extern int           DohUngetc(int ch, DOHFile *obj);
    214. 

  214. 

  215. /* Iterators */
    216. 

  216. extern DohIterator   DohFirst(DOH *obj);
    217. 

  217. extern DohIterator   DohNext(DohIterator x);
    218. 

  218. 

  219. /* Positional */
    220. 

  220. 

  221. extern int           DohGetline(DOH *obj);
    222. 

  222. extern void          DohSetline(DOH *obj, int line);
    223. 

  223. extern DOH          *DohGetfile(DOH *obj);
    224. 

  224. extern void          DohSetfile(DOH *obj, DOH *file);
    225. 

  225. 

  226.   /* String Methods */
    227. 

  227. 

  228. extern int           DohReplace(DOHString *src, const DOHString_or_char *token, const DOHString_or_char *rep, int flags);
    229. 

  229. extern void          DohChop(DOHString *src);
    230. 

  230. 

  231. /* Meta-variables */
    232. 

  232. extern DOH          *DohGetmeta(DOH *, const DOH *);
    233. 

  233. extern int           DohSetmeta(DOH *, const DOH *, const DOH *value);
    234. 

  234. extern int           DohDelmeta(DOH *, const DOH *);
    235. 

  235. 

  236.   /* Utility functions */
    237. 

  237. 

  238. extern void          DohEncoding(char *name, DOH *(*fn)(DOH *s));
    239. 

  239. extern int           DohPrintf(DOHFile *obj, const char *format, ...);
    240. 

  240. extern int           DohvPrintf(DOHFile *obj, const char *format, va_list ap);
    241. 

  241. extern int           DohPrintv(DOHFile *obj, ...);
    242. 

  242. extern DOH          *DohReadline(DOHFile *in);
    243. 

  243. 

  244.   /* Miscellaneous */
    245. 

  245. 

  246. extern int           DohIsMapping(const DOH *obj);
    247. 

  247. extern int           DohIsSequence(const DOH *obj);
    248. 

  248. extern int           DohIsString(const DOH *obj);
    249. 

  249. extern int           DohIsFile(const DOH *obj);
    250. 

  250. 

  251. extern void          DohSetmark(DOH *obj, int x);
    252. 

  252. extern int           DohGetmark(DOH *obj);
    253. 

  253. 

  254. /* -----------------------------------------------------------------------------
    255. 

  255.  * Strings.
    256. 

  256.  * ----------------------------------------------------------------------------- */
    257. 

  257. 

  258. extern DOHString    *DohNewString(const DOH *c);
    259. 

  259. extern DOHString    *DohNewStringWithSize(const DOH *c, int len);
    260. 

  260. extern DOHString    *DohNewStringf(const DOH *fmt, ...);
    261. 

  261. 

  262. extern int   DohStrcmp(const DOHString_or_char *s1, const DOHString_or_char *s2);
    263. 

  263. extern int   DohStrncmp(const DOHString_or_char *s1, const DOHString_or_char *s2, int n);
    264. 

  264. extern char *DohStrstr(const DOHString_or_char *s1, const DOHString_or_char *s2);
    265. 

  265. extern char *DohStrchr(const DOHString_or_char *s1, int ch);
    266. 

  266. 

  267. /* String replacement flags */
    268. 

  268. 

  269. #define   DOH_REPLACE_ANY         0x01
    270. 

  270. #define   DOH_REPLACE_NOQUOTE     0x02
    271. 

  271. #define   DOH_REPLACE_ID          0x04
    272. 

  272. #define   DOH_REPLACE_FIRST       0x08
    273. 

  273. #define   DOH_REPLACE_ID_BEGIN    0x10
    274. 

  274. #define   DOH_REPLACE_ID_END      0x20
    275. 

  275. 

  276. #define Replaceall(s,t,r)  DohReplace(s,t,r,DOH_REPLACE_ANY)
    277. 

  277. #define Replaceid(s,t,r)   DohReplace(s,t,r,DOH_REPLACE_ID)
    278. 

  278. 

  279. /* -----------------------------------------------------------------------------
    280. 

  280.  * Files
    281. 

  281.  * ----------------------------------------------------------------------------- */
    282. 

  282. 

  283. extern DOHFile *DohNewFile(DOH *file, const char *mode);
    284. 

  284. extern DOHFile *DohNewFileFromFile(FILE *f);
    285. 

  285. extern DOHFile *DohNewFileFromFd(int fd);
    286. 

  286. extern int      DohClose(DOH *file);
    287. 

  287. extern int      DohCopyto(DOHFile *input, DOHFile *output);
    288. 

  288. 

  289. 

  290. /* -----------------------------------------------------------------------------
    291. 

  291.  * List
    292. 

  292.  * ----------------------------------------------------------------------------- */
    293. 

  293. 

  294. extern DOHList  *DohNewList();
    295. 

  295. 

  296. /* -----------------------------------------------------------------------------
    297. 

  297.  * Hash
    298. 

  298.  * ----------------------------------------------------------------------------- */
    299. 

  299. 

  300. extern DOHHash   *DohNewHash();
    301. 

  301. 

  302. /* -----------------------------------------------------------------------------
    303. 

  303.  * Void
    304. 

  304.  * ----------------------------------------------------------------------------- */
    305. 

  305. 

  306. extern DOHVoid  *DohNewVoid(void *ptr, void (*del)(void *));
    307. 

  307. extern DOHList  *DohSplit(DOHFile *input, char ch, int nsplits);
    308. 

  308. extern DOHList  *DohSplitLines(DOHFile *input);
    309. 

  309. extern DOH      *DohNone;
    310. 

  310. 

  311. extern void      DohMemoryDebug(void);
    312. 

  312. 

  313. #ifndef DOH_LONG_NAMES
    314. 

  314. /* Macros to invoke the above functions.  Includes the location of
    315. 

  315.    the caller to simplify debugging if something goes wrong */
    316. 

  316. 

  317. #define Delete             DohDelete
    318. 

  318. #define Copy               DohCopy
    319. 

  319. #define Clear              DohClear
    320. 

  320. #define Str                DohStr
    321. 

  321. #define Dump               DohDump
    322. 

  322. #define Getattr            DohGetattr
    323. 

  323. #define Setattr            DohSetattr
    324. 

  324. #define Delattr            DohDelattr
    325. 

  325. #define Hashval            DohHashval
    326. 

  326. #define Getitem            DohGetitem
    327. 

  327. #define Setitem            DohSetitem
    328. 

  328. #define Delitem            DohDelitem
    329. 

  329. #define Insert             DohInsertitem
    330. 

  330. #define Delslice           DohDelslice
    331. 

  331. #define Append(s,x)        DohInsertitem(s,DOH_END,x)
    332. 

  332. #define Push(s,x)          DohInsertitem(s,DOH_BEGIN,x)
    333. 

  333. #define Len                DohLen
    334. 

  334. #define Data               DohData
    335. 

  335. #define Char               (char *) Data
    336. 

  336. #define Cmp                DohCmp
    337. 

  337. #define Setline            DohSetline
    338. 

  338. #define Getline            DohGetline
    339. 

  339. #define Setfile            DohSetfile
    340. 

  340. #define Getfile            DohGetfile
    341. 

  341. #define Write              DohWrite
    342. 

  342. #define Read               DohRead
    343. 

  343. #define Seek               DohSeek
    344. 

  344. #define Tell               DohTell
    345. 

  345. #define Printf             DohPrintf
    346. 

  346. #define Printv             DohPrintv
    347. 

  347. #define Getc               DohGetc
    348. 

  348. #define Putc               DohPutc
    349. 

  349. #define Ungetc             DohUngetc
    350. 

  350. #define Close              DohClose
    351. 

  351. #define vPrintf            DohvPrintf
    352. 

  352. #define GetInt             DohGetInt
    353. 

  353. #define GetDouble          DohGetDouble
    354. 

  354. #define GetChar            DohGetChar
    355. 

  355. #define GetVoid            DohGetVoid
    356. 

  356. #define SetInt             DohSetInt
    357. 

  357. #define SetDouble          DohSetDouble
    358. 

  358. #define SetChar            DohSetattr
    359. 

  359. #define SetVoid            DohSetVoid
    360. 

  360. #define Readline           DohReadline
    361. 

  361. #define Replace            DohReplace
    362. 

  362. #define Chop               DohChop
    363. 

  363. #define Getmeta            DohGetmeta
    364. 

  364. #define Setmeta            DohSetmeta
    365. 

  365. #define Delmeta            DohDelmeta
    366. 

  366. #define NewString          DohNewString
    367. 

  367. #define NewStringWithSize  DohNewStringWithSize
    368. 

  368. #define NewStringf         DohNewStringf
    369. 

  369. #define NewHash            DohNewHash
    370. 

  370. #define NewList            DohNewList
    371. 

  371. #define NewFile            DohNewFile
    372. 

  372. #define NewFileFromFile    DohNewFileFromFile
    373. 

  373. #define NewFileFromFd      DohNewFileFromFd
    374. 

  374. #define Close              DohClose
    375. 

  375. #define NewVoid            DohNewVoid
    376. 

  376. #define Keys               DohKeys
    377. 

  377. #define Strcmp             DohStrcmp
    378. 

  378. #define Strncmp            DohStrncmp
    379. 

  379. #define Strstr             DohStrstr
    380. 

  380. #define Strchr             DohStrchr
    381. 

  381. #define Copyto             DohCopyto
    382. 

  382. #define Split              DohSplit
    383. 

  383. #define SplitLines         DohSplitLines
    384. 

  384. #define Setmark            DohSetmark
    385. 

  385. #define Getmark            DohGetmark
    386. 

  386. #define None               DohNone
    387. 

  387. #define Call               DohCall
    388. 

  388. #define First              DohFirst
    389. 

  389. #define Next               DohNext
    390. 

  390. #define Iterator           DohIterator
    391. 

  391. #endif
    392. 

  392. 

  393. #ifdef NIL
    394. 

  394. #undef NIL
    395. 

  395. #endif
    396. 

  396. 

  397. #define NIL  (char *) NULL
    398. 

  398. 

  399. 

  400. #endif /* DOH_H */
    401.