/tags/rel-2.0.1/Source/DOH/doh.h

# · C++ Header · 446 lines · 318 code · 65 blank · 63 comment · 0 complexity · 1c02e31b008db1d5ca47168736825533 MD5 · raw file 

    

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

  2.  * This file is part of SWIG, which is licensed as a whole under version 3 
    3. 

  3.  * (or any later version) of the GNU General Public License. Some additional
    4. 

  4.  * terms also apply to certain portions of SWIG. The full details of the SWIG
    5. 

  5.  * license and copyrights can be found in the LICENSE and COPYRIGHT files
    6. 

  6.  * included with the SWIG source code as distributed by the SWIG developers
    7. 

  7.  * and at http://www.swig.org/legal.html.
    8. 

  8.  *
    9. 

  9.  * doh.h
    10. 

  10.  *
    11. 

  11.  *     This file describes of the externally visible functions in DOH.
    12. 

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

  13. 

  14. #ifndef _DOH_H
    15. 

  15. #define _DOH_H
    16. 

  16. 

  17. #ifndef MACSWIG
    18. 

  18. #include "swigconfig.h"
    19. 

  19. #endif
    20. 

  20. 

  21. #include <stdio.h>
    22. 

  22. #include <stdarg.h>
    23. 

  23. 

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

  25.    visibility of the functions in libraries */
    26. 

  26. 

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

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

  29.    change "Doh" to a new name. */
    30. 

  30. 

  31. /*
    32. 

  32. #define DOH_NAMESPACE(x) Doh ## x
    33. 

  33. */
    34. 

  34. 

  35. #ifdef DOH_NAMESPACE
    36. 

  36. 

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

  38. 

  39. #define DohCheck           DOH_NAMESPACE(Check)
    40. 

  40. #define DohIntern          DOH_NAMESPACE(Intern)
    41. 

  41. #define DohDelete          DOH_NAMESPACE(Delete)
    42. 

  42. #define DohCopy            DOH_NAMESPACE(Copy)
    43. 

  43. #define DohClear           DOH_NAMESPACE(Clear)
    44. 

  44. #define DohStr             DOH_NAMESPACE(Str)
    45. 

  45. #define DohData            DOH_NAMESPACE(Data)
    46. 

  46. #define DohDump            DOH_NAMESPACE(Dump)
    47. 

  47. #define DohLen             DOH_NAMESPACE(Len)
    48. 

  48. #define DohHashval         DOH_NAMESPACE(Hashval)
    49. 

  49. #define DohCmp             DOH_NAMESPACE(Cmp)
    50. 

  50. #define DohEqual           DOH_NAMESPACE(Equal)
    51. 

  51. #define DohIncref          DOH_NAMESPACE(Incref)
    52. 

  52. #define DohCheckattr       DOH_NAMESPACE(Checkattr)
    53. 

  53. #define DohSetattr         DOH_NAMESPACE(Setattr)
    54. 

  54. #define DohDelattr         DOH_NAMESPACE(Delattr)
    55. 

  55. #define DohKeys            DOH_NAMESPACE(Keys)
    56. 

  56. #define DohGetInt          DOH_NAMESPACE(GetInt)
    57. 

  57. #define DohGetDouble       DOH_NAMESPACE(GetDouble)
    58. 

  58. #define DohGetChar         DOH_NAMESPACE(GetChar)
    59. 

  59. #define DohSetChar         DOH_NAMESPACE(SetChar)
    60. 

  60. #define DohSetInt          DOH_NAMESPACE(SetInt)
    61. 

  61. #define DohSetDouble       DOH_NAMESPACE(SetDouble)
    62. 

  62. #define DohSetVoid         DOH_NAMESPACE(SetVoid)
    63. 

  63. #define DohGetVoid         DOH_NAMESPACE(GetVoid)
    64. 

  64. #define DohGetitem         DOH_NAMESPACE(Getitem)
    65. 

  65. #define DohSetitem         DOH_NAMESPACE(Setitem)
    66. 

  66. #define DohDelitem         DOH_NAMESPACE(Delitem)
    67. 

  67. #define DohInsertitem      DOH_NAMESPACE(Insertitem)
    68. 

  68. #define DohDelslice        DOH_NAMESPACE(Delslice)
    69. 

  69. #define DohWrite           DOH_NAMESPACE(Write)
    70. 

  70. #define DohRead            DOH_NAMESPACE(Read)
    71. 

  71. #define DohSeek            DOH_NAMESPACE(Seek)
    72. 

  72. #define DohTell            DOH_NAMESPACE(Tell)
    73. 

  73. #define DohGetc            DOH_NAMESPACE(Getc)
    74. 

  74. #define DohPutc            DOH_NAMESPACE(Putc)
    75. 

  75. #define DohUngetc          DOH_NAMESPACE(Ungetc)
    76. 

  76. #define DohGetline         DOH_NAMESPACE(Getline)
    77. 

  77. #define DohSetline         DOH_NAMESPACE(Setline)
    78. 

  78. #define DohGetfile         DOH_NAMESPACE(Getfile)
    79. 

  79. #define DohSetfile         DOH_NAMESPACE(Setfile)
    80. 

  80. #define DohReplace         DOH_NAMESPACE(Replace)
    81. 

  81. #define DohChop            DOH_NAMESPACE(Chop)
    82. 

  82. #define DohGetmeta         DOH_NAMESPACE(Getmeta)
    83. 

  83. #define DohSetmeta         DOH_NAMESPACE(Setmeta)
    84. 

  84. #define DohDelmeta         DOH_NAMESPACE(Delmeta)
    85. 

  85. #define DohEncoding        DOH_NAMESPACE(Encoding)
    86. 

  86. #define DohPrintf          DOH_NAMESPACE(Printf)
    87. 

  87. #define DohvPrintf         DOH_NAMESPACE(vPrintf)
    88. 

  88. #define DohPrintv          DOH_NAMESPACE(Printv)
    89. 

  89. #define DohReadline        DOH_NAMESPACE(Readline)
    90. 

  90. #define DohIsMapping       DOH_NAMESPACE(IsMapping)
    91. 

  91. #define DohIsSequence      DOH_NAMESPACE(IsSequence)
    92. 

  92. #define DohIsString        DOH_NAMESPACE(IsString)
    93. 

  93. #define DohIsFile          DOH_NAMESPACE(IsFile)
    94. 

  94. #define DohNewString       DOH_NAMESPACE(NewString)
    95. 

  95. #define DohNewStringEmpty  DOH_NAMESPACE(NewStringEmpty)
    96. 

  96. #define DohNewStringWithSize  DOH_NAMESPACE(NewStringWithSize)
    97. 

  97. #define DohNewStringf      DOH_NAMESPACE(NewStringf)
    98. 

  98. #define DohStrcmp          DOH_NAMESPACE(Strcmp)
    99. 

  99. #define DohStrncmp         DOH_NAMESPACE(Strncmp)
    100. 

  100. #define DohStrstr          DOH_NAMESPACE(Strstr)
    101. 

  101. #define DohStrchr          DOH_NAMESPACE(Strchr)
    102. 

  102. #define DohNewFile         DOH_NAMESPACE(NewFile)
    103. 

  103. #define DohNewFileFromFile DOH_NAMESPACE(NewFileFromFile)
    104. 

  104. #define DohNewFileFromFd   DOH_NAMESPACE(NewFileFromFd)
    105. 

  105. #define DohFileErrorDisplay   DOH_NAMESPACE(FileErrorDisplay)
    106. 

  106. #define DohClose           DOH_NAMESPACE(Close)
    107. 

  107. #define DohCopyto          DOH_NAMESPACE(Copyto)
    108. 

  108. #define DohNewList         DOH_NAMESPACE(NewList)
    109. 

  109. #define DohNewHash         DOH_NAMESPACE(NewHash)
    110. 

  110. #define DohNewVoid         DOH_NAMESPACE(NewVoid)
    111. 

  111. #define DohSplit           DOH_NAMESPACE(Split)
    112. 

  112. #define DohSplitLines      DOH_NAMESPACE(SplitLines)
    113. 

  113. #define DohNone            DOH_NAMESPACE(None)
    114. 

  114. #define DohCall            DOH_NAMESPACE(Call)
    115. 

  115. #define DohObjMalloc       DOH_NAMESPACE(ObjMalloc)
    116. 

  116. #define DohObjFree         DOH_NAMESPACE(ObjFree)
    117. 

  117. #define DohMemoryDebug     DOH_NAMESPACE(MemoryDebug)
    118. 

  118. #define DohStringType      DOH_NAMESPACE(StringType)
    119. 

  119. #define DohListType        DOH_NAMESPACE(ListType)
    120. 

  120. #define DohHashType        DOH_NAMESPACE(HashType)
    121. 

  121. #define DohFileType        DOH_NAMESPACE(FileType)
    122. 

  122. #define DohVoidType        DOH_NAMESPACE(VoidType)
    123. 

  123. #define DohIterator        DOH_NAMESPACE(Iterator)
    124. 

  124. #define DohFirst           DOH_NAMESPACE(First)
    125. 

  125. #define DohNext            DOH_NAMESPACE(Next)
    126. 

  126. #endif
    127. 

  127. 

  128. #define DOH_MAJOR_VERSION 0
    129. 

  129. #define DOH_MINOR_VERSION 1
    130. 

  130. 

  131. typedef void DOH;
    132. 

  132. 

  133. /*
    134. 

  134.  * With dynamic typing, all DOH objects are technically of type 'void *'.
    135. 

  135.  * However, to clarify the reading of source code, the following symbolic
    136. 

  136.  * names are used.
    137. 

  137.  */
    138. 

  138. 

  139. #define DOHString          DOH
    140. 

  140. #define DOHList            DOH
    141. 

  141. #define DOHHash            DOH
    142. 

  142. #define DOHFile            DOH
    143. 

  143. #define DOHVoid            DOH
    144. 

  144. #define DOHString_or_char  DOH
    145. 

  145. #define DOHObj_or_char     DOH
    146. 

  146. 

  147. typedef const DOHString_or_char * const_String_or_char_ptr;
    148. 

  148. typedef const DOHString_or_char * DOHconst_String_or_char_ptr;
    149. 

  149. 

  150. #define DOH_BEGIN          -1
    151. 

  151. #define DOH_END            -2
    152. 

  152. #define DOH_CUR            -3
    153. 

  153. #define DOH_CURRENT        -3
    154. 

  154. 

  155. /* Iterator objects */
    156. 

  156. 

  157. typedef struct {
    158. 

  158.   void *key;			/* Current key (if any)       */
    159. 

  159.   void *item;			/* Current item               */
    160. 

  160.   void *object;			/* Object being iterated over */
    161. 

  161.   void *_current;		/* Internal use */
    162. 

  162.   int _index;			/* Internal use */
    163. 

  163. } DohIterator;
    164. 

  164. 

  165. /* Memory management */
    166. 

  166. 

  167. #ifndef DohMalloc
    168. 

  168. #define DohMalloc malloc
    169. 

  169. #endif
    170. 

  170. #ifndef DohRealloc
    171. 

  171. #define DohRealloc realloc
    172. 

  172. #endif
    173. 

  173. #ifndef DohFree
    174. 

  174. #define DohFree free
    175. 

  175. #endif
    176. 

  176. 

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

  178. extern void DohIntern(DOH *);	/* Intern an object      */
    179. 

  179. 

  180. /* Basic object methods.  Common to most objects */
    181. 

  181. 

  182. extern void DohDelete(DOH *obj);	/* Delete an object      */
    183. 

  183. extern DOH *DohCopy(const DOH *obj);
    184. 

  184. extern void DohClear(DOH *obj);
    185. 

  185. extern DOHString *DohStr(const DOH *obj);
    186. 

  186. extern void *DohData(const DOH *obj);
    187. 

  187. extern int DohDump(const DOH *obj, DOHFile * out);
    188. 

  188. extern int DohLen(const DOH *obj);
    189. 

  189. extern int DohHashval(const DOH *obj);
    190. 

  190. extern int DohCmp(const DOH *obj1, const DOH *obj2);
    191. 

  191. extern int DohEqual(const DOH *obj1, const DOH *obj2);
    192. 

  192. extern void DohIncref(DOH *obj);
    193. 

  193. 

  194. /* Mapping methods */
    195. 

  195. 

  196. extern DOH *DohGetattr(DOH *obj, const DOHString_or_char *name);
    197. 

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

  198. extern int DohDelattr(DOH *obj, const DOHString_or_char *name);
    199. 

  199. extern int DohCheckattr(DOH *obj, const DOHString_or_char *name, const DOHString_or_char *value);
    200. 

  200. extern DOH *DohKeys(DOH *obj);
    201. 

  201. extern int DohGetInt(DOH *obj, const DOHString_or_char *name);
    202. 

  202. extern void DohSetInt(DOH *obj, const DOHString_or_char *name, int);
    203. 

  203. extern double DohGetDouble(DOH *obj, const DOHString_or_char *name);
    204. 

  204. extern void DohSetDouble(DOH *obj, const DOHString_or_char *name, double);
    205. 

  205. extern char *DohGetChar(DOH *obj, const DOHString_or_char *name);
    206. 

  206. extern void DohSetChar(DOH *obj, const DOH *name, char *value);
    207. 

  207. extern void *DohGetFlagAttr(DOH *obj, const DOHString_or_char *name);
    208. 

  208. extern int DohGetFlag(DOH *obj, const DOHString_or_char *name);
    209. 

  209. extern void DohSetFlagAttr(DOH *obj, const DOHString_or_char *name, const DOHString_or_char *attr);
    210. 

  210. extern void DohSetFlag(DOH *obj, const DOHString_or_char *name);
    211. 

  211. extern void *DohGetVoid(DOH *obj, const DOHString_or_char *name);
    212. 

  212. extern void DohSetVoid(DOH *obj, const DOHString_or_char *name, void *value);
    213. 

  213. 

  214. /* Sequence methods */
    215. 

  215. 

  216. extern DOH *DohGetitem(DOH *obj, int index);
    217. 

  217. extern int DohSetitem(DOH *obj, int index, const DOHObj_or_char * value);
    218. 

  218. extern int DohDelitem(DOH *obj, int index);
    219. 

  219. extern int DohInsertitem(DOH *obj, int index, const DOHObj_or_char * value);
    220. 

  220. extern int DohDelslice(DOH *obj, int sindex, int eindex);
    221. 

  221. 

  222. /* File methods */
    223. 

  223. 

  224. extern int DohWrite(DOHFile * obj, const void *buffer, int length);
    225. 

  225. extern int DohRead(DOHFile * obj, void *buffer, int length);
    226. 

  226. extern int DohSeek(DOHFile * obj, long offset, int whence);
    227. 

  227. extern long DohTell(DOHFile * obj);
    228. 

  228. extern int DohGetc(DOHFile * obj);
    229. 

  229. extern int DohPutc(int ch, DOHFile * obj);
    230. 

  230. extern int DohUngetc(int ch, DOHFile * obj);
    231. 

  231. 

  232. 

  233. 

  234. /* Iterators */
    235. 

  235. extern DohIterator DohFirst(DOH *obj);
    236. 

  236. extern DohIterator DohNext(DohIterator x);
    237. 

  237. 

  238. /* Positional */
    239. 

  239. 

  240. extern int DohGetline(const DOH *obj);
    241. 

  241. extern void DohSetline(DOH *obj, int line);
    242. 

  242. extern DOH *DohGetfile(const DOH *obj);
    243. 

  243. extern void DohSetfile(DOH *obj, DOH *file);
    244. 

  244. 

  245.   /* String Methods */
    246. 

  246. 

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

  248. extern void DohChop(DOHString * src);
    249. 

  249. 

  250. /* Meta-variables */
    251. 

  251. extern DOH *DohGetmeta(DOH *, const DOH *);
    252. 

  252. extern int DohSetmeta(DOH *, const DOH *, const DOH *value);
    253. 

  253. extern int DohDelmeta(DOH *, const DOH *);
    254. 

  254. 

  255.   /* Utility functions */
    256. 

  256. 

  257. extern void DohEncoding(char *name, DOH *(*fn) (DOH *s));
    258. 

  258. extern int DohPrintf(DOHFile * obj, const char *format, ...);
    259. 

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

  260. extern int DohPrintv(DOHFile * obj, ...);
    261. 

  261. extern DOH *DohReadline(DOHFile * in);
    262. 

  262. 

  263.   /* Miscellaneous */
    264. 

  264. 

  265. extern int DohIsMapping(const DOH *obj);
    266. 

  266. extern int DohIsSequence(const DOH *obj);
    267. 

  267. extern int DohIsString(const DOH *obj);
    268. 

  268. extern int DohIsFile(const DOH *obj);
    269. 

  269. 

  270. extern void DohSetMaxHashExpand(int count);
    271. 

  271. extern int DohGetMaxHashExpand(void);
    272. 

  272. extern void DohSetmark(DOH *obj, int x);
    273. 

  273. extern int DohGetmark(DOH *obj);
    274. 

  274. 

  275. /* -----------------------------------------------------------------------------
    276. 

  276.  * Strings.
    277. 

  277.  * ----------------------------------------------------------------------------- */
    278. 

  278. 

  279. extern DOHString *DohNewStringEmpty(void);
    280. 

  280. extern DOHString *DohNewString(const DOH *c);
    281. 

  281. extern DOHString *DohNewStringWithSize(const DOH *c, int len);
    282. 

  282. extern DOHString *DohNewStringf(const DOH *fmt, ...);
    283. 

  283. 

  284. extern int DohStrcmp(const DOHString_or_char *s1, const DOHString_or_char *s2);
    285. 

  285. extern int DohStrncmp(const DOHString_or_char *s1, const DOHString_or_char *s2, int n);
    286. 

  286. extern char *DohStrstr(const DOHString_or_char *s1, const DOHString_or_char *s2);
    287. 

  287. extern char *DohStrchr(const DOHString_or_char *s1, int ch);
    288. 

  288. 

  289. /* String replacement flags */
    290. 

  290. 

  291. #define   DOH_REPLACE_ANY         0x01
    292. 

  292. #define   DOH_REPLACE_NOQUOTE     0x02
    293. 

  293. #define   DOH_REPLACE_ID          0x04
    294. 

  294. #define   DOH_REPLACE_FIRST       0x08
    295. 

  295. #define   DOH_REPLACE_ID_BEGIN    0x10
    296. 

  296. #define   DOH_REPLACE_ID_END      0x20
    297. 

  297. 

  298. #define Replaceall(s,t,r)  DohReplace(s,t,r,DOH_REPLACE_ANY)
    299. 

  299. #define Replaceid(s,t,r)   DohReplace(s,t,r,DOH_REPLACE_ID)
    300. 

  300. 

  301. /* -----------------------------------------------------------------------------
    302. 

  302.  * Files
    303. 

  303.  * ----------------------------------------------------------------------------- */
    304. 

  304. 

  305. extern DOHFile *DohNewFile(DOH *filename, const char *mode, DOHList *outfiles);
    306. 

  306. extern DOHFile *DohNewFileFromFile(FILE *f);
    307. 

  307. extern DOHFile *DohNewFileFromFd(int fd);
    308. 

  308. extern void DohFileErrorDisplay(DOHString * filename);
    309. 

  309. extern int DohClose(DOH *file);
    310. 

  310. extern int DohCopyto(DOHFile * input, DOHFile * output);
    311. 

  311. 

  312. 

  313. /* -----------------------------------------------------------------------------
    314. 

  314.  * List
    315. 

  315.  * ----------------------------------------------------------------------------- */
    316. 

  316. 

  317. extern DOHList *DohNewList(void);
    318. 

  318. extern void DohSortList(DOH *lo, int (*cmp) (const DOH *, const DOH *));
    319. 

  319. 

  320. /* -----------------------------------------------------------------------------
    321. 

  321.  * Hash
    322. 

  322.  * ----------------------------------------------------------------------------- */
    323. 

  323. 

  324. extern DOHHash *DohNewHash(void);
    325. 

  325. 

  326. /* -----------------------------------------------------------------------------
    327. 

  327.  * Void
    328. 

  328.  * ----------------------------------------------------------------------------- */
    329. 

  329. 

  330. extern DOHVoid *DohNewVoid(void *ptr, void (*del) (void *));
    331. 

  331. extern DOHList *DohSplit(DOHFile * input, char ch, int nsplits);
    332. 

  332. extern DOHList *DohSplitLines(DOHFile * input);
    333. 

  333. extern DOH *DohNone;
    334. 

  334. 

  335. extern void DohMemoryDebug(void);
    336. 

  336. 

  337. #ifndef DOH_LONG_NAMES
    338. 

  338. /* Macros to invoke the above functions.  Includes the location of
    339. 

  339.    the caller to simplify debugging if something goes wrong */
    340. 

  340. 

  341. #define Delete             DohDelete
    342. 

  342. #define Copy               DohCopy
    343. 

  343. #define Clear              DohClear
    344. 

  344. #define Str                DohStr
    345. 

  345. #define Dump               DohDump
    346. 

  346. #define Getattr            DohGetattr
    347. 

  347. #define Setattr            DohSetattr
    348. 

  348. #define Delattr            DohDelattr
    349. 

  349. #define Checkattr          DohCheckattr
    350. 

  350. #define Hashval            DohHashval
    351. 

  351. #define Getitem            DohGetitem
    352. 

  352. #define Setitem            DohSetitem
    353. 

  353. #define Delitem            DohDelitem
    354. 

  354. #define Insert             DohInsertitem
    355. 

  355. #define Delslice           DohDelslice
    356. 

  356. #define Append(s,x)        DohInsertitem(s,DOH_END,x)
    357. 

  357. #define Push(s,x)          DohInsertitem(s,DOH_BEGIN,x)
    358. 

  358. #define Len                DohLen
    359. 

  359. #define Data               DohData
    360. 

  360. #define Char               (char *) Data
    361. 

  361. #define Cmp                DohCmp
    362. 

  362. #define Equal              DohEqual
    363. 

  363. #define Setline            DohSetline
    364. 

  364. #define Getline            DohGetline
    365. 

  365. #define Setfile            DohSetfile
    366. 

  366. #define Getfile            DohGetfile
    367. 

  367. #define Write              DohWrite
    368. 

  368. #define Read               DohRead
    369. 

  369. #define Seek               DohSeek
    370. 

  370. #define Tell               DohTell
    371. 

  371. #define Printf             DohPrintf
    372. 

  372. #define Printv             DohPrintv
    373. 

  373. #define Getc               DohGetc
    374. 

  374. #define Putc               DohPutc
    375. 

  375. #define Ungetc             DohUngetc
    376. 

  376. 

  377. /* #define StringPutc         DohStringPutc */
    378. 

  378. /* #define StringGetc         DohStringGetc */
    379. 

  379. /* #define StringUngetc       DohStringUngetc */
    380. 

  380. /* #define StringAppend       Append */
    381. 

  381. /* #define StringLen          DohStringLen */
    382. 

  382. /* #define StringChar         DohStringChar */
    383. 

  383. /* #define StringEqual        DohStringEqual */
    384. 

  384. 

  385. #define Close              DohClose
    386. 

  386. #define vPrintf            DohvPrintf
    387. 

  387. #define GetInt             DohGetInt
    388. 

  388. #define GetDouble          DohGetDouble
    389. 

  389. #define GetChar            DohGetChar
    390. 

  390. #define GetVoid            DohGetVoid
    391. 

  391. #define GetFlagAttr        DohGetFlagAttr
    392. 

  392. #define GetFlag            DohGetFlag
    393. 

  393. #define SetInt             DohSetInt
    394. 

  394. #define SetDouble          DohSetDouble
    395. 

  395. #define SetChar            DohSetattr
    396. 

  396. #define SetVoid            DohSetVoid
    397. 

  397. #define SetFlagAttr        DohSetFlagAttr
    398. 

  398. #define SetFlag            DohSetFlag
    399. 

  399. #define UnsetFlag(o,n)     DohSetFlagAttr(o,n,NULL)
    400. 

  400. #define ClearFlag(o,n)     DohSetFlagAttr(o,n,"")
    401. 

  401. #define Readline           DohReadline
    402. 

  402. #define Replace            DohReplace
    403. 

  403. #define Chop               DohChop
    404. 

  404. #define Getmeta            DohGetmeta
    405. 

  405. #define Setmeta            DohSetmeta
    406. 

  406. #define Delmeta            DohDelmeta
    407. 

  407. #define NewString          DohNewString
    408. 

  408. #define NewStringEmpty     DohNewStringEmpty
    409. 

  409. #define NewStringWithSize  DohNewStringWithSize
    410. 

  410. #define NewStringf         DohNewStringf
    411. 

  411. #define NewHash            DohNewHash
    412. 

  412. #define NewList            DohNewList
    413. 

  413. #define NewFile            DohNewFile
    414. 

  414. #define NewFileFromFile    DohNewFileFromFile
    415. 

  415. #define NewFileFromFd      DohNewFileFromFd
    416. 

  416. #define FileErrorDisplay   DohFileErrorDisplay
    417. 

  417. #define Close              DohClose
    418. 

  418. #define NewVoid            DohNewVoid
    419. 

  419. #define Keys               DohKeys
    420. 

  420. #define Strcmp             DohStrcmp
    421. 

  421. #define Strncmp            DohStrncmp
    422. 

  422. #define Strstr             DohStrstr
    423. 

  423. #define Strchr             DohStrchr
    424. 

  424. #define Copyto             DohCopyto
    425. 

  425. #define Split              DohSplit
    426. 

  426. #define SplitLines         DohSplitLines
    427. 

  427. #define Setmark            DohSetmark
    428. 

  428. #define Getmark            DohGetmark
    429. 

  429. #define SetMaxHashExpand   DohSetMaxHashExpand
    430. 

  430. #define GetMaxHashExpand   DohGetMaxHashExpand
    431. 

  431. #define None               DohNone
    432. 

  432. #define Call               DohCall
    433. 

  433. #define First              DohFirst
    434. 

  434. #define Next               DohNext
    435. 

  435. #define Iterator           DohIterator
    436. 

  436. #define SortList           DohSortList
    437. 

  437. #endif
    438. 

  438. 

  439. #ifdef NIL
    440. 

  440. #undef NIL
    441. 

  441. #endif
    442. 

  442. 

  443. #define NIL  (char *) NULL
    444. 

  444. 

  445. 

  446. #endif				/* DOH_H */
    447.