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
37int 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
106int 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
147int 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
223int 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
258int 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
509int 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_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:42
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:394
DBG_ERROR_ERR
#define DBG_ERROR_ERR(dbg_logger, dbg_err)
Definition: debug.h:113
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:150
write_h_elem_c
int write_h_elem_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:37
write_hp_group_c
int write_hp_group_c(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:223
write_h_struct_c
int write_h_struct_c(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:147
write_h_func_c
int write_h_func_c(GWEN_UNUSED ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio)
Definition: phc.c:106
write_hp_files_c
int write_hp_files_c(ARGUMENTS *args, GWEN_XMLNODE *node)
Definition: phc.c:509
write_hp_file_c
int write_hp_file_c(ARGUMENTS *args, GWEN_XMLNODE *node)
Definition: phc.c:258
_S_ARGS
Definition: tools/typemaker/args.h:44
GWEN_SyncIo_WriteString
int GWEN_SyncIo_WriteString(GWEN_SYNCIO *sio, const char *s)
Definition: syncio.c:392
GWEN_SyncIo_Connect
int GWEN_SyncIo_Connect(GWEN_SYNCIO *sio)
Definition: syncio.c:97
GWEN_SyncIo_AddFlags
void GWEN_SyncIo_AddFlags(GWEN_SYNCIO *sio, uint32_t fl)
Definition: syncio.c:179
GWEN_SyncIo_WriteChar
int GWEN_SyncIo_WriteChar(GWEN_SYNCIO *sio, char s)
Definition: syncio.c:431
GWEN_SyncIo_WriteLine
int GWEN_SyncIo_WriteLine(GWEN_SYNCIO *sio, const char *s)
Definition: syncio.c:407
GWEN_SyncIo_free
void GWEN_SyncIo_free(GWEN_SYNCIO *sio)
Definition: syncio.c:78
GWEN_SyncIo_Disconnect
int GWEN_SyncIo_Disconnect(GWEN_SYNCIO *sio)
Definition: syncio.c:109
GWEN_SYNCIO
struct GWEN_SYNCIO GWEN_SYNCIO
Definition: syncio.h:40
GWEN_SyncIo_File_CreationMode_CreateAlways
@ GWEN_SyncIo_File_CreationMode_CreateAlways
Definition: syncio_file.h:40
GWEN_SYNCIO_FILE_FLAGS_GWRITE
#define GWEN_SYNCIO_FILE_FLAGS_GWRITE
Definition: syncio_file.h:63
GWEN_SYNCIO_FILE_FLAGS_UWRITE
#define GWEN_SYNCIO_FILE_FLAGS_UWRITE
Definition: syncio_file.h:59
GWEN_SyncIo_File_new
GWENHYWFAR_API GWEN_SYNCIO * GWEN_SyncIo_File_new(const char *path, GWEN_SYNCIO_FILE_CREATIONMODE cm)
GWEN_SYNCIO_FILE_FLAGS_READ
#define GWEN_SYNCIO_FILE_FLAGS_READ
Definition: syncio_file.h:53
GWEN_SYNCIO_FILE_FLAGS_UREAD
#define GWEN_SYNCIO_FILE_FLAGS_UREAD
Definition: syncio_file.h:58
GWEN_SYNCIO_FILE_FLAGS_GREAD
#define GWEN_SYNCIO_FILE_FLAGS_GREAD
Definition: syncio_file.h:62
GWEN_SYNCIO_FILE_FLAGS_WRITE
#define GWEN_SYNCIO_FILE_FLAGS_WRITE
Definition: syncio_file.h:54
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
get_typedef
GWEN_XMLNODE * get_typedef(GWEN_XMLNODE *node, const char *name)
Definition: typemaker/main.c:1079
get_property
const char * get_property(GWEN_XMLNODE *node, const char *pname, const char *defval)
Definition: typemaker/main.c:1117
write_h_enums
int write_h_enums(ARGUMENTS *args, GWEN_XMLNODE *node, GWEN_SYNCIO *sio, const char *acc)
Definition: typemaker/main.c:510
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
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
get_struct_property
const char * get_struct_property(GWEN_XMLNODE *node, const char *pname, const char *defval)
Definition: typemaker/main.c:1153
GWEN_XMLNode_GetProperty
const char * GWEN_XMLNode_GetProperty(const GWEN_XMLNODE *n, const char *name, const char *defaultValue)
Definition: xml.c:239
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
GWEN_XMLNode_GetFirstTag
GWEN_XMLNODE * GWEN_XMLNode_GetFirstTag(const GWEN_XMLNODE *n)
Definition: xml.c:705
GWEN_XMLNode_GetType
GWEN_XMLNODE_TYPE GWEN_XMLNode_GetType(const GWEN_XMLNODE *n)
Definition: xml.c:458
GWEN_XMLNode_GetNextTag
GWEN_XMLNODE * GWEN_XMLNode_GetNextTag(const GWEN_XMLNODE *n)
Definition: xml.c:712
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_XMLNode_GetData
const char * GWEN_XMLNode_GetData(const GWEN_XMLNODE *n)
Definition: xml.c:370
GWEN_XMLNODE
struct GWEN__XMLNODE GWEN_XMLNODE
Definition: xml.h:156
GWEN_XMLNodeTypeTag
@ GWEN_XMLNodeTypeTag
Definition: xml.h:145
Generated by doxygen 1.9.5