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