gwenhywfar  5.10.1
phc.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Mon Mar 01 2004
3  copyright : (C) 2004-2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * Please see toplevel file COPYING for license details *
8  ***************************************************************************/
9 
10 #ifdef HAVE_CONFIG_H
11 # include <config.h>
12 #endif
13 
14 
15 
16 #include "args.h"
17 #include "typemaker_p.h"
18 #include <gwenhywfar/debug.h>
19 #include <gwenhywfar/logger.h>
20 #include <gwenhywfar/xml.h>
21 
22 #include <gwenhywfar/syncio_file.h>
23 #include <gwenhywfar/syncio_buffered.h>
24 
25 #include <stdlib.h>
26 #include <assert.h>
27 
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31 #include <errno.h>
32 #include <string.h>
33 #include <ctype.h>
34 
35 
36 
37 int write_h_elem_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node,
38  GWEN_SYNCIO *sio)
39 {
40  const char *name;
41  const char *typ;
42  const char *mode;
43  GWEN_XMLNODE *tnode;
44  const char *tmode;
45  int err;
46  int isPtr;
47 
48  name=GWEN_XMLNode_GetProperty(node, "name", 0);
49  if (!name) {
50  DBG_ERROR(0, "No name for element");
51  return -1;
52  }
53 
54  typ=GWEN_XMLNode_GetProperty(node, "type", 0);
55  if (!typ) {
56  DBG_ERROR(0, "No type for element");
57  return -1;
58  }
59 
60  mode=GWEN_XMLNode_GetProperty(node, "mode", "single");
61 
62  tnode=get_typedef(node, typ);
63  if (tnode)
64  tmode=GWEN_XMLNode_GetProperty(tnode, "mode", "single");
65  else
66  tmode=mode;
67 
68  isPtr=atoi(get_property(node, "ptr", "0"));
69 
70  err=GWEN_SyncIo_WriteString(sio, " ");
71  if (err) {
72  DBG_ERROR_ERR(0, err);
73  return -1;
74  }
75 
76  if (strcasecmp(tmode, "enum")!=0)
77  GWEN_SyncIo_WriteString(sio, typ);
78  else {
79  GWEN_BUFFER *tid;
80  const char *s;
81 
82  tid=GWEN_Buffer_new(0, 64, 0, 1);
83  s=get_struct_property(node, "id", 0);
84  assert(s);
85  GWEN_Buffer_AppendString(tid, s);
86  GWEN_Buffer_AppendString(tid, "_");
87  GWEN_Buffer_AppendString(tid, typ);
88  GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(tid));
89  GWEN_Buffer_free(tid);
90  }
91 
92  GWEN_SyncIo_WriteString(sio, " ");
93  if (isPtr) {
94  GWEN_SyncIo_WriteString(sio, "*");
95  }
96 
97  GWEN_SyncIo_WriteChar(sio, tolower(*name));
98  GWEN_SyncIo_WriteString(sio, name+1);
99  GWEN_SyncIo_WriteLine(sio, ";");
100 
101  return 0;
102 }
103 
104 
105 
106 int write_h_func_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node,
107  GWEN_SYNCIO *sio)
108 {
109  const char *name;
110  const char *typ;
111  const char *styp;
112 
113  styp=get_struct_property(node, "id", 0);
114  if (!styp) {
115  DBG_ERROR(0, "No id in struct");
116  return -1;
117  }
118 
119  name=GWEN_XMLNode_GetProperty(node, "name", 0);
120  if (!name) {
121  DBG_ERROR(0, "No name for function");
122  return -1;
123  }
124 
125  typ=GWEN_XMLNode_GetProperty(node, "type", 0);
126  if (!typ) {
127  DBG_ERROR(0, "No type for function");
128  return -1;
129  }
130 
131  GWEN_SyncIo_WriteString(sio, " ");
132 
133  /* rettype name; */
134  GWEN_SyncIo_WriteString(sio, styp);
135  GWEN_SyncIo_WriteString(sio, "_");
136  GWEN_SyncIo_WriteString(sio, typ);
137  GWEN_SyncIo_WriteString(sio, " ");
138  GWEN_SyncIo_WriteChar(sio, tolower(*name));
139  GWEN_SyncIo_WriteString(sio, name+1);
140  GWEN_SyncIo_WriteLine(sio, ";");
141 
142  return 0;
143 }
144 
145 
146 
147 int write_h_struct_c(ARGUMENTS *args, GWEN_XMLNODE *node,
148  GWEN_SYNCIO *sio)
149 {
150  GWEN_XMLNODE *n;
151  const char *id;
152  const char *acc;
153  const char *prefix;
154 
155  id=get_struct_property(node, "id", 0);
156  if (!id) {
157  DBG_ERROR(0, "No id for struct");
158  return -1;
159  }
160 
161  prefix=get_struct_property(node, "prefix", 0);
162  if (!prefix) {
163  DBG_ERROR(0, "No prefix for struct");
164  return -1;
165  }
166 
167  if (write_h_enums(args, node, sio, "private")) {
168  DBG_ERROR(0, "Error writing enum types");
169  return -1;
170  }
171 
172  if (write_h_funcs(args, node, sio, "private")) {
173  DBG_ERROR(0, "Error writing function types");
174  return -1;
175  }
176 
177  acc=get_struct_property(node, "access", "public");
178  if (strcasecmp(acc, "private")==0) {
179  GWEN_SyncIo_WriteString(sio, "typedef struct ");
180  GWEN_SyncIo_WriteString(sio, id);
181  GWEN_SyncIo_WriteString(sio, " ");
182  GWEN_SyncIo_WriteString(sio, id);
183  GWEN_SyncIo_WriteLine(sio, ";");
184  }
185  GWEN_SyncIo_WriteString(sio, "struct ");
186  GWEN_SyncIo_WriteString(sio, id);
187  GWEN_SyncIo_WriteLine(sio, " {");
188 
189  if (get_struct_property(node, "inherit", 0)) {
190  GWEN_SyncIo_WriteString(sio, " GWEN_INHERIT_ELEMENT(");
191  GWEN_SyncIo_WriteString(sio, id);
192  GWEN_SyncIo_WriteLine(sio, ")");
193  }
194 
195  if (get_struct_property(node, "list", 0)) {
196  GWEN_SyncIo_WriteString(sio, " GWEN_LIST_ELEMENT(");
197  GWEN_SyncIo_WriteString(sio, id);
198  GWEN_SyncIo_WriteLine(sio, ")");
199  }
200 
201  GWEN_SyncIo_WriteLine(sio, " int _usage;");
202  GWEN_SyncIo_WriteLine(sio, " int _modified;");
203 
204  GWEN_SyncIo_WriteLine(sio, "");
205 
206  n=GWEN_XMLNode_GetFirstTag(node);
207  while (n) {
208  int rv;
209 
210  rv=write_hp_group_c(args, n, sio);
211  if (rv)
212  return rv;
213  n=GWEN_XMLNode_GetNextTag(n);
214  } /* while */
215 
216  GWEN_SyncIo_WriteLine(sio, "};");
217 
218  return 0;
219 }
220 
221 
222 
223 int write_hp_group_c(ARGUMENTS *args, GWEN_XMLNODE *node,
224  GWEN_SYNCIO *sio)
225 {
226  int rv;
227 
228  if (GWEN_XMLNode_GetType(node)==GWEN_XMLNodeTypeTag) {
229  if (strcasecmp(GWEN_XMLNode_GetData(node), "type")==0)
230  return write_h_struct_c(args, node, sio);
231  else if (strcasecmp(GWEN_XMLNode_GetData(node), "elem")==0) {
232  return write_h_elem_c(args, node, sio);
233  }
234  else if (strcasecmp(GWEN_XMLNode_GetData(node), "func")==0) {
235  return write_h_func_c(args, node, sio);
236  }
237  else if (strcasecmp(GWEN_XMLNode_GetData(node), "header")==0) {
238  return write_h_header(args, node, sio, "header");
239  }
240  else if (strcasecmp(GWEN_XMLNode_GetData(node), "group")==0) {
241  GWEN_XMLNODE *n;
242 
243  n=GWEN_XMLNode_GetFirstTag(node);
244  while (n) {
245  rv=write_hp_group_c(args, n, sio);
246  if (rv)
247  return rv;
248  n=GWEN_XMLNode_GetNextTag(n);
249  } /* while */
250  } /* if group */
251 
252  }
253  return 0;
254 }
255 
256 
257 
258 int write_hp_file_c(ARGUMENTS *args, GWEN_XMLNODE *node)
259 {
260  int rv;
261  const char *f;
262  GWEN_BUFFER *fname;
263  GWEN_BUFFER *hbuf;
264  const char *s;
265  GWEN_SYNCIO *sio;
266 
267  int err;
268  const char *nacc;
269  const char *constAcc;
270  const char *constName;
271  const char *fromDbAcc;
272  const char *fromDbName;
273  const char *dupAcc;
274  const char *dupName;
275  const char *id;
276  const char *prefix;
277 
278  id=get_struct_property(node, "id", 0);
279  if (!id) {
280  DBG_ERROR(0, "No id for struct");
281  return -1;
282  }
283 
284  prefix=get_struct_property(node, "prefix", 0);
285  if (!prefix) {
286  DBG_ERROR(0, "No prefix for struct");
287  return -1;
288  }
289 
290  f=get_struct_property(node, "filename", 0);
291  if (!f) {
292  DBG_ERROR(0, "No filename given");
293  return -1;
294  }
295 
296  nacc=get_struct_property(node, "access", "public");
297  constAcc=get_struct_property(node, "constructor-access", nacc);
298  constName=get_struct_property(node, "constructor-name", 0);
299  fromDbAcc=get_struct_property(node, "fromdb-access", nacc);
300  fromDbName=get_struct_property(node, "fromdb-name", 0);
301  dupAcc=get_struct_property(node, "dup-access", nacc);
302  dupName=get_struct_property(node, "fromdb-name", 0);
303 
304  fname=GWEN_Buffer_new(0, 256, 0, 1);
305  GWEN_Buffer_AppendString(fname, f);
306  GWEN_Buffer_AppendString(fname, "_p.h");
307 
308  sio=GWEN_SyncIo_File_new(GWEN_Buffer_GetStart(fname),
309  GWEN_SyncIo_File_CreationMode_CreateAlways);
310  GWEN_SyncIo_AddFlags(sio,
311  GWEN_SYNCIO_FILE_FLAGS_READ |
312  GWEN_SYNCIO_FILE_FLAGS_WRITE |
313  GWEN_SYNCIO_FILE_FLAGS_UREAD |
314  GWEN_SYNCIO_FILE_FLAGS_UWRITE |
315  GWEN_SYNCIO_FILE_FLAGS_GREAD |
316  GWEN_SYNCIO_FILE_FLAGS_GWRITE);
317  rv=GWEN_SyncIo_Connect(sio);
318  if (rv<0) {
319  DBG_ERROR(0, "open(%s): %s",
320  GWEN_Buffer_GetStart(fname),
321  strerror(errno));
322  GWEN_Buffer_free(fname);
323  GWEN_SyncIo_free(sio);
324  return -1;
325  }
326  GWEN_Buffer_free(fname);
327 
328  /* Insert the auto-generation warning */
329  GWEN_SyncIo_WriteString(sio, "/* This file is auto-generated from \"");
330  GWEN_SyncIo_WriteString(sio, f);
331  GWEN_SyncIo_WriteLine(sio, ".xml\" by the typemaker");
332  GWEN_SyncIo_WriteLine(sio, " tool of Gwenhywfar. ");
333  GWEN_SyncIo_WriteLine(sio, " Do not edit this file -- all changes will be lost! */");
334 
335  hbuf=GWEN_Buffer_new(0, 256, 0, 1);
336  s=f;
337  while (*s) {
338  GWEN_Buffer_AppendByte(hbuf, toupper(*s));
339  s++;
340  }
341  GWEN_Buffer_AppendString(hbuf, "_P_H");
342 
343  GWEN_SyncIo_WriteString(sio, "#ifndef ");
344  GWEN_SyncIo_WriteLine(sio, GWEN_Buffer_GetStart(hbuf));
345  GWEN_SyncIo_WriteString(sio, "#define ");
346  GWEN_SyncIo_WriteLine(sio, GWEN_Buffer_GetStart(hbuf));
347  GWEN_SyncIo_WriteLine(sio, "");
348 
349  if (strcasecmp(get_struct_property(node, "inherit", ""),
350  "private")==0) {
351  GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/inherit.h>");
352  }
353 
354  if (strcasecmp(get_struct_property(node, "list", ""),
355  "private")==0) {
356  GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/misc.h>");
357  }
358 
359  if (strcasecmp(get_struct_property(node, "list2", ""),
360  "private")==0) {
361  GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/list2.h>");
362  }
363 
364  fname=GWEN_Buffer_new(0, 256, 0, 1);
365  GWEN_Buffer_AppendString(fname, f);
366  GWEN_Buffer_AppendString(fname, "_l.h");
367  GWEN_SyncIo_WriteString(sio, "#include \"");
368  GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(fname));
369  GWEN_SyncIo_WriteLine(sio, "\"");
370  GWEN_Buffer_free(fname);
371 
372  GWEN_SyncIo_WriteLine(sio, "");
373 
374  rv=write_h_struct_c(args, node, sio);
375  if (rv) {
376  GWEN_Buffer_free(hbuf);
377  GWEN_SyncIo_free(sio);
378  return rv;
379  }
380 
381  GWEN_SyncIo_WriteLine(sio, "");
382 
383  /* include private functions */
384  if (strcasecmp(constAcc, "private")==0) {
385  GWEN_SyncIo_WriteString(sio, id);
386  GWEN_SyncIo_WriteString(sio, " *");
387  GWEN_SyncIo_WriteString(sio, prefix);
388  if (constName)
389  GWEN_SyncIo_WriteString(sio, constName);
390  else
391  GWEN_SyncIo_WriteString(sio, "_new");
392  GWEN_SyncIo_WriteLine(sio, "(void);");
393  }
394 
395  /* FromDb */
396  if (strcasecmp(fromDbAcc, "private")==0) {
397  GWEN_SyncIo_WriteString(sio, id);
398  GWEN_SyncIo_WriteString(sio, " *");
399  GWEN_SyncIo_WriteString(sio, prefix);
400  if (fromDbName)
401  GWEN_SyncIo_WriteString(sio, fromDbName);
402  else
403  GWEN_SyncIo_WriteString(sio, "_fromDb");
404  GWEN_SyncIo_WriteLine(sio, "(GWEN_DB_NODE *db);");
405  }
406 
407  /* dup */
408  if (strcasecmp(dupAcc, "private")==0) {
409  GWEN_SyncIo_WriteString(sio, id);
410  GWEN_SyncIo_WriteString(sio, " *");
411  GWEN_SyncIo_WriteString(sio, prefix);
412  if (dupName)
413  GWEN_SyncIo_WriteString(sio, dupName);
414  else
415  GWEN_SyncIo_WriteString(sio, "_dup");
416  GWEN_SyncIo_WriteString(sio, "(const ");
417  GWEN_SyncIo_WriteString(sio, id);
418  GWEN_SyncIo_WriteLine(sio, "*st);");
419  }
420 
421  if (strcasecmp(nacc, "private")==0) {
422  GWEN_SyncIo_WriteString(sio, "void ");
423  GWEN_SyncIo_WriteString(sio, prefix);
424  GWEN_SyncIo_WriteString(sio, "_free(");
425  GWEN_SyncIo_WriteString(sio, id);
426  GWEN_SyncIo_WriteLine(sio, " *st);");
427 
428  GWEN_SyncIo_WriteString(sio, "void ");
429  GWEN_SyncIo_WriteString(sio, prefix);
430  GWEN_SyncIo_WriteString(sio, "_Attach(");
431  GWEN_SyncIo_WriteString(sio, id);
432  GWEN_SyncIo_WriteLine(sio, " *st);");
433 
434  /* ReadDb */
435  GWEN_SyncIo_WriteString(sio, "int ");
436  GWEN_SyncIo_WriteString(sio, prefix);
437  GWEN_SyncIo_WriteString(sio, "_ReadDb(");
438  GWEN_SyncIo_WriteString(sio, id);
439  GWEN_SyncIo_WriteLine(sio, " *st, GWEN_DB_NODE *db);");
440 
441  /* ToDb */
442  GWEN_SyncIo_WriteString(sio, "int ");
443  GWEN_SyncIo_WriteString(sio, prefix);
444  GWEN_SyncIo_WriteString(sio, "_toDb(const ");
445  GWEN_SyncIo_WriteString(sio, id);
446  GWEN_SyncIo_WriteString(sio, "*st, GWEN_DB_NODE *db);");
447 
448  GWEN_SyncIo_WriteString(sio, "int ");
449  GWEN_SyncIo_WriteString(sio, prefix);
450  GWEN_SyncIo_WriteString(sio, "_IsModified(const ");
451  GWEN_SyncIo_WriteString(sio, id);
452  GWEN_SyncIo_WriteLine(sio, " *st);");
453 
454  GWEN_SyncIo_WriteString(sio, "void ");
455  GWEN_SyncIo_WriteString(sio, prefix);
456  GWEN_SyncIo_WriteString(sio, "_SetModified(");
457  GWEN_SyncIo_WriteString(sio, id);
458  GWEN_SyncIo_WriteLine(sio, " *st, int i);");
459  }
460 
461  rv=write_h_setget_c(args, node, sio, "private");
462  if (rv) {
463  GWEN_Buffer_free(hbuf);
464  GWEN_SyncIo_free(sio);
465  return rv;
466  }
467 
468  /* write trailing endif */
469  err=GWEN_SyncIo_WriteLine(sio, "");
470  if (err) {
471  DBG_ERROR_ERR(0, err);
472  GWEN_Buffer_free(hbuf);
473  return -1;
474  }
475 
476  err=GWEN_SyncIo_WriteString(sio, "#endif /* ");
477  if (err) {
478  DBG_ERROR_ERR(0, err);
479  GWEN_Buffer_free(hbuf);
480  return -1;
481  }
482  err=GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(hbuf));
483  if (err) {
484  DBG_ERROR_ERR(0, err);
485  GWEN_Buffer_free(hbuf);
486  return -1;
487  }
488  err=GWEN_SyncIo_WriteLine(sio, " */");
489  if (err) {
490  DBG_ERROR_ERR(0, err);
491  GWEN_Buffer_free(hbuf);
492  return -1;
493  }
494 
495  err=GWEN_SyncIo_Disconnect(sio);
496  if (err) {
497  DBG_ERROR_ERR(0, err);
498  GWEN_SyncIo_free(sio);
499  GWEN_Buffer_free(hbuf);
500  return -1;
501  }
502 
503  GWEN_Buffer_free(hbuf);
504  return 0;
505 }
506 
507 
508 
509 int write_hp_files_c(ARGUMENTS *args, GWEN_XMLNODE *node)
510 {
511  GWEN_XMLNODE *n;
512  int rv;
513 
514  n=GWEN_XMLNode_FindFirstTag(node, "type", 0, 0);
515  while (n) {
516  rv=write_hp_file_c(args, n);
517  if (rv)
518  return rv;
519  n=GWEN_XMLNode_FindNextTag(n, "type", 0, 0);
520  }
521  return 0;
522 }
523 
524 
525 
526 
527 
528 
529 
530 
GWEN_SyncIo_File_CreationMode_CreateAlways
Definition: syncio_file.h:40
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
write_h_struct_c
int write_h_struct_c(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:147
GWEN_SyncIo_Connect
int GWEN_SyncIo_Connect(GWEN_SYNCIO *sio)
Definition: syncio.c:97
write_h_elem_c
int write_h_elem_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:37
GWEN_SYNCIO_FILE_FLAGS_WRITE
#define GWEN_SYNCIO_FILE_FLAGS_WRITE
Definition: syncio_file.h:54
GWEN_SYNCIO_FILE_FLAGS_READ
#define GWEN_SYNCIO_FILE_FLAGS_READ
Definition: syncio_file.h:53
GWEN_XMLNode_GetProperty
const char * GWEN_XMLNode_GetProperty(const GWEN_XMLNODE *n, const char *name, const char *defaultValue)
Definition: xml.c:239
GWEN_XMLNode_FindNextTag
GWEN_XMLNODE * GWEN_XMLNode_FindNextTag(const GWEN_XMLNODE *n, const char *tname, const char *pname, const char *pvalue)
Definition: xml.c:794
GWEN_SYNCIO_FILE_FLAGS_UREAD
#define GWEN_SYNCIO_FILE_FLAGS_UREAD
Definition: syncio_file.h:58
DBG_ERROR_ERR
#define DBG_ERROR_ERR(dbg_logger, dbg_err)
Definition: debug.h:113
write_hp_files_c
int write_hp_files_c(ARGUMENTS *args, GWEN_XMLNODE *node)
Definition: phc.c:509
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:42
GWEN_SYNCIO_FILE_FLAGS_GREAD
#define GWEN_SYNCIO_FILE_FLAGS_GREAD
Definition: syncio_file.h:62
write_h_func_c
int write_h_func_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:106
_S_ARGS
Definition: tools/typemaker/args.h:44
GWEN_SyncIo_WriteLine
int GWEN_SyncIo_WriteLine(GWEN_SYNCIO *sio, const char *s)
Definition: syncio.c:407
write_h_funcs
int write_h_funcs(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio, const char *acc)
Definition: typemaker/main.c:640
GWEN_XMLNode_FindFirstTag
GWEN_XMLNODE * GWEN_XMLNode_FindFirstTag(const GWEN_XMLNODE *n, const char *tname, const char *pname, const char *pvalue)
Definition: xml.c:776
get_typedef
GWEN_XMLNODE * get_typedef(GWEN_XMLNODE *node, const char *name)
Definition: typemaker/main.c:1079
GWEN_SYNCIO
struct GWEN_SYNCIO GWEN_SYNCIO
Definition: syncio.h:40
GWEN_XMLNode_GetType
GWEN_XMLNODE_TYPE GWEN_XMLNode_GetType(const GWEN_XMLNODE *n)
Definition: xml.c:458
get_struct_property
const char * get_struct_property(GWEN_XMLNODE *node, const char *pname, const char *defval)
Definition: typemaker/main.c:1153
GWEN_XMLNode_GetNextTag
GWEN_XMLNODE * GWEN_XMLNode_GetNextTag(const GWEN_XMLNODE *n)
Definition: xml.c:712
GWEN_SYNCIO_FILE_FLAGS_GWRITE
#define GWEN_SYNCIO_FILE_FLAGS_GWRITE
Definition: syncio_file.h:63
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:394
write_hp_group_c
int write_hp_group_c(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:223
GWEN_SYNCIO_FILE_FLAGS_UWRITE
#define GWEN_SYNCIO_FILE_FLAGS_UWRITE
Definition: syncio_file.h:59
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
GWEN_SyncIo_free
void GWEN_SyncIo_free(GWEN_SYNCIO *sio)
Definition: syncio.c:78
get_property
const char * get_property(GWEN_XMLNODE *node, const char *pname, const char *defval)
Definition: typemaker/main.c:1117
GWEN_SyncIo_AddFlags
void GWEN_SyncIo_AddFlags(GWEN_SYNCIO *sio, uint32_t fl)
Definition: syncio.c:179
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
GWEN_XMLNode_GetFirstTag
GWEN_XMLNODE * GWEN_XMLNode_GetFirstTag(const GWEN_XMLNODE *n)
Definition: xml.c:705
GWEN_SyncIo_WriteString
int GWEN_SyncIo_WriteString(GWEN_SYNCIO *sio, const char *s)
Definition: syncio.c:392
GWEN_XMLNode_GetData
const char * GWEN_XMLNode_GetData(const GWEN_XMLNODE *n)
Definition: xml.c:370
GWEN_SyncIo_Disconnect
int GWEN_SyncIo_Disconnect(GWEN_SYNCIO *sio)
Definition: syncio.c:109
write_h_enums
int write_h_enums(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio, const char *acc)
Definition: typemaker/main.c:510
write_hp_file_c
int write_hp_file_c(ARGUMENTS *args, GWEN_XMLNODE *node)
Definition: phc.c:258
write_h_setget_c
int write_h_setget_c(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio, const char *acc)
Definition: typemaker/main.c:145
GWEN_XMLNodeTypeTag
Definition: xml.h:145
GWEN_SyncIo_File_new
GWENHYWFAR_API GWEN_SYNCIO * GWEN_SyncIo_File_new(const char *path, GWEN_SYNCIO_FILE_CREATIONMODE cm)
write_h_header
int write_h_header(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio, GWEN_UNUSED const char *where)
Definition: typemaker/main.c:67
GWEN_XMLNODE
struct GWEN__XMLNODE GWEN_XMLNODE
Definition: xml.h:156
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:150
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
GWEN_SyncIo_WriteChar
int GWEN_SyncIo_WriteChar(GWEN_SYNCIO *sio, char s)
Definition: syncio.c:431
Generated by   doxygen 1.8.14