gwenhywfar  5.1.2
tm_builder_c.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Thu Jul 02 2009
3  copyright : (C) 2018 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * Please see toplevel file COPYING for license details *
8  ***************************************************************************/
9 
10 
11 
12 #include "tm_builder_c.h"
13 
14 #include <gwenhywfar/debug.h>
15 
16 #include <ctype.h>
17 #include <string.h>
18 
19 
20 
21 /* DEBUG */
22 /*DBG_ERROR(0, "Member %s has flags %x", Typemaker2_Member_GetName(tm), Typemaker2_Member_GetFlags(tm));*/
23 
24 
25 
26 static int _buildFieldIds(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
27 {
28  GWEN_BUFFER *tbuf;
29  const char *s;
30  TYPEMAKER2_MEMBER_LIST *tml;
31  char numbuf[16];
32 
33  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
34 
35  tml=Typemaker2_Type_GetMembers(ty);
36  if (tml) {
37  TYPEMAKER2_MEMBER *tm;
38 
39  tm=Typemaker2_Member_List_First(tml);
40  while (tm) {
41  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)) {
42  GWEN_Buffer_AppendString(tbuf, "#define ");
43  s=Typemaker2_Member_GetFieldId(tm);
44  GWEN_Buffer_AppendString(tbuf, s);
45  GWEN_Buffer_AppendString(tbuf, " ");
46 
47  snprintf(numbuf, sizeof(numbuf)-1, "%d",
48  Typemaker2_Member_GetMemberPosition(tm));
49  GWEN_Buffer_AppendString(tbuf, numbuf);
50  GWEN_Buffer_AppendString(tbuf, "\n");
51  }
52 
53  tm=Typemaker2_Member_List_Next(tm);
54  }
55  }
56 
57  GWEN_Buffer_AppendString(tbuf, "#define ");
58  s=Typemaker2_Type_GetFieldCountId(ty);
59  GWEN_Buffer_AppendString(tbuf, s);
60  GWEN_Buffer_AppendString(tbuf, " ");
61 
62  snprintf(numbuf, sizeof(numbuf)-1, "%d",
63  Typemaker2_Type_GetNonVolatileMemberCount(ty));
64  GWEN_Buffer_AppendString(tbuf, numbuf);
65  GWEN_Buffer_AppendString(tbuf, "\n");
66 
67  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
68  GWEN_Buffer_free(tbuf);
69 
70  return 0;
71 }
72 
73 
74 
76 static int _buildTypedef(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
77 {
78  GWEN_BUFFER *tbuf;
79  const char *s;
80  uint32_t flags;
81  TYPEMAKER2_TYPEMANAGER *tym;
82  TYPEMAKER2_HEADER_LIST *hl;
83 
84  tym=Typemaker2_Builder_GetTypeManager(tb);
85  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
86 
87  flags=Typemaker2_Type_GetFlags(ty);
88 
89  /* add some system headers */
90  GWEN_Buffer_AppendString(tbuf, "/* needed system headers */\n");
91  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/types.h>\n");
92  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1)
93  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/list1.h>\n");
94  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST2)
95  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/list2.h>\n");
96  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE)
97  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/tree.h>\n");
98  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2)
99  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/tree2.h>\n");
100  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT)
101  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/inherit.h>\n");
102  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_IDMAP)
103  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/idmap.h>\n");
104  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_DB)
105  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/db.h>\n");
106  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_XML)
107  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/xml.h>\n");
108  if ((flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) || (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS))
109  GWEN_Buffer_AppendString(tbuf, "#include <gwenhywfar/gwensignal.h>\n");
110  GWEN_Buffer_AppendString(tbuf, "\n");
111 
112  /* handle pre-headers */
113  hl=Typemaker2_Type_GetHeaders(ty);
114  if (hl) {
115  TYPEMAKER2_HEADER *h;
116 
117  h=Typemaker2_Header_List_First(hl);
118  if (h) {
119  GWEN_Buffer_AppendString(tbuf, "/* pre-headers */\n");
120  while (h) {
121  if (Typemaker2_Header_GetLocation(h)==Typemaker2_HeaderLocation_Pre) {
122  GWEN_Buffer_AppendString(tbuf, "#include ");
123 
124  if (Typemaker2_Header_GetType(h)==Typemaker2_HeaderType_System) {
125  GWEN_Buffer_AppendString(tbuf, "<");
126  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
127  GWEN_Buffer_AppendString(tbuf, ">");
128  }
129  else {
130  GWEN_Buffer_AppendString(tbuf, "\"");
131  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
132  GWEN_Buffer_AppendString(tbuf, "\"");
133  }
134  GWEN_Buffer_AppendString(tbuf, "\n");
135  }
136  h=Typemaker2_Header_List_Next(h);
137  }
138  GWEN_Buffer_AppendString(tbuf, "\n");
139  }
140  }
141 
142  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
143  GWEN_Buffer_AppendString(tbuf, "#include <aqdatabase/aqdb.h>\n");
144  }
145 
146  GWEN_Buffer_AppendString(tbuf, "typedef struct ");
147  s=Typemaker2_Type_GetIdentifier(ty);
148  GWEN_Buffer_AppendString(tbuf, s);
149  GWEN_Buffer_AppendString(tbuf, " ");
150  GWEN_Buffer_AppendString(tbuf, s);
151  GWEN_Buffer_AppendString(tbuf, ";\n");
152 
153  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
154  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
155  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST_FUNCTION_LIB_DEFS(");
156  s=Typemaker2_Type_GetIdentifier(ty);
157  GWEN_Buffer_AppendString(tbuf, s);
158  GWEN_Buffer_AppendString(tbuf, ", ");
159  s=Typemaker2_Type_GetPrefix(ty);
160  GWEN_Buffer_AppendString(tbuf, s);
161  GWEN_Buffer_AppendString(tbuf, ", ");
162  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
163  GWEN_Buffer_AppendString(tbuf, s);
164  GWEN_Buffer_AppendString(tbuf, ")\n");
165  }
166  else {
167  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST_FUNCTION_DEFS(");
168  s=Typemaker2_Type_GetIdentifier(ty);
169  GWEN_Buffer_AppendString(tbuf, s);
170  GWEN_Buffer_AppendString(tbuf, ", ");
171  s=Typemaker2_Type_GetPrefix(ty);
172  GWEN_Buffer_AppendString(tbuf, s);
173  GWEN_Buffer_AppendString(tbuf, ")\n");
174  }
175  }
176 
177  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST2) {
178  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
179  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST2_FUNCTION_LIB_DEFS(");
180  s=Typemaker2_Type_GetIdentifier(ty);
181  GWEN_Buffer_AppendString(tbuf, s);
182  GWEN_Buffer_AppendString(tbuf, ", ");
183  s=Typemaker2_Type_GetPrefix(ty);
184  GWEN_Buffer_AppendString(tbuf, s);
185  GWEN_Buffer_AppendString(tbuf, ", ");
186  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
187  GWEN_Buffer_AppendString(tbuf, s);
188  GWEN_Buffer_AppendString(tbuf, ")\n");
189  }
190  else {
191  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST2_FUNCTION_DEFS(");
192  s=Typemaker2_Type_GetIdentifier(ty);
193  GWEN_Buffer_AppendString(tbuf, s);
194  GWEN_Buffer_AppendString(tbuf, ", ");
195  s=Typemaker2_Type_GetPrefix(ty);
196  GWEN_Buffer_AppendString(tbuf, s);
197  GWEN_Buffer_AppendString(tbuf, ")\n");
198  }
199  }
200 
201  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2) {
202  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
203  GWEN_Buffer_AppendString(tbuf, "GWEN_CONSTLIST2_FUNCTION_LIB_DEFS(");
204  s=Typemaker2_Type_GetIdentifier(ty);
205  GWEN_Buffer_AppendString(tbuf, s);
206  GWEN_Buffer_AppendString(tbuf, ", ");
207  s=Typemaker2_Type_GetPrefix(ty);
208  GWEN_Buffer_AppendString(tbuf, s);
209  GWEN_Buffer_AppendString(tbuf, ", ");
210  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
211  GWEN_Buffer_AppendString(tbuf, s);
212  GWEN_Buffer_AppendString(tbuf, ")\n");
213  }
214  else {
215  GWEN_Buffer_AppendString(tbuf, "GWEN_CONSTLIST2_FUNCTION_DEFS(");
216  s=Typemaker2_Type_GetIdentifier(ty);
217  GWEN_Buffer_AppendString(tbuf, s);
218  GWEN_Buffer_AppendString(tbuf, ", ");
219  s=Typemaker2_Type_GetPrefix(ty);
220  GWEN_Buffer_AppendString(tbuf, s);
221  GWEN_Buffer_AppendString(tbuf, ")\n");
222  }
223  }
224 
225  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
226  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
227  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE_FUNCTION_LIB_DEFS(");
228  s=Typemaker2_Type_GetIdentifier(ty);
229  GWEN_Buffer_AppendString(tbuf, s);
230  GWEN_Buffer_AppendString(tbuf, ", ");
231  s=Typemaker2_Type_GetPrefix(ty);
232  GWEN_Buffer_AppendString(tbuf, s);
233  GWEN_Buffer_AppendString(tbuf, ", ");
234  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
235  GWEN_Buffer_AppendString(tbuf, s);
236  GWEN_Buffer_AppendString(tbuf, ")\n");
237  }
238  else {
239  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE_FUNCTION_DEFS(");
240  s=Typemaker2_Type_GetIdentifier(ty);
241  GWEN_Buffer_AppendString(tbuf, s);
242  GWEN_Buffer_AppendString(tbuf, ", ");
243  s=Typemaker2_Type_GetPrefix(ty);
244  GWEN_Buffer_AppendString(tbuf, s);
245  GWEN_Buffer_AppendString(tbuf, ")\n");
246  }
247  }
248 
249  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
250  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
251  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE2_FUNCTION_LIB_DEFS(");
252  s=Typemaker2_Type_GetIdentifier(ty);
253  GWEN_Buffer_AppendString(tbuf, s);
254  GWEN_Buffer_AppendString(tbuf, ", ");
255  s=Typemaker2_Type_GetPrefix(ty);
256  GWEN_Buffer_AppendString(tbuf, s);
257  GWEN_Buffer_AppendString(tbuf, ", ");
258  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
259  GWEN_Buffer_AppendString(tbuf, s);
260  GWEN_Buffer_AppendString(tbuf, ")\n");
261  }
262  else {
263  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE2_FUNCTION_DEFS(");
264  s=Typemaker2_Type_GetIdentifier(ty);
265  GWEN_Buffer_AppendString(tbuf, s);
266  GWEN_Buffer_AppendString(tbuf, ", ");
267  s=Typemaker2_Type_GetPrefix(ty);
268  GWEN_Buffer_AppendString(tbuf, s);
269  GWEN_Buffer_AppendString(tbuf, ")\n");
270  }
271  }
272 
273  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT) {
274  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
275  GWEN_Buffer_AppendString(tbuf, "GWEN_INHERIT_FUNCTION_LIB_DEFS(");
276  s=Typemaker2_Type_GetIdentifier(ty);
277  GWEN_Buffer_AppendString(tbuf, s);
278  GWEN_Buffer_AppendString(tbuf, ", ");
279  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
280  GWEN_Buffer_AppendString(tbuf, s);
281  GWEN_Buffer_AppendString(tbuf, ")\n");
282  }
283  else {
284  GWEN_Buffer_AppendString(tbuf, "GWEN_INHERIT_FUNCTION_DEFS(");
285  s=Typemaker2_Type_GetIdentifier(ty);
286  GWEN_Buffer_AppendString(tbuf, s);
287  GWEN_Buffer_AppendString(tbuf, ")\n");
288  }
289  }
290 
291  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_IDMAP) {
292  if (Typemaker2_TypeManager_GetApiDeclaration(tym)) {
293  GWEN_Buffer_AppendString(tbuf, "GWEN_IDMAP_FUNCTION_LIB_DEFS(");
294  s=Typemaker2_Type_GetIdentifier(ty);
295  GWEN_Buffer_AppendString(tbuf, s);
296  GWEN_Buffer_AppendString(tbuf, ", ");
297  s=Typemaker2_Type_GetPrefix(ty);
298  GWEN_Buffer_AppendString(tbuf, s);
299  GWEN_Buffer_AppendString(tbuf, ", ");
300  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
301  GWEN_Buffer_AppendString(tbuf, s);
302  GWEN_Buffer_AppendString(tbuf, ")\n");
303  }
304  else {
305  GWEN_Buffer_AppendString(tbuf, "GWEN_IDMAP_FUNCTION_DEFS(");
306  s=Typemaker2_Type_GetIdentifier(ty);
307  GWEN_Buffer_AppendString(tbuf, s);
308  GWEN_Buffer_AppendString(tbuf, ", ");
309  s=Typemaker2_Type_GetPrefix(ty);
310  GWEN_Buffer_AppendString(tbuf, s);
311  GWEN_Buffer_AppendString(tbuf, ")\n");
312  }
313  }
314  GWEN_Buffer_AppendString(tbuf, "\n");
315 
316 
317  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
318  GWEN_Buffer_AppendString(tbuf, "#include <aqdatabase/aqdb_db.h>\n");
319  }
320  GWEN_Buffer_AppendString(tbuf, "\n");
321 
322  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
323  GWEN_Buffer_free(tbuf);
324 
325  return 0;
326 }
327 
328 
329 
330 static int _buildPostHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
331 {
332  GWEN_BUFFER *tbuf;
333  TYPEMAKER2_TYPEMANAGER *tym GWEN_UNUSED;
334  TYPEMAKER2_HEADER_LIST *hl;
335 
336  tym=Typemaker2_Builder_GetTypeManager(tb);
337  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
338 
339  /* handle post-headers */
340  hl=Typemaker2_Type_GetHeaders(ty);
341  if (hl) {
342  TYPEMAKER2_HEADER *h;
343 
344  h=Typemaker2_Header_List_First(hl);
345  if (h) {
346  GWEN_Buffer_AppendString(tbuf, "/* post-headers */\n");
347  while (h) {
348  if (Typemaker2_Header_GetLocation(h)==Typemaker2_HeaderLocation_Post) {
349  GWEN_Buffer_AppendString(tbuf, "#include ");
350 
351  if (Typemaker2_Header_GetType(h)==Typemaker2_HeaderType_System) {
352  GWEN_Buffer_AppendString(tbuf, "<");
353  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
354  GWEN_Buffer_AppendString(tbuf, ">");
355  }
356  else {
357  GWEN_Buffer_AppendString(tbuf, "\"");
358  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
359  GWEN_Buffer_AppendString(tbuf, "\"");
360  }
361  GWEN_Buffer_AppendString(tbuf, "\n");
362  }
363  h=Typemaker2_Header_List_Next(h);
364  }
365  }
366  GWEN_Buffer_AppendString(tbuf, "\n");
367  }
368 
369  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
370  GWEN_Buffer_free(tbuf);
371 
372  return 0;
373 }
374 
375 
376 
377 static int _buildEndHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
378 {
379  GWEN_BUFFER *tbuf;
380  TYPEMAKER2_TYPEMANAGER *tym GWEN_UNUSED;
381  TYPEMAKER2_HEADER_LIST *hl;
382 
383  tym=Typemaker2_Builder_GetTypeManager(tb);
384  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
385 
386  /* handle post-headers */
387  hl=Typemaker2_Type_GetHeaders(ty);
388  if (hl) {
389  TYPEMAKER2_HEADER *h;
390 
391  h=Typemaker2_Header_List_First(hl);
392  if (h) {
393  GWEN_Buffer_AppendString(tbuf, "/* end-headers */\n");
394  while (h) {
395  if (Typemaker2_Header_GetLocation(h)==Typemaker2_HeaderLocation_HeaderEnd) {
396  GWEN_Buffer_AppendString(tbuf, "#include ");
397 
398  if (Typemaker2_Header_GetType(h)==Typemaker2_HeaderType_System) {
399  GWEN_Buffer_AppendString(tbuf, "<");
400  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
401  GWEN_Buffer_AppendString(tbuf, ">");
402  }
403  else {
404  GWEN_Buffer_AppendString(tbuf, "\"");
405  GWEN_Buffer_AppendString(tbuf, Typemaker2_Header_GetFileName(h));
406  GWEN_Buffer_AppendString(tbuf, "\"");
407  }
408  GWEN_Buffer_AppendString(tbuf, "\n");
409  }
410  h=Typemaker2_Header_List_Next(h);
411  }
412  }
413  GWEN_Buffer_AppendString(tbuf, "\n");
414  }
415 
416  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
417  GWEN_Buffer_free(tbuf);
418 
419  return 0;
420 }
421 
422 
423 
424 static int _buildStruct(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
425 {
426  GWEN_BUFFER *tbuf;
427  const char *s;
428  TYPEMAKER2_MEMBER_LIST *tml;
429  uint32_t flags;
430  TYPEMAKER2_VIRTUALFN_LIST *fns;
431 
432  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
433 
434  flags=Typemaker2_Type_GetFlags(ty);
435 
436  GWEN_Buffer_AppendString(tbuf, "struct ");
437  s=Typemaker2_Type_GetIdentifier(ty);
438  GWEN_Buffer_AppendString(tbuf, s);
439  GWEN_Buffer_AppendString(tbuf, " {\n");
440 
441  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT) {
442  GWEN_Buffer_AppendString(tbuf, " GWEN_INHERIT_ELEMENT(");
443  s=Typemaker2_Type_GetIdentifier(ty);
444  GWEN_Buffer_AppendString(tbuf, s);
445  GWEN_Buffer_AppendString(tbuf, ")\n");
446  }
447 
448  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
449  GWEN_Buffer_AppendString(tbuf, " GWEN_LIST_ELEMENT(");
450  s=Typemaker2_Type_GetIdentifier(ty);
451  GWEN_Buffer_AppendString(tbuf, s);
452  GWEN_Buffer_AppendString(tbuf, ")\n");
453  }
454 
455  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
456  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE_ELEMENT(");
457  s=Typemaker2_Type_GetIdentifier(ty);
458  GWEN_Buffer_AppendString(tbuf, s);
459  GWEN_Buffer_AppendString(tbuf, ")\n");
460  }
461 
462  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
463  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE2_ELEMENT(");
464  s=Typemaker2_Type_GetIdentifier(ty);
465  GWEN_Buffer_AppendString(tbuf, s);
466  GWEN_Buffer_AppendString(tbuf, ")\n");
467  }
468 
469  if ((flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) || (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS)) {
470  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNALOBJECT *_signalObject;");
471  GWEN_Buffer_AppendString(tbuf, "\n");
472  }
473 
474  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT)
475  GWEN_Buffer_AppendString(tbuf, " int _refCount;\n");
476 
477 
478  tml=Typemaker2_Type_GetMembers(ty);
479  if (tml) {
480  TYPEMAKER2_MEMBER *tm;
481 
482  tm=Typemaker2_Member_List_First(tml);
483  while (tm) {
484  TYPEMAKER2_TYPE *mty;
485  int typeIsWritten=0;
486 
487  mty=Typemaker2_Member_GetTypePtr(tm);
488  assert(mty);
489 
490  GWEN_Buffer_AppendString(tbuf, " ");
491 
492  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
493  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
494  const char *s;
495 
496  assert(te);
497  s=Typemaker2_Enum_GetType(te);
498  if (s && *s) {
499  GWEN_Buffer_AppendString(tbuf, s);
500  GWEN_Buffer_AppendString(tbuf, " ");
501  typeIsWritten=1;
502  }
503  }
504 
505  if (!typeIsWritten) {
506  if ((Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) &&
507  (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_CONST))
508  GWEN_Buffer_AppendString(tbuf, "const ");
509 
510  s=Typemaker2_Type_GetIdentifier(mty);
511  if (!(s && *s)) {
512  const char *xx;
513 
514  xx=Typemaker2_Member_GetName(tm);
515  DBG_ERROR(0, "Member [%s] has no identifier", xx?xx:"(unnamed)");
516  GWEN_Buffer_free(tbuf);
517  return GWEN_ERROR_BAD_DATA;
518  }
519  GWEN_Buffer_AppendString(tbuf, s);
520  GWEN_Buffer_AppendString(tbuf, " ");
521 
522  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer)
523  GWEN_Buffer_AppendString(tbuf, "*");
524  }
525 
526  s=Typemaker2_Member_GetName(tm);
527  GWEN_Buffer_AppendString(tbuf, s);
528  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
529  char numbuf[32];
530 
531  snprintf(numbuf, sizeof(numbuf)-1, "[%d]",
532  Typemaker2_Member_GetMaxLen(tm));
533  GWEN_Buffer_AppendString(tbuf, numbuf);
534  }
535 
536  GWEN_Buffer_AppendString(tbuf, ";");
537  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)
538  GWEN_Buffer_AppendString(tbuf, " /* volatile */");
539  GWEN_Buffer_AppendString(tbuf, "\n");
540 
541  tm=Typemaker2_Member_List_Next(tm);
542  }
543  }
544 
545  /* add virtual functions */
546  fns=Typemaker2_Type_GetVirtualFns(ty);
547  assert(fns);
548  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
549  const char *s;
550  TYPEMAKER2_VIRTUALFN *vf;
551 
552  vf=Typemaker2_VirtualFn_List_First(fns);
553  while (vf) {
554  GWEN_Buffer_AppendString(tbuf, " ");
555  s=Typemaker2_Type_GetIdentifier(ty);
556  GWEN_Buffer_AppendString(tbuf, s);
557  GWEN_Buffer_AppendString(tbuf, "_");
558  s=Typemaker2_VirtualFn_GetName(vf);
559  if (!(s && *s)) {
560  DBG_ERROR(0, "Virtual function has no name");
561  GWEN_Buffer_free(tbuf);
562  return GWEN_ERROR_BAD_DATA;
563  }
564  while (*s)
565  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
566  GWEN_Buffer_AppendString(tbuf, "_FN ");
567 
568  s=Typemaker2_VirtualFn_GetName(vf);
569  if (!(s && *s)) {
570  DBG_ERROR(0, "Virtual function has no name");
571  GWEN_Buffer_free(tbuf);
572  return GWEN_ERROR_BAD_DATA;
573  }
574  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
575  GWEN_Buffer_AppendString(tbuf, s+1);
576  GWEN_Buffer_AppendString(tbuf, "Fn;\n");
577 
578  vf=Typemaker2_VirtualFn_List_Next(vf);
579  }
580  }
581 
582  GWEN_Buffer_AppendString(tbuf, "};\n");
583 
584  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
585  GWEN_Buffer_free(tbuf);
586 
587  return 0;
588 }
589 
590 
591 
592 static int _buildMacroFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
593 {
594  GWEN_BUFFER *tbuf;
595  const char *s;
596  uint32_t flags;
597  /* TYPEMAKER2_TYPEMANAGER *tym; */
598 
599  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
600  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
601 
602  GWEN_Buffer_AppendString(tbuf, "/* macro functions */\n");
603 
604  flags=Typemaker2_Type_GetFlags(ty);
605  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
606  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST_FUNCTIONS(");
607  s=Typemaker2_Type_GetIdentifier(ty);
608  GWEN_Buffer_AppendString(tbuf, s);
609  GWEN_Buffer_AppendString(tbuf, ", ");
610  s=Typemaker2_Type_GetPrefix(ty);
611  GWEN_Buffer_AppendString(tbuf, s);
612  GWEN_Buffer_AppendString(tbuf, ")\n");
613  }
614 
615  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST2) {
616  GWEN_Buffer_AppendString(tbuf, "GWEN_LIST2_FUNCTIONS(");
617  s=Typemaker2_Type_GetIdentifier(ty);
618  GWEN_Buffer_AppendString(tbuf, s);
619  GWEN_Buffer_AppendString(tbuf, ", ");
620  s=Typemaker2_Type_GetPrefix(ty);
621  GWEN_Buffer_AppendString(tbuf, s);
622  GWEN_Buffer_AppendString(tbuf, ")\n");
623  }
624 
625  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2) {
626  GWEN_Buffer_AppendString(tbuf, "GWEN_CONSTLIST2_FUNCTIONS(");
627  s=Typemaker2_Type_GetIdentifier(ty);
628  GWEN_Buffer_AppendString(tbuf, s);
629  GWEN_Buffer_AppendString(tbuf, ", ");
630  s=Typemaker2_Type_GetPrefix(ty);
631  GWEN_Buffer_AppendString(tbuf, s);
632  GWEN_Buffer_AppendString(tbuf, ")\n");
633  }
634 
635  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
636  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE_FUNCTIONS(");
637  s=Typemaker2_Type_GetIdentifier(ty);
638  GWEN_Buffer_AppendString(tbuf, s);
639  GWEN_Buffer_AppendString(tbuf, ", ");
640  s=Typemaker2_Type_GetPrefix(ty);
641  GWEN_Buffer_AppendString(tbuf, s);
642  GWEN_Buffer_AppendString(tbuf, ")\n");
643  }
644 
645  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
646  GWEN_Buffer_AppendString(tbuf, "GWEN_TREE2_FUNCTIONS(");
647  s=Typemaker2_Type_GetIdentifier(ty);
648  GWEN_Buffer_AppendString(tbuf, s);
649  GWEN_Buffer_AppendString(tbuf, ", ");
650  s=Typemaker2_Type_GetPrefix(ty);
651  GWEN_Buffer_AppendString(tbuf, s);
652  GWEN_Buffer_AppendString(tbuf, ")\n");
653  }
654 
655  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT) {
656  GWEN_Buffer_AppendString(tbuf, "GWEN_INHERIT_FUNCTIONS(");
657  s=Typemaker2_Type_GetIdentifier(ty);
658  GWEN_Buffer_AppendString(tbuf, s);
659  GWEN_Buffer_AppendString(tbuf, ")\n");
660  }
661 
662  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_IDMAP) {
663  GWEN_Buffer_AppendString(tbuf, "GWEN_IDMAP_FUNCTIONS(");
664  s=Typemaker2_Type_GetIdentifier(ty);
665  GWEN_Buffer_AppendString(tbuf, s);
666  GWEN_Buffer_AppendString(tbuf, ", ");
667  s=Typemaker2_Type_GetPrefix(ty);
668  GWEN_Buffer_AppendString(tbuf, s);
669  GWEN_Buffer_AppendString(tbuf, ")\n");
670  }
671  GWEN_Buffer_AppendString(tbuf, "\n");
672 
673  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
674  GWEN_Buffer_free(tbuf);
675 
676  return 0;
677 }
678 
679 
680 
681 static int _buildConstructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
682 {
683  GWEN_BUFFER *tbuf;
684  const char *s;
685  TYPEMAKER2_MEMBER_LIST *tml;
686  uint32_t flags;
687  TYPEMAKER2_TYPEMANAGER *tym;
688  TYPEMAKER2_VIRTUALFN_LIST *tvfl;
689 
690  tym=Typemaker2_Builder_GetTypeManager(tb);
691  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
692 
693  flags=Typemaker2_Type_GetFlags(ty);
694 
695  /* prototype */
696  if (Typemaker2_Type_GetUsePrivateConstructor(ty)) {
697  GWEN_Buffer_AppendString(tbuf, "/** Private constructor. */\n");
698  }
699  else {
700  GWEN_Buffer_AppendString(tbuf, "/** Constructor. */\n");
701  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
702  if (s) {
703  GWEN_Buffer_AppendString(tbuf, s);
704  GWEN_Buffer_AppendString(tbuf, " ");
705  }
706  }
707 
708  s=Typemaker2_Type_GetIdentifier(ty);
709  GWEN_Buffer_AppendString(tbuf, s);
710  /* created structs are always pointers */
711  GWEN_Buffer_AppendString(tbuf, " *");
712  s=Typemaker2_Type_GetPrefix(ty);
713  GWEN_Buffer_AppendString(tbuf, s);
714  if (Typemaker2_Type_GetUsePrivateConstructor(ty))
715  GWEN_Buffer_AppendString(tbuf, "_");
716  GWEN_Buffer_AppendString(tbuf, "_new(void)");
717  GWEN_Buffer_AppendString(tbuf, ";\n");
718  if (Typemaker2_Type_GetUsePrivateConstructor(ty))
719  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
720  else
721  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
722  GWEN_Buffer_Reset(tbuf);
723 
724  /* implementation */
725  s=Typemaker2_Type_GetIdentifier(ty);
726  GWEN_Buffer_AppendString(tbuf, s);
727  GWEN_Buffer_AppendString(tbuf, " *");
728  s=Typemaker2_Type_GetPrefix(ty);
729  GWEN_Buffer_AppendString(tbuf, s);
730  if (Typemaker2_Type_GetUsePrivateConstructor(ty))
731  GWEN_Buffer_AppendString(tbuf, "_");
732  GWEN_Buffer_AppendString(tbuf, "_new(void)");
733  GWEN_Buffer_AppendString(tbuf, " {\n");
734 
735  GWEN_Buffer_AppendString(tbuf, " ");
736  s=Typemaker2_Type_GetIdentifier(ty);
737  GWEN_Buffer_AppendString(tbuf, s);
738  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
739  GWEN_Buffer_AppendString(tbuf, "\n");
740 
741  GWEN_Buffer_AppendString(tbuf, " GWEN_NEW_OBJECT(");
742  s=Typemaker2_Type_GetIdentifier(ty);
743  GWEN_Buffer_AppendString(tbuf, s);
744  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
745 
746  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT)
747  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount=1;\n");
748 
749  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT) {
750  GWEN_Buffer_AppendString(tbuf, " GWEN_INHERIT_INIT(");
751  s=Typemaker2_Type_GetIdentifier(ty);
752  GWEN_Buffer_AppendString(tbuf, s);
753  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
754  }
755 
756  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
757  GWEN_Buffer_AppendString(tbuf, " GWEN_LIST_INIT(");
758  s=Typemaker2_Type_GetIdentifier(ty);
759  GWEN_Buffer_AppendString(tbuf, s);
760  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
761  }
762 
763  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
764  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE_INIT(");
765  s=Typemaker2_Type_GetIdentifier(ty);
766  GWEN_Buffer_AppendString(tbuf, s);
767  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
768  }
769 
770  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
771  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE2_INIT(");
772  s=Typemaker2_Type_GetIdentifier(ty);
773  GWEN_Buffer_AppendString(tbuf, s);
774  GWEN_Buffer_AppendString(tbuf, ", p_struct,");
775  s=Typemaker2_Type_GetPrefix(ty);
776  GWEN_Buffer_AppendString(tbuf, s);
777  GWEN_Buffer_AppendString(tbuf, ")\n");
778  }
779 
780  if ((flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) || (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS)) {
781  GWEN_Buffer_AppendString(tbuf, " p_struct->_signalObject=GWEN_SignalObject_new();\n");
782  }
783 
784  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) {
785  TYPEMAKER2_SIGNAL_LIST *slist;
786 
787  GWEN_Buffer_AppendString(tbuf, " /* generate pre-defined signals */\n");
788  slist=Typemaker2_Type_GetSignals(ty);
789  if (slist) {
790  TYPEMAKER2_SIGNAL *sig;
791 
792  sig=Typemaker2_Signal_List_First(slist);
793  while (sig) {
794  s=Typemaker2_Signal_GetName(sig);
795  GWEN_Buffer_AppendString(tbuf, " /* signal \"");
796  GWEN_Buffer_AppendString(tbuf, s);
797  GWEN_Buffer_AppendString(tbuf, "\" */\n");
798 
799  GWEN_Buffer_AppendString(tbuf, " GWEN_Signal_new(p_struct->_signalObject, NULL, ");
800  /* name */
801  GWEN_Buffer_AppendString(tbuf, "\"");
802  GWEN_Buffer_AppendString(tbuf, s);
803  GWEN_Buffer_AppendString(tbuf, "\", ");
804 
805  /* param type 1 */
806  s=Typemaker2_Signal_GetParamType1(sig);
807  GWEN_Buffer_AppendString(tbuf, "\"");
808  GWEN_Buffer_AppendString(tbuf, s?s:"none");
809  GWEN_Buffer_AppendString(tbuf, "\", ");
810 
811  /* param type 2 */
812  s=Typemaker2_Signal_GetParamType2(sig);
813  GWEN_Buffer_AppendString(tbuf, "\"");
814  GWEN_Buffer_AppendString(tbuf, s?s:"none");
815  GWEN_Buffer_AppendString(tbuf, "\");\n");
816 
817  sig=Typemaker2_Signal_List_Next(sig);
818  }
819  }
820  }
821 
822 
823  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
824  TYPEMAKER2_SLOT_LIST *slist;
825 
826  GWEN_Buffer_AppendString(tbuf, " /* generate pre-defined slots */\n");
827  slist=Typemaker2_Type_GetSlots(ty);
828  if (slist) {
829  TYPEMAKER2_SLOT *slot;
830 
831  slot=Typemaker2_Slot_List_First(slist);
832  while (slot) {
833  s=Typemaker2_Slot_GetName(slot);
834  GWEN_Buffer_AppendString(tbuf, " /* slot \"");
835  GWEN_Buffer_AppendString(tbuf, s);
836  GWEN_Buffer_AppendString(tbuf, "\" */\n");
837 
838  GWEN_Buffer_AppendString(tbuf, " GWEN_Slot_new(p_struct->_signalObject, NULL, ");
839  /* name */
840  GWEN_Buffer_AppendString(tbuf, "\"");
841  GWEN_Buffer_AppendString(tbuf, s);
842  GWEN_Buffer_AppendString(tbuf, "\", ");
843 
844  /* param type 1 */
845  s=Typemaker2_Slot_GetParamType1(slot);
846  GWEN_Buffer_AppendString(tbuf, "\"");
847  GWEN_Buffer_AppendString(tbuf, s?s:"none");
848  GWEN_Buffer_AppendString(tbuf, "\", ");
849 
850  /* param type 2 */
851  s=Typemaker2_Slot_GetParamType2(slot);
852  GWEN_Buffer_AppendString(tbuf, "\"");
853  GWEN_Buffer_AppendString(tbuf, s?s:"none");
854  GWEN_Buffer_AppendString(tbuf, "\", ");
855 
856  /* callback function */
857  s=Typemaker2_Type_GetPrefix(ty);
858  GWEN_Buffer_AppendString(tbuf, s);
859  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
860  s=Typemaker2_Slot_GetName(slot);
861  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
862  GWEN_Buffer_AppendString(tbuf, s+1);
863  GWEN_Buffer_AppendString(tbuf, ", (void*) p_struct");
864  GWEN_Buffer_AppendString(tbuf, ");\n");
865 
866 
867 
868  slot=Typemaker2_Slot_List_Next(slot);
869  }
870  }
871  }
872 
873 
874  GWEN_Buffer_AppendString(tbuf, " /* members */\n");
875 
876  tml=Typemaker2_Type_GetMembers(ty);
877  if (tml) {
878  TYPEMAKER2_MEMBER *tm;
879  int rv;
880 
881  tm=Typemaker2_Member_List_First(tml);
882  while (tm) {
883  TYPEMAKER2_TYPE *mty;
884  GWEN_BUFFER *dstbuf;
885 
886  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
887  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
888  s=Typemaker2_Member_GetName(tm);
889  GWEN_Buffer_AppendString(dstbuf, s);
890 
891  mty=Typemaker2_Member_GetTypePtr(tm);
892  assert(mty);
893 
894  GWEN_Buffer_AppendString(tbuf, " ");
895 
896  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
897  NULL, /* no source */
898  GWEN_Buffer_GetStart(dstbuf),
899  tbuf);
900  if (rv<0) {
901  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
902  GWEN_Buffer_free(dstbuf);
903  GWEN_Buffer_free(tbuf);
904  return rv;
905  }
906  GWEN_Buffer_free(dstbuf);
907 
908  GWEN_Buffer_AppendString(tbuf, "\n");
909 
910  tm=Typemaker2_Member_List_Next(tm);
911  }
912  }
913 
914  tvfl=Typemaker2_Type_GetVirtualFns(ty);
915  if (tvfl) {
916  TYPEMAKER2_VIRTUALFN *tvf;
917 
918  GWEN_Buffer_AppendString(tbuf, " /* virtual functions */\n");
919  tvf=Typemaker2_VirtualFn_List_First(tvfl);
920  while (tvf) {
921  const char *fname;
922  const char *fpreset;
923 
924  fname=Typemaker2_VirtualFn_GetName(tvf);
925  fpreset=Typemaker2_VirtualFn_GetPreset(tvf);
926  if (fname && *fname && fpreset && *fpreset) {
927  GWEN_Buffer_AppendString(tbuf, " ");
928  GWEN_Buffer_AppendString(tbuf, "p_struct->");
929  GWEN_Buffer_AppendByte(tbuf, tolower(*fname));
930  GWEN_Buffer_AppendString(tbuf, fname+1);
931  GWEN_Buffer_AppendString(tbuf, "Fn=");
932  GWEN_Buffer_AppendString(tbuf, fpreset);
933  GWEN_Buffer_AppendString(tbuf, ";\n");
934  }
935  tvf=Typemaker2_VirtualFn_List_Next(tvf);
936  }
937  }
938 
939  GWEN_Buffer_AppendString(tbuf, "\n");
940  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
941  GWEN_Buffer_AppendString(tbuf, "}\n");
942 
943  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
944  GWEN_Buffer_free(tbuf);
945 
946  return 0;
947 }
948 
949 
950 
951 static int _buildDestructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
952 {
953  GWEN_BUFFER *tbuf;
954  const char *s;
955  TYPEMAKER2_MEMBER_LIST *tml;
956  uint32_t flags;
957  TYPEMAKER2_TYPEMANAGER *tym;
958 
959  tym=Typemaker2_Builder_GetTypeManager(tb);
960  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
961 
962  flags=Typemaker2_Type_GetFlags(ty);
963 
964  /* prototype */
965  GWEN_Buffer_AppendString(tbuf, "/** Destructor. */\n");
966  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
967  if (s) {
968  GWEN_Buffer_AppendString(tbuf, s);
969  GWEN_Buffer_AppendString(tbuf, " ");
970  }
971  GWEN_Buffer_AppendString(tbuf, "void ");
972  s=Typemaker2_Type_GetPrefix(ty);
973  GWEN_Buffer_AppendString(tbuf, s);
974  GWEN_Buffer_AppendString(tbuf, "_free(");
975  s=Typemaker2_Type_GetIdentifier(ty);
976  GWEN_Buffer_AppendString(tbuf, s);
977  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
978  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
979  GWEN_Buffer_Reset(tbuf);
980 
981  /* insert freeHook prototype, if needed */
982  s=Typemaker2_Type_GetFreeHook(ty);
983  if (s && *s) {
984  GWEN_Buffer_AppendString(tbuf, "static void ");
985  GWEN_Buffer_AppendString(tbuf, s);
986  GWEN_Buffer_AppendString(tbuf, "(");
987  s=Typemaker2_Type_GetIdentifier(ty);
988  GWEN_Buffer_AppendString(tbuf, s);
989  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
990  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
991  GWEN_Buffer_Reset(tbuf);
992  }
993 
994 
995  /* implementation */
996  GWEN_Buffer_AppendString(tbuf, "void ");
997  s=Typemaker2_Type_GetPrefix(ty);
998  GWEN_Buffer_AppendString(tbuf, s);
999  GWEN_Buffer_AppendString(tbuf, "_free(");
1000  s=Typemaker2_Type_GetIdentifier(ty);
1001  GWEN_Buffer_AppendString(tbuf, s);
1002  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
1003 
1004  GWEN_Buffer_AppendString(tbuf, " if (p_struct) {\n");
1005 
1006  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
1007  GWEN_Buffer_AppendString(tbuf, " assert(p_struct->_refCount);\n");
1008  GWEN_Buffer_AppendString(tbuf, " if (p_struct->_refCount==1) {\n");
1009  }
1010 
1011  if ((flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) || (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS)) {
1012  GWEN_Buffer_AppendString(tbuf, " GWEN_SignalObject_free(p_struct->_signalObject);\n");
1013  }
1014 
1015  /* insert freeHook, if any */
1016  s=Typemaker2_Type_GetFreeHook(ty);
1017  if (s && *s) {
1018  GWEN_Buffer_AppendString(tbuf, " ");
1019  GWEN_Buffer_AppendString(tbuf, s);
1020  GWEN_Buffer_AppendString(tbuf, "(p_struct);\n");
1021  }
1022 
1023  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_INHERIT) {
1024  GWEN_Buffer_AppendString(tbuf, " GWEN_INHERIT_FINI(");
1025  s=Typemaker2_Type_GetIdentifier(ty);
1026  GWEN_Buffer_AppendString(tbuf, s);
1027  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
1028  }
1029 
1030  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
1031  GWEN_Buffer_AppendString(tbuf, " GWEN_LIST_FINI(");
1032  s=Typemaker2_Type_GetIdentifier(ty);
1033  GWEN_Buffer_AppendString(tbuf, s);
1034  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
1035  }
1036 
1037  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
1038  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE_FINI(");
1039  s=Typemaker2_Type_GetIdentifier(ty);
1040  GWEN_Buffer_AppendString(tbuf, s);
1041  GWEN_Buffer_AppendString(tbuf, ", p_struct)\n");
1042  }
1043 
1044  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
1045  GWEN_Buffer_AppendString(tbuf, " GWEN_TREE2_FINI(");
1046  s=Typemaker2_Type_GetIdentifier(ty);
1047  GWEN_Buffer_AppendString(tbuf, s);
1048  GWEN_Buffer_AppendString(tbuf, ", p_struct, ");
1049  s=Typemaker2_Type_GetPrefix(ty);
1050  GWEN_Buffer_AppendString(tbuf, s);
1051  GWEN_Buffer_AppendString(tbuf, ")\n");
1052  }
1053 
1054  GWEN_Buffer_AppendString(tbuf, " /* members */\n");
1055  tml=Typemaker2_Type_GetMembers(ty);
1056  if (tml) {
1057  TYPEMAKER2_MEMBER *tm;
1058 
1059  tm=Typemaker2_Member_List_First(tml);
1060  while (tm) {
1061  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN) {
1062  /* destruct, but only if the member is owned */
1063  if (1) {
1064  GWEN_BUFFER *dstbuf;
1065  int rv;
1066 
1067  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
1068  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
1069  s=Typemaker2_Member_GetName(tm);
1070  GWEN_Buffer_AppendString(dstbuf, s);
1071 
1072  GWEN_Buffer_AppendString(tbuf, " ");
1073  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
1074  GWEN_Buffer_GetStart(dstbuf),
1075  NULL, /* no dest */
1076  tbuf);
1077  if (rv<0) {
1078  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1079  GWEN_Buffer_free(dstbuf);
1080  GWEN_Buffer_free(tbuf);
1081  return rv;
1082  }
1083  GWEN_Buffer_free(dstbuf);
1084  GWEN_Buffer_AppendString(tbuf, "\n");
1085  }
1086  }
1087 
1088  tm=Typemaker2_Member_List_Next(tm);
1089  }
1090  }
1091 
1092  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
1093  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount=0;\n");
1094  }
1095 
1096  GWEN_Buffer_AppendString(tbuf, " GWEN_FREE_OBJECT(p_struct);\n");
1097  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
1098  GWEN_Buffer_AppendString(tbuf, " }\n");
1099  GWEN_Buffer_AppendString(tbuf, " else\n");
1100  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount--;\n");
1101  }
1102  GWEN_Buffer_AppendString(tbuf, " }\n");
1103  GWEN_Buffer_AppendString(tbuf, "}\n");
1104 
1105  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1106  GWEN_Buffer_free(tbuf);
1107 
1108  return 0;
1109 }
1110 
1111 
1112 
1113 static int _buildGetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
1114 {
1115  GWEN_BUFFER *tbuf;
1116  const char *s;
1117  TYPEMAKER2_MEMBER_LIST *tml;
1118  uint32_t flags;
1119  TYPEMAKER2_TYPEMANAGER *tym;
1120 
1121  tym=Typemaker2_Builder_GetTypeManager(tb);
1122  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
1123  flags=Typemaker2_Type_GetFlags(ty);
1124 
1125  /* probably add getter for signalObject */
1126  if ((flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) || (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS)) {
1127  /* prototype */
1128  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1129  if (s && *s) {
1130  GWEN_Buffer_AppendString(tbuf, s);
1131  GWEN_Buffer_AppendString(tbuf, " ");
1132  }
1133 
1134  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNALOBJECT *");
1135  s=Typemaker2_Type_GetPrefix(ty);
1136  GWEN_Buffer_AppendString(tbuf, s);
1137  GWEN_Buffer_AppendString(tbuf, "_GetSignalObject(const ");
1138  s=Typemaker2_Type_GetIdentifier(ty);
1139  GWEN_Buffer_AppendString(tbuf, s);
1140  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
1141 
1142 
1143  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1144  GWEN_Buffer_Reset(tbuf);
1145 
1146  /* implementation */
1147  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNALOBJECT *");
1148  s=Typemaker2_Type_GetPrefix(ty);
1149  GWEN_Buffer_AppendString(tbuf, s);
1150  GWEN_Buffer_AppendString(tbuf, "_GetSignalObject(const ");
1151  s=Typemaker2_Type_GetIdentifier(ty);
1152  GWEN_Buffer_AppendString(tbuf, s);
1153  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
1154 
1155  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1156  GWEN_Buffer_AppendString(tbuf, " return p_struct->_signalObject;\n");
1157 
1158  GWEN_Buffer_AppendString(tbuf, "}\n");
1159 
1160  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1161  GWEN_Buffer_Reset(tbuf);
1162 
1163  }
1164 
1165  tml=Typemaker2_Type_GetMembers(ty);
1166  if (tml) {
1167  TYPEMAKER2_MEMBER *tm;
1168 
1169  tm=Typemaker2_Member_List_First(tml);
1170  while (tm) {
1171  if (!(Typemaker2_Member_GetGetFlags(tm) & TYPEMAKER2_FLAGS_OMIT)) {
1172  TYPEMAKER2_TYPE *mty;
1173 
1174  mty=Typemaker2_Member_GetTypePtr(tm);
1175  assert(mty);
1176 
1177  /* prototype */
1178  GWEN_Buffer_AppendString(tbuf,
1179  "/** Getter.\n"
1180  " * Use this function to get the member \"");
1181  s=Typemaker2_Member_GetName(tm);
1182  GWEN_Buffer_AppendString(tbuf, s);
1183  GWEN_Buffer_AppendString(tbuf, "\" (see @ref ");
1184  s=Typemaker2_Type_GetIdentifier(ty);
1185  GWEN_Buffer_AppendString(tbuf, s);
1186  GWEN_Buffer_AppendString(tbuf, "_");
1187  s=Typemaker2_Member_GetName(tm);
1188  GWEN_Buffer_AppendString(tbuf, s);
1189  GWEN_Buffer_AppendString(tbuf, ")\n*/\n");
1190 
1191  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1192  if (s && Typemaker2_Member_GetAccess(tm)<=TypeMaker2_Access_Protected) {
1193  GWEN_Buffer_AppendString(tbuf, s);
1194  GWEN_Buffer_AppendString(tbuf, " ");
1195  }
1196  if ((Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1197  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) &&
1198  (Typemaker2_Member_GetGetFlags(tm) & TYPEMAKER2_FLAGS_CONST))
1199  GWEN_Buffer_AppendString(tbuf, "const ");
1200  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1201  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1202  const char *s;
1203 
1204  assert(te);
1205  s=Typemaker2_Enum_GetType(te);
1206  if (s && *s) {
1207  GWEN_Buffer_AppendString(tbuf, s);
1208  }
1209  else {
1210  s=Typemaker2_Type_GetIdentifier(mty);
1211  GWEN_Buffer_AppendString(tbuf, s);
1212  }
1213  }
1214  else {
1215  s=Typemaker2_Type_GetIdentifier(mty);
1216  GWEN_Buffer_AppendString(tbuf, s);
1217  }
1218  GWEN_Buffer_AppendString(tbuf, " ");
1219  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1220  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array)
1221  GWEN_Buffer_AppendString(tbuf, "*");
1222 
1223  s=Typemaker2_Type_GetPrefix(ty);
1224  GWEN_Buffer_AppendString(tbuf, s);
1225  GWEN_Buffer_AppendString(tbuf, "_Get");
1226  s=Typemaker2_Member_GetName(tm);
1227  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1228  GWEN_Buffer_AppendString(tbuf, s+1);
1229 
1230  GWEN_Buffer_AppendString(tbuf, "(");
1231  if (!(Typemaker2_Member_GetGetFlags(tm) & TYPEMAKER2_FLAGS_NOCONSTOBJECT))
1232  GWEN_Buffer_AppendString(tbuf, "const ");
1233  s=Typemaker2_Type_GetIdentifier(ty);
1234  GWEN_Buffer_AppendString(tbuf, s);
1235  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
1236 
1237  switch (Typemaker2_Member_GetAccess(tm)) {
1238  case TypeMaker2_Access_Public:
1239  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1240  break;
1241  case TypeMaker2_Access_Library:
1242  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1243  break;
1244  case TypeMaker2_Access_Protected:
1245  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1246  break;
1247  case TypeMaker2_Access_Private:
1248  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1249  break;
1250  default:
1251  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
1252  GWEN_Buffer_free(tbuf);
1253  return GWEN_ERROR_BAD_DATA;
1254  }
1255  GWEN_Buffer_Reset(tbuf);
1256 
1257  /* implementation */
1258  if ((Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1259  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) &&
1260  (Typemaker2_Member_GetGetFlags(tm) & TYPEMAKER2_FLAGS_CONST))
1261  GWEN_Buffer_AppendString(tbuf, "const ");
1262  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1263  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1264  const char *s;
1265 
1266  assert(te);
1267  s=Typemaker2_Enum_GetType(te);
1268  if (s && *s) {
1269  GWEN_Buffer_AppendString(tbuf, s);
1270  }
1271  else {
1272  s=Typemaker2_Type_GetIdentifier(mty);
1273  GWEN_Buffer_AppendString(tbuf, s);
1274  }
1275  }
1276  else {
1277  s=Typemaker2_Type_GetIdentifier(mty);
1278  GWEN_Buffer_AppendString(tbuf, s);
1279  }
1280  GWEN_Buffer_AppendString(tbuf, " ");
1281  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1282  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array)
1283  GWEN_Buffer_AppendString(tbuf, "*");
1284 
1285  s=Typemaker2_Type_GetPrefix(ty);
1286  GWEN_Buffer_AppendString(tbuf, s);
1287  GWEN_Buffer_AppendString(tbuf, "_Get");
1288  s=Typemaker2_Member_GetName(tm);
1289  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1290  GWEN_Buffer_AppendString(tbuf, s+1);
1291 
1292  GWEN_Buffer_AppendString(tbuf, "(");
1293  if (!(Typemaker2_Member_GetGetFlags(tm) & TYPEMAKER2_FLAGS_NOCONSTOBJECT))
1294  GWEN_Buffer_AppendString(tbuf, "const ");
1295  s=Typemaker2_Type_GetIdentifier(ty);
1296  GWEN_Buffer_AppendString(tbuf, s);
1297  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
1298 
1299  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1300  GWEN_Buffer_AppendString(tbuf, " return p_struct->");
1301  s=Typemaker2_Member_GetName(tm);
1302  GWEN_Buffer_AppendString(tbuf, s);
1303  GWEN_Buffer_AppendString(tbuf, ";\n");
1304 
1305  GWEN_Buffer_AppendString(tbuf, "}\n");
1306 
1307  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1308  GWEN_Buffer_Reset(tbuf);
1309  }
1310 
1311  tm=Typemaker2_Member_List_Next(tm);
1312  }
1313  }
1314 
1315  return 0;
1316 }
1317 
1318 
1319 
1320 static int _buildSetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
1321 {
1322  GWEN_BUFFER *tbuf;
1323  const char *s;
1324  TYPEMAKER2_MEMBER_LIST *tml;
1325  /* uint32_t flags; */
1326  TYPEMAKER2_TYPEMANAGER *tym;
1327 
1328  tym=Typemaker2_Builder_GetTypeManager(tb);
1329  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
1330  /* flags=Typemaker2_Type_GetFlags(ty); */
1331 
1332  tml=Typemaker2_Type_GetMembers(ty);
1333  if (tml) {
1334  TYPEMAKER2_MEMBER *tm;
1335 
1336  tm=Typemaker2_Member_List_First(tml);
1337  while (tm) {
1338  if (!(Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_OMIT)) {
1339  TYPEMAKER2_TYPE *mty;
1340  int typeIsWritten=0;
1341 
1342  mty=Typemaker2_Member_GetTypePtr(tm);
1343  assert(mty);
1344 
1345  /* prototype */
1346  GWEN_Buffer_AppendString(tbuf,
1347  "/** Setter.\n"
1348  " * Use this function to set the member \"");
1349  s=Typemaker2_Member_GetName(tm);
1350  GWEN_Buffer_AppendString(tbuf, s);
1351  GWEN_Buffer_AppendString(tbuf, "\" (see @ref ");
1352  s=Typemaker2_Type_GetIdentifier(ty);
1353  GWEN_Buffer_AppendString(tbuf, s);
1354  GWEN_Buffer_AppendString(tbuf, "_");
1355  s=Typemaker2_Member_GetName(tm);
1356  GWEN_Buffer_AppendString(tbuf, s);
1357  GWEN_Buffer_AppendString(tbuf, ")\n*/\n");
1358 
1359  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1360  if (s && Typemaker2_Member_GetAccess(tm)<=TypeMaker2_Access_Protected) {
1361  GWEN_Buffer_AppendString(tbuf, s);
1362  GWEN_Buffer_AppendString(tbuf, " ");
1363  }
1364  GWEN_Buffer_AppendString(tbuf, "void ");
1365  s=Typemaker2_Type_GetPrefix(ty);
1366  GWEN_Buffer_AppendString(tbuf, s);
1367  GWEN_Buffer_AppendString(tbuf, "_Set");
1368  s=Typemaker2_Member_GetName(tm);
1369  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1370  GWEN_Buffer_AppendString(tbuf, s+1);
1371 
1372  GWEN_Buffer_AppendString(tbuf, "(");
1373  s=Typemaker2_Type_GetIdentifier(ty);
1374  GWEN_Buffer_AppendString(tbuf, s);
1375  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1376 
1377  typeIsWritten=0;
1378  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1379  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1380  const char *s;
1381 
1382  assert(te);
1383  s=Typemaker2_Enum_GetType(te);
1384  if (s && *s) {
1385  GWEN_Buffer_AppendString(tbuf, s);
1386  GWEN_Buffer_AppendString(tbuf, " ");
1387  GWEN_Buffer_AppendString(tbuf, " p_src");
1388  typeIsWritten=1;
1389  }
1390  }
1391 
1392  if (!typeIsWritten) {
1393  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1394  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
1395  if (Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_CONST ||
1396  Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_DUP)
1397  GWEN_Buffer_AppendString(tbuf, "const ");
1398  s=Typemaker2_Type_GetIdentifier(mty);
1399  GWEN_Buffer_AppendString(tbuf, s);
1400  GWEN_Buffer_AppendString(tbuf, " *p_src");
1401  }
1402  else {
1403  s=Typemaker2_Type_GetIdentifier(mty);
1404  GWEN_Buffer_AppendString(tbuf, s);
1405  GWEN_Buffer_AppendString(tbuf, " p_src");
1406  }
1407  }
1408  GWEN_Buffer_AppendString(tbuf, ");\n");
1409 
1410  switch (Typemaker2_Member_GetAccess(tm)) {
1411  case TypeMaker2_Access_Public:
1412  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1413  break;
1414  case TypeMaker2_Access_Library:
1415  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1416  break;
1417  case TypeMaker2_Access_Protected:
1418  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1419  break;
1420  case TypeMaker2_Access_Private:
1421  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1422  break;
1423  default:
1424  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
1425  GWEN_Buffer_free(tbuf);
1426  return GWEN_ERROR_BAD_DATA;
1427  }
1428  GWEN_Buffer_Reset(tbuf);
1429 
1430  /* add special functions for flags */
1431  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_FLAGS) {
1432  GWEN_Buffer_AppendString(tbuf,
1433  "/** Add flags.\n"
1434  " * Use this function to add flags to the member \"");
1435  s=Typemaker2_Member_GetName(tm);
1436  GWEN_Buffer_AppendString(tbuf, s);
1437  GWEN_Buffer_AppendString(tbuf, "\"\n*/\n");
1438  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1439  if (s && Typemaker2_Member_GetAccess(tm)<=TypeMaker2_Access_Protected) {
1440  GWEN_Buffer_AppendString(tbuf, s);
1441  GWEN_Buffer_AppendString(tbuf, " ");
1442  }
1443  GWEN_Buffer_AppendString(tbuf, "void ");
1444  s=Typemaker2_Type_GetPrefix(ty);
1445  GWEN_Buffer_AppendString(tbuf, s);
1446  GWEN_Buffer_AppendString(tbuf, "_Add");
1447  s=Typemaker2_Member_GetName(tm);
1448  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1449  GWEN_Buffer_AppendString(tbuf, s+1);
1450 
1451  GWEN_Buffer_AppendString(tbuf, "(");
1452  s=Typemaker2_Type_GetIdentifier(ty);
1453  GWEN_Buffer_AppendString(tbuf, s);
1454  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1455 
1456  typeIsWritten=0;
1457  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1458  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1459  const char *s;
1460 
1461  assert(te);
1462  s=Typemaker2_Enum_GetType(te);
1463  if (s && *s) {
1464  GWEN_Buffer_AppendString(tbuf, s);
1465  GWEN_Buffer_AppendString(tbuf, " ");
1466  GWEN_Buffer_AppendString(tbuf, " p_src");
1467  typeIsWritten=1;
1468  }
1469  }
1470 
1471  if (!typeIsWritten) {
1472  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1473  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
1474  if (Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_CONST ||
1475  Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_DUP)
1476  GWEN_Buffer_AppendString(tbuf, "const ");
1477  s=Typemaker2_Type_GetIdentifier(mty);
1478  GWEN_Buffer_AppendString(tbuf, s);
1479  GWEN_Buffer_AppendString(tbuf, " *p_src");
1480  }
1481  else {
1482  s=Typemaker2_Type_GetIdentifier(mty);
1483  GWEN_Buffer_AppendString(tbuf, s);
1484  GWEN_Buffer_AppendString(tbuf, " p_src");
1485  }
1486  }
1487  GWEN_Buffer_AppendString(tbuf, ");\n");
1488 
1489  switch (Typemaker2_Member_GetAccess(tm)) {
1490  case TypeMaker2_Access_Public:
1491  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1492  break;
1493  case TypeMaker2_Access_Library:
1494  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1495  break;
1496  case TypeMaker2_Access_Protected:
1497  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1498  break;
1499  case TypeMaker2_Access_Private:
1500  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1501  break;
1502  default:
1503  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
1504  GWEN_Buffer_free(tbuf);
1505  return GWEN_ERROR_BAD_DATA;
1506  }
1507  GWEN_Buffer_Reset(tbuf);
1508 
1509  GWEN_Buffer_AppendString(tbuf,
1510  "/** Sub flags.\n"
1511  " * Use this function to sub flags from the member \"");
1512  s=Typemaker2_Member_GetName(tm);
1513  GWEN_Buffer_AppendString(tbuf, s);
1514  GWEN_Buffer_AppendString(tbuf, "\"\n*/\n");
1515  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1516  if (s && Typemaker2_Member_GetAccess(tm)<=TypeMaker2_Access_Protected) {
1517  GWEN_Buffer_AppendString(tbuf, s);
1518  GWEN_Buffer_AppendString(tbuf, " ");
1519  }
1520  GWEN_Buffer_AppendString(tbuf, "void ");
1521  s=Typemaker2_Type_GetPrefix(ty);
1522  GWEN_Buffer_AppendString(tbuf, s);
1523  GWEN_Buffer_AppendString(tbuf, "_Sub");
1524  s=Typemaker2_Member_GetName(tm);
1525  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1526  GWEN_Buffer_AppendString(tbuf, s+1);
1527 
1528  GWEN_Buffer_AppendString(tbuf, "(");
1529  s=Typemaker2_Type_GetIdentifier(ty);
1530  GWEN_Buffer_AppendString(tbuf, s);
1531  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1532 
1533  typeIsWritten=0;
1534  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1535  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1536  const char *s;
1537 
1538  assert(te);
1539  s=Typemaker2_Enum_GetType(te);
1540  if (s && *s) {
1541  GWEN_Buffer_AppendString(tbuf, s);
1542  GWEN_Buffer_AppendString(tbuf, " ");
1543  GWEN_Buffer_AppendString(tbuf, " p_src");
1544  typeIsWritten=1;
1545  }
1546  }
1547 
1548  if (!typeIsWritten) {
1549  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1550  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
1551  if (Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_CONST ||
1552  Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_DUP)
1553  GWEN_Buffer_AppendString(tbuf, "const ");
1554  s=Typemaker2_Type_GetIdentifier(mty);
1555  GWEN_Buffer_AppendString(tbuf, s);
1556  GWEN_Buffer_AppendString(tbuf, " *p_src");
1557  }
1558  else {
1559  s=Typemaker2_Type_GetIdentifier(mty);
1560  GWEN_Buffer_AppendString(tbuf, s);
1561  GWEN_Buffer_AppendString(tbuf, " p_src");
1562  }
1563  }
1564  GWEN_Buffer_AppendString(tbuf, ");\n");
1565 
1566  switch (Typemaker2_Member_GetAccess(tm)) {
1567  case TypeMaker2_Access_Public:
1568  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1569  break;
1570  case TypeMaker2_Access_Library:
1571  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1572  break;
1573  case TypeMaker2_Access_Protected:
1574  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1575  break;
1576  case TypeMaker2_Access_Private:
1577  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1578  break;
1579  default:
1580  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
1581  GWEN_Buffer_free(tbuf);
1582  return GWEN_ERROR_BAD_DATA;
1583  }
1584  GWEN_Buffer_Reset(tbuf);
1585  }
1586 
1587 
1588  /* implementation */
1589  GWEN_Buffer_AppendString(tbuf, "void ");
1590  s=Typemaker2_Type_GetPrefix(ty);
1591  GWEN_Buffer_AppendString(tbuf, s);
1592  GWEN_Buffer_AppendString(tbuf, "_Set");
1593  s=Typemaker2_Member_GetName(tm);
1594  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1595  GWEN_Buffer_AppendString(tbuf, s+1);
1596 
1597  GWEN_Buffer_AppendString(tbuf, "(");
1598  s=Typemaker2_Type_GetIdentifier(ty);
1599  GWEN_Buffer_AppendString(tbuf, s);
1600  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1601 
1602  typeIsWritten=0;
1603  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1604  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1605  const char *s;
1606 
1607  assert(te);
1608  s=Typemaker2_Enum_GetType(te);
1609  if (s && *s) {
1610  GWEN_Buffer_AppendString(tbuf, s);
1611  GWEN_Buffer_AppendString(tbuf, " ");
1612  GWEN_Buffer_AppendString(tbuf, " p_src");
1613  typeIsWritten=1;
1614  }
1615  }
1616 
1617  if (!typeIsWritten) {
1618  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
1619  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
1620  if (Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_CONST ||
1621  Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_DUP)
1622  GWEN_Buffer_AppendString(tbuf, "const ");
1623  s=Typemaker2_Type_GetIdentifier(mty);
1624  GWEN_Buffer_AppendString(tbuf, s);
1625  GWEN_Buffer_AppendString(tbuf, " *p_src");
1626  }
1627  else {
1628  s=Typemaker2_Type_GetIdentifier(mty);
1629  GWEN_Buffer_AppendString(tbuf, s);
1630  GWEN_Buffer_AppendString(tbuf, " p_src");
1631  }
1632  }
1633  GWEN_Buffer_AppendString(tbuf, ") {\n");
1634 
1635  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1636  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN) {
1637 
1638  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
1639  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
1640  s=Typemaker2_Member_GetName(tm);
1641  GWEN_Buffer_AppendString(tbuf, s);
1642  GWEN_Buffer_AppendString(tbuf, ") {\n");
1643  }
1644 
1645  /* free */
1646  if (1) {
1647  GWEN_BUFFER *srcbuf;
1648  int rv;
1649 
1650  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
1651  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
1652  s=Typemaker2_Member_GetName(tm);
1653  GWEN_Buffer_AppendString(srcbuf, s);
1654 
1655  GWEN_Buffer_AppendString(tbuf, " ");
1656  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
1657  GWEN_Buffer_GetStart(srcbuf),
1658  NULL, /* no dest */
1659  tbuf);
1660  if (rv<0) {
1661  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1662  GWEN_Buffer_free(srcbuf);
1663  GWEN_Buffer_free(tbuf);
1664  return rv;
1665  }
1666  GWEN_Buffer_AppendString(tbuf, "\n");
1667  GWEN_Buffer_free(srcbuf);
1668  }
1669 
1670  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
1671  GWEN_Buffer_AppendString(tbuf, " }\n");
1672  }
1673  } /* if own */
1674 
1675  if (Typemaker2_Member_GetSetFlags(tm) & TYPEMAKER2_FLAGS_DUP) {
1676  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer)
1677  GWEN_Buffer_AppendString(tbuf, " if (p_src) {\n");
1678 
1679  /* dup */
1680  if (1) {
1681  GWEN_BUFFER *dstbuf;
1682  int rv;
1683 
1684  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
1685  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
1686  s=Typemaker2_Member_GetName(tm);
1687  GWEN_Buffer_AppendString(dstbuf, s);
1688 
1689  GWEN_Buffer_AppendString(tbuf, " ");
1690  rv=Typemaker2_Builder_Invoke_DupFn(tb, ty, tm,
1691  "p_src",
1692  GWEN_Buffer_GetStart(dstbuf),
1693  tbuf);
1694  if (rv<0) {
1695  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1696  GWEN_Buffer_free(dstbuf);
1697  GWEN_Buffer_free(tbuf);
1698  return rv;
1699  }
1700  GWEN_Buffer_AppendString(tbuf, "\n");
1701  GWEN_Buffer_free(dstbuf);
1702  }
1703 
1704  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
1705  GWEN_Buffer_AppendString(tbuf, " }\n");
1706  GWEN_Buffer_AppendString(tbuf, " else {\n");
1707 
1708  /* construct */
1709  if (1) {
1710  GWEN_BUFFER *dstbuf;
1711  int rv;
1712 
1713  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
1714  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
1715  s=Typemaker2_Member_GetName(tm);
1716  GWEN_Buffer_AppendString(dstbuf, s);
1717 
1718  GWEN_Buffer_AppendString(tbuf, " ");
1719  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
1720  NULL,
1721  GWEN_Buffer_GetStart(dstbuf),
1722  tbuf);
1723  if (rv<0) {
1724  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1725  GWEN_Buffer_free(dstbuf);
1726  GWEN_Buffer_free(tbuf);
1727  return rv;
1728  }
1729  GWEN_Buffer_AppendString(tbuf, "\n");
1730  GWEN_Buffer_free(dstbuf);
1731  }
1732  else {
1733  GWEN_Buffer_AppendString(tbuf, " p_struct->");
1734  s=Typemaker2_Member_GetName(tm);
1735  GWEN_Buffer_AppendString(tbuf, s);
1736  GWEN_Buffer_AppendString(tbuf, " = ");
1737  s=Typemaker2_Member_GetPresetValue(tm);
1738  if (s && *s)
1739  GWEN_Buffer_AppendString(tbuf, s);
1740  else
1741  GWEN_Buffer_AppendString(tbuf, "NULL");
1742  GWEN_Buffer_AppendString(tbuf, ";\n");
1743  }
1744 
1745  GWEN_Buffer_AppendString(tbuf, " }\n");
1746  }
1747  }
1748  else {
1749  if (1) {
1750  GWEN_BUFFER *dstbuf;
1751  int rv;
1752 
1753  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
1754  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
1755  s=Typemaker2_Member_GetName(tm);
1756  GWEN_Buffer_AppendString(dstbuf, s);
1757 
1758  GWEN_Buffer_AppendString(tbuf, " ");
1759  rv=Typemaker2_Builder_Invoke_AssignFn(tb, ty, tm,
1760  "p_src",
1761  GWEN_Buffer_GetStart(dstbuf),
1762  tbuf);
1763  if (rv<0) {
1764  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1765  GWEN_Buffer_free(dstbuf);
1766  GWEN_Buffer_free(tbuf);
1767  return rv;
1768  }
1769  GWEN_Buffer_AppendString(tbuf, "\n");
1770  GWEN_Buffer_free(dstbuf);
1771  }
1772  }
1773 
1774  GWEN_Buffer_AppendString(tbuf, "}\n");
1775 
1776  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1777  GWEN_Buffer_Reset(tbuf);
1778 
1779  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_FLAGS) {
1780  /* add flags */
1781  GWEN_Buffer_AppendString(tbuf, "void ");
1782  s=Typemaker2_Type_GetPrefix(ty);
1783  GWEN_Buffer_AppendString(tbuf, s);
1784  GWEN_Buffer_AppendString(tbuf, "_Add");
1785  s=Typemaker2_Member_GetName(tm);
1786  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1787  GWEN_Buffer_AppendString(tbuf, s+1);
1788 
1789  GWEN_Buffer_AppendString(tbuf, "(");
1790  s=Typemaker2_Type_GetIdentifier(ty);
1791  GWEN_Buffer_AppendString(tbuf, s);
1792  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1793 
1794  typeIsWritten=0;
1795  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1796  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1797  const char *s;
1798 
1799  assert(te);
1800  s=Typemaker2_Enum_GetType(te);
1801  if (s && *s) {
1802  GWEN_Buffer_AppendString(tbuf, s);
1803  GWEN_Buffer_AppendString(tbuf, " ");
1804  GWEN_Buffer_AppendString(tbuf, " p_src");
1805  typeIsWritten=1;
1806  }
1807  }
1808 
1809  if (!typeIsWritten) {
1810  s=Typemaker2_Type_GetIdentifier(mty);
1811  GWEN_Buffer_AppendString(tbuf, s);
1812  GWEN_Buffer_AppendString(tbuf, " p_src");
1813  }
1814  GWEN_Buffer_AppendString(tbuf, ") {\n");
1815 
1816  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1817  GWEN_Buffer_AppendString(tbuf, " p_struct->");
1818  s=Typemaker2_Member_GetName(tm);
1819  GWEN_Buffer_AppendString(tbuf, s);
1820  GWEN_Buffer_AppendString(tbuf, "|=p_src;\n");
1821  GWEN_Buffer_AppendString(tbuf, "}\n");
1822 
1823  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1824  GWEN_Buffer_Reset(tbuf);
1825 
1826  /* sub flags */
1827  GWEN_Buffer_AppendString(tbuf, "void ");
1828  s=Typemaker2_Type_GetPrefix(ty);
1829  GWEN_Buffer_AppendString(tbuf, s);
1830  GWEN_Buffer_AppendString(tbuf, "_Sub");
1831  s=Typemaker2_Member_GetName(tm);
1832  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
1833  GWEN_Buffer_AppendString(tbuf, s+1);
1834 
1835  GWEN_Buffer_AppendString(tbuf, "(");
1836  s=Typemaker2_Type_GetIdentifier(ty);
1837  GWEN_Buffer_AppendString(tbuf, s);
1838  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
1839 
1840  typeIsWritten=0;
1841  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_ENUM) {
1842  TYPEMAKER2_ENUM *te=Typemaker2_Member_GetEnumPtr(tm);
1843  const char *s;
1844 
1845  assert(te);
1846  s=Typemaker2_Enum_GetType(te);
1847  if (s && *s) {
1848  GWEN_Buffer_AppendString(tbuf, s);
1849  GWEN_Buffer_AppendString(tbuf, " ");
1850  GWEN_Buffer_AppendString(tbuf, " p_src");
1851  typeIsWritten=1;
1852  }
1853  }
1854 
1855  if (!typeIsWritten) {
1856  s=Typemaker2_Type_GetIdentifier(mty);
1857  GWEN_Buffer_AppendString(tbuf, s);
1858  GWEN_Buffer_AppendString(tbuf, " p_src");
1859  }
1860  GWEN_Buffer_AppendString(tbuf, ") {\n");
1861 
1862  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1863  GWEN_Buffer_AppendString(tbuf, " p_struct->");
1864  s=Typemaker2_Member_GetName(tm);
1865  GWEN_Buffer_AppendString(tbuf, s);
1866  GWEN_Buffer_AppendString(tbuf, "&=~p_src;\n");
1867  GWEN_Buffer_AppendString(tbuf, "}\n");
1868 
1869  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
1870  GWEN_Buffer_Reset(tbuf);
1871  }
1872  }
1873 
1874  tm=Typemaker2_Member_List_Next(tm);
1875  }
1876  }
1877 
1878  return 0;
1879 }
1880 
1881 
1882 
1883 static int _buildReadDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
1884 {
1885  GWEN_BUFFER *tbuf;
1886  const char *s;
1887  TYPEMAKER2_MEMBER_LIST *tml;
1888  /* uint32_t flags; */
1889  TYPEMAKER2_TYPEMANAGER *tym;
1890 
1891  tym=Typemaker2_Builder_GetTypeManager(tb);
1892  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
1893 
1894  /* flags=Typemaker2_Type_GetFlags(ty); */
1895 
1896  /* prototype */
1897  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
1898  if (s) {
1899  GWEN_Buffer_AppendString(tbuf, s);
1900  GWEN_Buffer_AppendString(tbuf, " ");
1901  }
1902  GWEN_Buffer_AppendString(tbuf, "void ");
1903  s=Typemaker2_Type_GetPrefix(ty);
1904  GWEN_Buffer_AppendString(tbuf, s);
1905  GWEN_Buffer_AppendString(tbuf, "_ReadDb(");
1906  s=Typemaker2_Type_GetIdentifier(ty);
1907  GWEN_Buffer_AppendString(tbuf, s);
1908  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db);\n");
1909  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
1910  GWEN_Buffer_Reset(tbuf);
1911 
1912  /* implementation */
1913  GWEN_Buffer_AppendString(tbuf, "void ");
1914  s=Typemaker2_Type_GetPrefix(ty);
1915  GWEN_Buffer_AppendString(tbuf, s);
1916  GWEN_Buffer_AppendString(tbuf, "_ReadDb(");
1917  s=Typemaker2_Type_GetIdentifier(ty);
1918  GWEN_Buffer_AppendString(tbuf, s);
1919  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db) {\n");
1920 
1921  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
1922 
1923  tml=Typemaker2_Type_GetMembers(ty);
1924  if (tml) {
1925  TYPEMAKER2_MEMBER *tm;
1926 
1927  tm=Typemaker2_Member_List_First(tml);
1928  while (tm) {
1929  TYPEMAKER2_TYPE *mty;
1930 
1931  mty=Typemaker2_Member_GetTypePtr(tm);
1932  assert(mty);
1933 
1934  GWEN_Buffer_AppendString(tbuf, " /* member \"");
1935  s=Typemaker2_Member_GetName(tm);
1936  GWEN_Buffer_AppendString(tbuf, s);
1937  GWEN_Buffer_AppendString(tbuf, "\" */\n");
1938 
1939  /* release previous value */
1940  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer &&
1941  (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN)) {
1942  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
1943  s=Typemaker2_Member_GetName(tm);
1944  GWEN_Buffer_AppendString(tbuf, s);
1945  GWEN_Buffer_AppendString(tbuf, ") {\n");
1946 
1947  /* free */
1948  if (1) {
1949  GWEN_BUFFER *srcbuf;
1950  int rv;
1951 
1952  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
1953  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
1954  s=Typemaker2_Member_GetName(tm);
1955  GWEN_Buffer_AppendString(srcbuf, s);
1956 
1957  GWEN_Buffer_AppendString(tbuf, " ");
1958  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
1959  GWEN_Buffer_GetStart(srcbuf),
1960  NULL, /* no dest */
1961  tbuf);
1962  if (rv<0) {
1963  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1964  GWEN_Buffer_free(srcbuf);
1965  GWEN_Buffer_free(tbuf);
1966  return rv;
1967  }
1968  GWEN_Buffer_AppendString(tbuf, "\n");
1969  GWEN_Buffer_free(srcbuf);
1970  }
1971  GWEN_Buffer_AppendString(tbuf, " }\n");
1972  }
1973 
1974  /* read form object */
1975  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE) {
1976  GWEN_BUFFER *dstbuf;
1977  int rv;
1978 
1979  /* volatile */
1980  GWEN_Buffer_AppendString(tbuf, " /* member \"");
1981  s=Typemaker2_Member_GetName(tm);
1982  GWEN_Buffer_AppendString(tbuf, s);
1983  GWEN_Buffer_AppendString(tbuf, "\" is volatile, just presetting */\n");
1984 
1985  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
1986  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
1987  s=Typemaker2_Member_GetName(tm);
1988  GWEN_Buffer_AppendString(dstbuf, s);
1989 
1990  GWEN_Buffer_AppendString(tbuf, " ");
1991  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
1992  NULL, /* no source */
1993  GWEN_Buffer_GetStart(dstbuf),
1994  tbuf);
1995  if (rv<0) {
1996  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1997  GWEN_Buffer_free(dstbuf);
1998  GWEN_Buffer_free(tbuf);
1999  return rv;
2000  }
2001  GWEN_Buffer_AppendString(tbuf, "\n");
2002  GWEN_Buffer_free(dstbuf);
2003  }
2004  else {
2005  /* not volatile */
2006  if (1) { /* from object */
2007  GWEN_BUFFER *dstbuf;
2008  int rv;
2009 
2010  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2011  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2012  s=Typemaker2_Member_GetName(tm);
2013  GWEN_Buffer_AppendString(dstbuf, s);
2014 
2015  GWEN_Buffer_AppendString(tbuf, " ");
2016  rv=Typemaker2_Builder_Invoke_FromDbFn(tb, ty, tm,
2017  NULL, /* no source */
2018  GWEN_Buffer_GetStart(dstbuf),
2019  tbuf);
2020  if (rv<0) {
2021  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2022  GWEN_Buffer_free(dstbuf);
2023  GWEN_Buffer_free(tbuf);
2024  return rv;
2025  }
2026  GWEN_Buffer_free(dstbuf);
2027  GWEN_Buffer_AppendString(tbuf, "\n");
2028  }
2029 
2030  /* add preset code for the case when a pointer is NULL */
2031  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
2032  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
2033  s=Typemaker2_Member_GetName(tm);
2034  GWEN_Buffer_AppendString(tbuf, s);
2035  GWEN_Buffer_AppendString(tbuf, "==NULL) {");
2036 
2037  if (1) {
2038  GWEN_BUFFER *dstbuf;
2039  int rv;
2040 
2041  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2042  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2043  s=Typemaker2_Member_GetName(tm);
2044  GWEN_Buffer_AppendString(dstbuf, s);
2045 
2046  GWEN_Buffer_AppendString(tbuf, " ");
2047  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
2048  NULL, /* no source */
2049  GWEN_Buffer_GetStart(dstbuf),
2050  tbuf);
2051  if (rv<0) {
2052  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2053  GWEN_Buffer_free(dstbuf);
2054  GWEN_Buffer_free(tbuf);
2055  return rv;
2056  }
2057  GWEN_Buffer_AppendString(tbuf, "\n");
2058  GWEN_Buffer_free(dstbuf);
2059  }
2060 
2061  GWEN_Buffer_AppendString(tbuf, " }\n");
2062  }
2063  }
2064  GWEN_Buffer_AppendString(tbuf, "\n");
2065 
2066  tm=Typemaker2_Member_List_Next(tm);
2067  }
2068  }
2069 
2070  GWEN_Buffer_AppendString(tbuf, "}\n");
2071 
2072  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2073  GWEN_Buffer_free(tbuf);
2074 
2075  return 0;
2076 }
2077 
2078 
2079 
2080 static int _buildWriteDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2081 {
2082  GWEN_BUFFER *tbuf;
2083  const char *s;
2084  TYPEMAKER2_MEMBER_LIST *tml;
2085  /* uint32_t flags; */
2086  TYPEMAKER2_TYPEMANAGER *tym;
2087 
2088  tym=Typemaker2_Builder_GetTypeManager(tb);
2089  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2090 
2091  /* flags=Typemaker2_Type_GetFlags(ty); */
2092 
2093  /* prototype */
2094  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2095  if (s) {
2096  GWEN_Buffer_AppendString(tbuf, s);
2097  GWEN_Buffer_AppendString(tbuf, " ");
2098  }
2099  GWEN_Buffer_AppendString(tbuf, "int ");
2100  s=Typemaker2_Type_GetPrefix(ty);
2101  GWEN_Buffer_AppendString(tbuf, s);
2102  GWEN_Buffer_AppendString(tbuf, "_WriteDb(const ");
2103  s=Typemaker2_Type_GetIdentifier(ty);
2104  GWEN_Buffer_AppendString(tbuf, s);
2105  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db);\n");
2106  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2107  GWEN_Buffer_Reset(tbuf);
2108 
2109  /* implementation */
2110  GWEN_Buffer_AppendString(tbuf, "int ");
2111  s=Typemaker2_Type_GetPrefix(ty);
2112  GWEN_Buffer_AppendString(tbuf, s);
2113  GWEN_Buffer_AppendString(tbuf, "_WriteDb(const ");
2114  s=Typemaker2_Type_GetIdentifier(ty);
2115  GWEN_Buffer_AppendString(tbuf, s);
2116  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db) {\n");
2117 
2118  if (Typemaker2_Type_GetNonVolatileMemberCount(ty)) {
2119  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
2120  GWEN_Buffer_AppendString(tbuf, "\n");
2121  }
2122  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
2123 
2124  tml=Typemaker2_Type_GetMembers(ty);
2125  if (tml) {
2126  TYPEMAKER2_MEMBER *tm;
2127 
2128  tm=Typemaker2_Member_List_First(tml);
2129  while (tm) {
2130  TYPEMAKER2_TYPE *mty;
2131 
2132  mty=Typemaker2_Member_GetTypePtr(tm);
2133  assert(mty);
2134 
2135  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)) {
2136  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2137  s=Typemaker2_Member_GetName(tm);
2138  GWEN_Buffer_AppendString(tbuf, s);
2139  GWEN_Buffer_AppendString(tbuf, "\" */\n");
2140 
2141  /* toDb */
2142  if (1) {
2143  GWEN_BUFFER *srcbuf;
2144  int rv;
2145 
2146  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
2147  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
2148  s=Typemaker2_Member_GetName(tm);
2149  GWEN_Buffer_AppendString(srcbuf, s);
2150 
2151  GWEN_Buffer_AppendString(tbuf, " ");
2152  rv=Typemaker2_Builder_Invoke_ToDbFn(tb, ty, tm,
2153  GWEN_Buffer_GetStart(srcbuf),
2154  NULL, /* no dest */
2155  tbuf);
2156  if (rv<0) {
2157  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2158  GWEN_Buffer_free(srcbuf);
2159  GWEN_Buffer_free(tbuf);
2160  return rv;
2161  }
2162  GWEN_Buffer_AppendString(tbuf, "\n");
2163  GWEN_Buffer_free(srcbuf);
2164  }
2165 
2166  GWEN_Buffer_AppendString(tbuf, " if (p_rv<0) {\n");
2167  GWEN_Buffer_AppendString(tbuf, " DBG_INFO(GWEN_LOGDOMAIN, \"here (%d)\\n\", p_rv);\n");
2168  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
2169  GWEN_Buffer_AppendString(tbuf, " }\n");
2170 
2171  }
2172  else {
2173  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2174  s=Typemaker2_Member_GetName(tm);
2175  GWEN_Buffer_AppendString(tbuf, s);
2176  GWEN_Buffer_AppendString(tbuf, "\" is volatile, not writing to db */\n");
2177  }
2178  GWEN_Buffer_AppendString(tbuf, "\n");
2179 
2180  tm=Typemaker2_Member_List_Next(tm);
2181  }
2182  }
2183 
2184  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
2185  GWEN_Buffer_AppendString(tbuf, "}\n");
2186 
2187  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2188  GWEN_Buffer_free(tbuf);
2189 
2190  return 0;
2191 }
2192 
2193 
2194 
2195 static int _buildToDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2196 {
2197  GWEN_BUFFER *tbuf;
2198  const char *s;
2199  /* uint32_t flags; */
2200  TYPEMAKER2_TYPEMANAGER *tym;
2201 
2202  tym=Typemaker2_Builder_GetTypeManager(tb);
2203  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2204 
2205  /* flags=Typemaker2_Type_GetFlags(ty); */
2206 
2207  /* prototype */
2208  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2209  if (s) {
2210  GWEN_Buffer_AppendString(tbuf, s);
2211  GWEN_Buffer_AppendString(tbuf, " ");
2212  }
2213  GWEN_Buffer_AppendString(tbuf, "int ");
2214  s=Typemaker2_Type_GetPrefix(ty);
2215  GWEN_Buffer_AppendString(tbuf, s);
2216  GWEN_Buffer_AppendString(tbuf, "_toDb(const ");
2217  s=Typemaker2_Type_GetIdentifier(ty);
2218  GWEN_Buffer_AppendString(tbuf, s);
2219  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db);\n");
2220  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2221  GWEN_Buffer_Reset(tbuf);
2222 
2223  /* implementation */
2224  GWEN_Buffer_AppendString(tbuf, "int ");
2225  s=Typemaker2_Type_GetPrefix(ty);
2226  GWEN_Buffer_AppendString(tbuf, s);
2227  GWEN_Buffer_AppendString(tbuf, "_toDb(const ");
2228  s=Typemaker2_Type_GetIdentifier(ty);
2229  GWEN_Buffer_AppendString(tbuf, s);
2230  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_DB_NODE *p_db) {\n");
2231 
2232  GWEN_Buffer_AppendString(tbuf, " return ");
2233  s=Typemaker2_Type_GetPrefix(ty);
2234  GWEN_Buffer_AppendString(tbuf, s);
2235  GWEN_Buffer_AppendString(tbuf, "_WriteDb(p_struct, p_db);\n");
2236  GWEN_Buffer_AppendString(tbuf, "}\n");
2237 
2238  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2239  GWEN_Buffer_free(tbuf);
2240 
2241  return 0;
2242 }
2243 
2244 
2245 
2246 static int _buildFromDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2247 {
2248  GWEN_BUFFER *tbuf;
2249  const char *s;
2250  /* uint32_t flags; */
2251  TYPEMAKER2_TYPEMANAGER *tym;
2252 
2253  tym=Typemaker2_Builder_GetTypeManager(tb);
2254  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2255 
2256  /* flags=Typemaker2_Type_GetFlags(ty); */
2257 
2258  /* prototype */
2259  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2260  if (s) {
2261  GWEN_Buffer_AppendString(tbuf, s);
2262  GWEN_Buffer_AppendString(tbuf, " ");
2263  }
2264  s=Typemaker2_Type_GetIdentifier(ty);
2265  GWEN_Buffer_AppendString(tbuf, s);
2266  GWEN_Buffer_AppendString(tbuf, " *");
2267  s=Typemaker2_Type_GetPrefix(ty);
2268  GWEN_Buffer_AppendString(tbuf, s);
2269  GWEN_Buffer_AppendString(tbuf, "_fromDb(GWEN_DB_NODE *p_db);\n");
2270  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2271  GWEN_Buffer_Reset(tbuf);
2272 
2273  /* implementation */
2274  s=Typemaker2_Type_GetIdentifier(ty);
2275  GWEN_Buffer_AppendString(tbuf, s);
2276  GWEN_Buffer_AppendString(tbuf, " *");
2277  s=Typemaker2_Type_GetPrefix(ty);
2278  GWEN_Buffer_AppendString(tbuf, s);
2279  GWEN_Buffer_AppendString(tbuf, "_fromDb(GWEN_DB_NODE *p_db) {\n");
2280 
2281  GWEN_Buffer_AppendString(tbuf, " ");
2282  s=Typemaker2_Type_GetIdentifier(ty);
2283  GWEN_Buffer_AppendString(tbuf, s);
2284  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
2285 
2286  GWEN_Buffer_AppendString(tbuf, " p_struct=");
2287  s=Typemaker2_Type_GetPrefix(ty);
2288  GWEN_Buffer_AppendString(tbuf, s);
2289  if (Typemaker2_Type_GetUsePrivateConstructor(ty)) {
2290  GWEN_Buffer_AppendByte(tbuf, '_');
2291  }
2292  GWEN_Buffer_AppendString(tbuf, "_new();\n");
2293 
2294  GWEN_Buffer_AppendString(tbuf, " ");
2295  s=Typemaker2_Type_GetPrefix(ty);
2296  GWEN_Buffer_AppendString(tbuf, s);
2297  GWEN_Buffer_AppendString(tbuf, "_ReadDb(p_struct, p_db);\n");
2298 
2299  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
2300  GWEN_Buffer_AppendString(tbuf, "}\n");
2301 
2302  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2303  GWEN_Buffer_free(tbuf);
2304 
2305  return 0;
2306 }
2307 
2308 
2309 
2310 static int _buildReadXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2311 {
2312  GWEN_BUFFER *tbuf;
2313  const char *s;
2314  TYPEMAKER2_MEMBER_LIST *tml;
2315  /* uint32_t flags; */
2316  TYPEMAKER2_TYPEMANAGER *tym;
2317 
2318  tym=Typemaker2_Builder_GetTypeManager(tb);
2319  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2320 
2321  /* flags=Typemaker2_Type_GetFlags(ty); */
2322 
2323  /* prototype */
2324  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2325  if (s) {
2326  GWEN_Buffer_AppendString(tbuf, s);
2327  GWEN_Buffer_AppendString(tbuf, " ");
2328  }
2329  GWEN_Buffer_AppendString(tbuf, "void ");
2330  s=Typemaker2_Type_GetPrefix(ty);
2331  GWEN_Buffer_AppendString(tbuf, s);
2332  GWEN_Buffer_AppendString(tbuf, "_ReadXml(");
2333  s=Typemaker2_Type_GetIdentifier(ty);
2334  GWEN_Buffer_AppendString(tbuf, s);
2335  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db);\n");
2336  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2337  GWEN_Buffer_Reset(tbuf);
2338 
2339  /* implementation */
2340  GWEN_Buffer_AppendString(tbuf, "void ");
2341  s=Typemaker2_Type_GetPrefix(ty);
2342  GWEN_Buffer_AppendString(tbuf, s);
2343  GWEN_Buffer_AppendString(tbuf, "_ReadXml(");
2344  s=Typemaker2_Type_GetIdentifier(ty);
2345  GWEN_Buffer_AppendString(tbuf, s);
2346  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db) {\n");
2347 
2348  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
2349 
2350  tml=Typemaker2_Type_GetMembers(ty);
2351  if (tml) {
2352  TYPEMAKER2_MEMBER *tm;
2353 
2354  tm=Typemaker2_Member_List_First(tml);
2355  while (tm) {
2356  TYPEMAKER2_TYPE *mty;
2357 
2358  mty=Typemaker2_Member_GetTypePtr(tm);
2359  assert(mty);
2360 
2361  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2362  s=Typemaker2_Member_GetName(tm);
2363  GWEN_Buffer_AppendString(tbuf, s);
2364  GWEN_Buffer_AppendString(tbuf, "\" */\n");
2365 
2366  /* release previous value */
2367  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer &&
2368  (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN)) {
2369  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
2370  s=Typemaker2_Member_GetName(tm);
2371  GWEN_Buffer_AppendString(tbuf, s);
2372  GWEN_Buffer_AppendString(tbuf, ") {\n");
2373 
2374  /* free */
2375  if (1) {
2376  GWEN_BUFFER *srcbuf;
2377  int rv;
2378 
2379  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
2380  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
2381  s=Typemaker2_Member_GetName(tm);
2382  GWEN_Buffer_AppendString(srcbuf, s);
2383 
2384  GWEN_Buffer_AppendString(tbuf, " ");
2385  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
2386  GWEN_Buffer_GetStart(srcbuf),
2387  NULL, /* no dest */
2388  tbuf);
2389  if (rv<0) {
2390  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2391  GWEN_Buffer_free(srcbuf);
2392  GWEN_Buffer_free(tbuf);
2393  return rv;
2394  }
2395  GWEN_Buffer_AppendString(tbuf, "\n");
2396  GWEN_Buffer_free(srcbuf);
2397  }
2398  GWEN_Buffer_AppendString(tbuf, " }\n");
2399  }
2400 
2401  /* read form object */
2402  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE) {
2403  GWEN_BUFFER *dstbuf;
2404  int rv;
2405 
2406  /* volatile */
2407  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2408  s=Typemaker2_Member_GetName(tm);
2409  GWEN_Buffer_AppendString(tbuf, s);
2410  GWEN_Buffer_AppendString(tbuf, "\" is volatile, just presetting */\n");
2411 
2412  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2413  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2414  s=Typemaker2_Member_GetName(tm);
2415  GWEN_Buffer_AppendString(dstbuf, s);
2416 
2417  GWEN_Buffer_AppendString(tbuf, " ");
2418  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
2419  NULL, /* no source */
2420  GWEN_Buffer_GetStart(dstbuf),
2421  tbuf);
2422  if (rv<0) {
2423  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2424  GWEN_Buffer_free(dstbuf);
2425  GWEN_Buffer_free(tbuf);
2426  return rv;
2427  }
2428  GWEN_Buffer_AppendString(tbuf, "\n");
2429  GWEN_Buffer_free(dstbuf);
2430  }
2431  else {
2432  /* not volatile */
2433  if (1) { /* from object */
2434  GWEN_BUFFER *dstbuf;
2435  int rv;
2436 
2437  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2438  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2439  s=Typemaker2_Member_GetName(tm);
2440  GWEN_Buffer_AppendString(dstbuf, s);
2441 
2442  GWEN_Buffer_AppendString(tbuf, " ");
2443  rv=Typemaker2_Builder_Invoke_FromXmlFn(tb, ty, tm,
2444  NULL, /* no source */
2445  GWEN_Buffer_GetStart(dstbuf),
2446  tbuf);
2447  if (rv<0) {
2448  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2449  GWEN_Buffer_free(dstbuf);
2450  GWEN_Buffer_free(tbuf);
2451  return rv;
2452  }
2453  GWEN_Buffer_free(dstbuf);
2454  GWEN_Buffer_AppendString(tbuf, "\n");
2455  }
2456 
2457  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
2458  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
2459  s=Typemaker2_Member_GetName(tm);
2460  GWEN_Buffer_AppendString(tbuf, s);
2461  GWEN_Buffer_AppendString(tbuf, "==NULL) {");
2462 
2463  if (1) {
2464  GWEN_BUFFER *dstbuf;
2465  int rv;
2466 
2467  /* preset */
2468  GWEN_Buffer_AppendString(tbuf, " /* preset member \"");
2469  s=Typemaker2_Member_GetName(tm);
2470  GWEN_Buffer_AppendString(tbuf, s);
2471  GWEN_Buffer_AppendString(tbuf, "\" if empty */\n");
2472 
2473  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2474  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2475  s=Typemaker2_Member_GetName(tm);
2476  GWEN_Buffer_AppendString(dstbuf, s);
2477 
2478  GWEN_Buffer_AppendString(tbuf, " ");
2479  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
2480  NULL, /* no source */
2481  GWEN_Buffer_GetStart(dstbuf),
2482  tbuf);
2483  if (rv<0) {
2484  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2485  GWEN_Buffer_free(dstbuf);
2486  GWEN_Buffer_free(tbuf);
2487  return rv;
2488  }
2489  GWEN_Buffer_AppendString(tbuf, "\n");
2490  GWEN_Buffer_free(dstbuf);
2491  }
2492 
2493  GWEN_Buffer_AppendString(tbuf, " }\n");
2494  }
2495  }
2496  GWEN_Buffer_AppendString(tbuf, "\n");
2497 
2498  tm=Typemaker2_Member_List_Next(tm);
2499  }
2500  }
2501 
2502  GWEN_Buffer_AppendString(tbuf, "}\n");
2503 
2504  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2505  GWEN_Buffer_free(tbuf);
2506 
2507  return 0;
2508 }
2509 
2510 
2511 
2512 static int _buildWriteXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2513 {
2514  GWEN_BUFFER *tbuf;
2515  const char *s;
2516  TYPEMAKER2_MEMBER_LIST *tml;
2517  /* uint32_t flags; */
2518  TYPEMAKER2_TYPEMANAGER *tym;
2519 
2520  tym=Typemaker2_Builder_GetTypeManager(tb);
2521  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2522 
2523  /* flags=Typemaker2_Type_GetFlags(ty); */
2524 
2525  /* prototype */
2526  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2527  if (s) {
2528  GWEN_Buffer_AppendString(tbuf, s);
2529  GWEN_Buffer_AppendString(tbuf, " ");
2530  }
2531  GWEN_Buffer_AppendString(tbuf, "void ");
2532  s=Typemaker2_Type_GetPrefix(ty);
2533  GWEN_Buffer_AppendString(tbuf, s);
2534  GWEN_Buffer_AppendString(tbuf, "_WriteXml(const ");
2535  s=Typemaker2_Type_GetIdentifier(ty);
2536  GWEN_Buffer_AppendString(tbuf, s);
2537  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db);\n");
2538  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2539  GWEN_Buffer_Reset(tbuf);
2540 
2541  /* implementation */
2542  GWEN_Buffer_AppendString(tbuf, "void ");
2543  s=Typemaker2_Type_GetPrefix(ty);
2544  GWEN_Buffer_AppendString(tbuf, s);
2545  GWEN_Buffer_AppendString(tbuf, "_WriteXml(const ");
2546  s=Typemaker2_Type_GetIdentifier(ty);
2547  GWEN_Buffer_AppendString(tbuf, s);
2548  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db) {\n");
2549 
2550  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
2551 
2552  tml=Typemaker2_Type_GetMembers(ty);
2553  if (tml) {
2554  TYPEMAKER2_MEMBER *tm;
2555 
2556  tm=Typemaker2_Member_List_First(tml);
2557  while (tm) {
2558  TYPEMAKER2_TYPE *mty;
2559 
2560  mty=Typemaker2_Member_GetTypePtr(tm);
2561  assert(mty);
2562 
2563  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)) {
2564  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2565  s=Typemaker2_Member_GetName(tm);
2566  GWEN_Buffer_AppendString(tbuf, s);
2567  GWEN_Buffer_AppendString(tbuf, "\" */\n");
2568 
2569  /* toXml */
2570  if (1) {
2571  GWEN_BUFFER *srcbuf;
2572  int rv;
2573 
2574  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
2575  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
2576  s=Typemaker2_Member_GetName(tm);
2577  GWEN_Buffer_AppendString(srcbuf, s);
2578 
2579  GWEN_Buffer_AppendString(tbuf, " ");
2580  rv=Typemaker2_Builder_Invoke_ToXmlFn(tb, ty, tm,
2581  GWEN_Buffer_GetStart(srcbuf),
2582  NULL, /* no dest */
2583  tbuf);
2584  if (rv<0) {
2585  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2586  GWEN_Buffer_free(srcbuf);
2587  GWEN_Buffer_free(tbuf);
2588  return rv;
2589  }
2590  GWEN_Buffer_AppendString(tbuf, "\n");
2591  GWEN_Buffer_free(srcbuf);
2592  }
2593 
2594  }
2595  else {
2596  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2597  s=Typemaker2_Member_GetName(tm);
2598  GWEN_Buffer_AppendString(tbuf, s);
2599  GWEN_Buffer_AppendString(tbuf, "\" is volatile, not writing to xml */\n");
2600  }
2601  GWEN_Buffer_AppendString(tbuf, "\n");
2602 
2603  tm=Typemaker2_Member_List_Next(tm);
2604  }
2605  }
2606 
2607  GWEN_Buffer_AppendString(tbuf, "}\n");
2608 
2609  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2610  GWEN_Buffer_free(tbuf);
2611 
2612  return 0;
2613 }
2614 
2615 
2616 
2617 static int _buildToXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2618 {
2619  GWEN_BUFFER *tbuf;
2620  const char *s;
2621  /* uint32_t flags; */
2622  TYPEMAKER2_TYPEMANAGER *tym;
2623 
2624  tym=Typemaker2_Builder_GetTypeManager(tb);
2625  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2626 
2627  /* flags=Typemaker2_Type_GetFlags(ty); */
2628 
2629  /* prototype */
2630  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2631  if (s) {
2632  GWEN_Buffer_AppendString(tbuf, s);
2633  GWEN_Buffer_AppendString(tbuf, " ");
2634  }
2635  GWEN_Buffer_AppendString(tbuf, "void ");
2636  s=Typemaker2_Type_GetPrefix(ty);
2637  GWEN_Buffer_AppendString(tbuf, s);
2638  GWEN_Buffer_AppendString(tbuf, "_toXml(const ");
2639  s=Typemaker2_Type_GetIdentifier(ty);
2640  GWEN_Buffer_AppendString(tbuf, s);
2641  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db);\n");
2642  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2643  GWEN_Buffer_Reset(tbuf);
2644 
2645  /* implementation */
2646  GWEN_Buffer_AppendString(tbuf, "void ");
2647  s=Typemaker2_Type_GetPrefix(ty);
2648  GWEN_Buffer_AppendString(tbuf, s);
2649  GWEN_Buffer_AppendString(tbuf, "_toXml(const ");
2650  s=Typemaker2_Type_GetIdentifier(ty);
2651  GWEN_Buffer_AppendString(tbuf, s);
2652  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_XMLNODE *p_db) {\n");
2653 
2654  GWEN_Buffer_AppendString(tbuf, " ");
2655  s=Typemaker2_Type_GetPrefix(ty);
2656  GWEN_Buffer_AppendString(tbuf, s);
2657  GWEN_Buffer_AppendString(tbuf, "_WriteXml(p_struct, p_db);\n");
2658  GWEN_Buffer_AppendString(tbuf, "}\n");
2659 
2660  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2661  GWEN_Buffer_free(tbuf);
2662 
2663  return 0;
2664 }
2665 
2666 
2667 
2668 static int _buildFromXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2669 {
2670  GWEN_BUFFER *tbuf;
2671  const char *s;
2672  /* uint32_t flags; */
2673  TYPEMAKER2_TYPEMANAGER *tym;
2674 
2675  tym=Typemaker2_Builder_GetTypeManager(tb);
2676  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2677 
2678  /* flags=Typemaker2_Type_GetFlags(ty); */
2679 
2680  /* prototype */
2681  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2682  if (s) {
2683  GWEN_Buffer_AppendString(tbuf, s);
2684  GWEN_Buffer_AppendString(tbuf, " ");
2685  }
2686  s=Typemaker2_Type_GetIdentifier(ty);
2687  GWEN_Buffer_AppendString(tbuf, s);
2688  GWEN_Buffer_AppendString(tbuf, " *");
2689  s=Typemaker2_Type_GetPrefix(ty);
2690  GWEN_Buffer_AppendString(tbuf, s);
2691  GWEN_Buffer_AppendString(tbuf, "_fromXml(GWEN_XMLNODE *p_db);\n");
2692  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2693  GWEN_Buffer_Reset(tbuf);
2694 
2695  /* implementation */
2696  s=Typemaker2_Type_GetIdentifier(ty);
2697  GWEN_Buffer_AppendString(tbuf, s);
2698  GWEN_Buffer_AppendString(tbuf, " *");
2699  s=Typemaker2_Type_GetPrefix(ty);
2700  GWEN_Buffer_AppendString(tbuf, s);
2701  GWEN_Buffer_AppendString(tbuf, "_fromXml(GWEN_XMLNODE *p_db) {\n");
2702 
2703  GWEN_Buffer_AppendString(tbuf, " ");
2704  s=Typemaker2_Type_GetIdentifier(ty);
2705  GWEN_Buffer_AppendString(tbuf, s);
2706  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
2707 
2708  GWEN_Buffer_AppendString(tbuf, " p_struct=");
2709  s=Typemaker2_Type_GetPrefix(ty);
2710  GWEN_Buffer_AppendString(tbuf, s);
2711  if (Typemaker2_Type_GetUsePrivateConstructor(ty)) {
2712  GWEN_Buffer_AppendByte(tbuf, '_');
2713  }
2714  GWEN_Buffer_AppendString(tbuf, "_new();\n");
2715 
2716  GWEN_Buffer_AppendString(tbuf, " ");
2717  s=Typemaker2_Type_GetPrefix(ty);
2718  GWEN_Buffer_AppendString(tbuf, s);
2719  GWEN_Buffer_AppendString(tbuf, "_ReadXml(p_struct, p_db);\n");
2720 
2721  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
2722  GWEN_Buffer_AppendString(tbuf, "}\n");
2723 
2724  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2725  GWEN_Buffer_free(tbuf);
2726 
2727  return 0;
2728 }
2729 
2730 
2731 
2732 static int _buildReadObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2733 {
2734  GWEN_BUFFER *tbuf;
2735  const char *s;
2736  TYPEMAKER2_MEMBER_LIST *tml;
2737  /* uint32_t flags; */
2738  TYPEMAKER2_TYPEMANAGER *tym;
2739 
2740  tym=Typemaker2_Builder_GetTypeManager(tb);
2741  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2742 
2743  /* flags=Typemaker2_Type_GetFlags(ty); */
2744 
2745  /* prototype */
2746  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2747  if (s) {
2748  GWEN_Buffer_AppendString(tbuf, s);
2749  GWEN_Buffer_AppendString(tbuf, " ");
2750  }
2751  GWEN_Buffer_AppendString(tbuf, "int ");
2752  s=Typemaker2_Type_GetPrefix(ty);
2753  GWEN_Buffer_AppendString(tbuf, s);
2754  GWEN_Buffer_AppendString(tbuf, "_ReadObject(");
2755  s=Typemaker2_Type_GetIdentifier(ty);
2756  GWEN_Buffer_AppendString(tbuf, s);
2757  GWEN_Buffer_AppendString(tbuf, " *p_struct, const AQDB_OBJECT *p_db);\n");
2758  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2759  GWEN_Buffer_Reset(tbuf);
2760 
2761  /* implementation */
2762  GWEN_Buffer_AppendString(tbuf, "int ");
2763  s=Typemaker2_Type_GetPrefix(ty);
2764  GWEN_Buffer_AppendString(tbuf, s);
2765  GWEN_Buffer_AppendString(tbuf, "_ReadObject(");
2766  s=Typemaker2_Type_GetIdentifier(ty);
2767  GWEN_Buffer_AppendString(tbuf, s);
2768  GWEN_Buffer_AppendString(tbuf, " *p_struct, const AQDB_OBJECT *p_db) {\n");
2769 
2770  if (Typemaker2_Type_GetNonVolatileMemberCount(ty)) {
2771  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
2772  GWEN_Buffer_AppendString(tbuf, "\n");
2773  }
2774  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
2775 
2776  tml=Typemaker2_Type_GetMembers(ty);
2777  if (tml) {
2778  TYPEMAKER2_MEMBER *tm;
2779 
2780  tm=Typemaker2_Member_List_First(tml);
2781  while (tm) {
2782  TYPEMAKER2_TYPE *mty;
2783 
2784  mty=Typemaker2_Member_GetTypePtr(tm);
2785  assert(mty);
2786 
2787  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2788  s=Typemaker2_Member_GetName(tm);
2789  GWEN_Buffer_AppendString(tbuf, s);
2790  GWEN_Buffer_AppendString(tbuf, "\" */\n");
2791 
2792  /* release previous value */
2793  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer &&
2794  (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN)) {
2795  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
2796  s=Typemaker2_Member_GetName(tm);
2797  GWEN_Buffer_AppendString(tbuf, s);
2798  GWEN_Buffer_AppendString(tbuf, ") {\n");
2799 
2800  /* free */
2801  if (1) {
2802  GWEN_BUFFER *srcbuf;
2803  int rv;
2804 
2805  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
2806  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
2807  s=Typemaker2_Member_GetName(tm);
2808  GWEN_Buffer_AppendString(srcbuf, s);
2809 
2810  GWEN_Buffer_AppendString(tbuf, " ");
2811  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
2812  GWEN_Buffer_GetStart(srcbuf),
2813  NULL, /* no dest */
2814  tbuf);
2815  if (rv<0) {
2816  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2817  GWEN_Buffer_free(srcbuf);
2818  GWEN_Buffer_free(tbuf);
2819  return rv;
2820  }
2821  GWEN_Buffer_AppendString(tbuf, "\n");
2822  GWEN_Buffer_free(srcbuf);
2823  }
2824  GWEN_Buffer_AppendString(tbuf, " }\n");
2825  }
2826 
2827  /* read form object */
2828  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE) {
2829  GWEN_BUFFER *dstbuf;
2830  int rv;
2831 
2832  /* volatile */
2833  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2834  s=Typemaker2_Member_GetName(tm);
2835  GWEN_Buffer_AppendString(tbuf, s);
2836  GWEN_Buffer_AppendString(tbuf, "\" is volatile, just presetting */\n");
2837 
2838  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2839  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2840  s=Typemaker2_Member_GetName(tm);
2841  GWEN_Buffer_AppendString(dstbuf, s);
2842 
2843  GWEN_Buffer_AppendString(tbuf, " ");
2844  rv=Typemaker2_Builder_Invoke_ConstructFn(tb, ty, tm,
2845  NULL, /* no source */
2846  GWEN_Buffer_GetStart(dstbuf),
2847  tbuf);
2848  if (rv<0) {
2849  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2850  GWEN_Buffer_free(dstbuf);
2851  GWEN_Buffer_free(tbuf);
2852  return rv;
2853  }
2854  GWEN_Buffer_AppendString(tbuf, "\n");
2855  GWEN_Buffer_free(dstbuf);
2856  }
2857  else {
2858  /* not volatile */
2859  if (1) { /* from object */
2860  GWEN_BUFFER *dstbuf;
2861  int rv;
2862 
2863  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
2864  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
2865  s=Typemaker2_Member_GetName(tm);
2866  GWEN_Buffer_AppendString(dstbuf, s);
2867 
2868  GWEN_Buffer_AppendString(tbuf, " ");
2869  rv=Typemaker2_Builder_Invoke_FromObjectFn(tb, ty, tm,
2870  NULL, /* no source */
2871  GWEN_Buffer_GetStart(dstbuf),
2872  tbuf);
2873  if (rv<0) {
2874  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2875  GWEN_Buffer_free(dstbuf);
2876  GWEN_Buffer_free(tbuf);
2877  return rv;
2878  }
2879  GWEN_Buffer_free(dstbuf);
2880  GWEN_Buffer_AppendString(tbuf, "\n");
2881  }
2882 
2883  GWEN_Buffer_AppendString(tbuf, " if (p_rv<0) {\n");
2884  GWEN_Buffer_AppendString(tbuf, " DBG_INFO(GWEN_LOGDOMAIN, \"here (%d)\\n\", p_rv);\n");
2885  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
2886  GWEN_Buffer_AppendString(tbuf, " }\n");
2887  }
2888  GWEN_Buffer_AppendString(tbuf, "\n");
2889 
2890  tm=Typemaker2_Member_List_Next(tm);
2891  }
2892  }
2893 
2894  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
2895  GWEN_Buffer_AppendString(tbuf, "}\n");
2896 
2897  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
2898  GWEN_Buffer_free(tbuf);
2899 
2900  return 0;
2901 }
2902 
2903 
2904 
2905 static int _buildWriteObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
2906 {
2907  GWEN_BUFFER *tbuf;
2908  const char *s;
2909  TYPEMAKER2_MEMBER_LIST *tml;
2910  /* uint32_t flags; */
2911  TYPEMAKER2_TYPEMANAGER *tym;
2912 
2913  tym=Typemaker2_Builder_GetTypeManager(tb);
2914  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
2915 
2916  /* flags=Typemaker2_Type_GetFlags(ty); */
2917 
2918  /* prototype */
2919  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
2920  if (s) {
2921  GWEN_Buffer_AppendString(tbuf, s);
2922  GWEN_Buffer_AppendString(tbuf, " ");
2923  }
2924  GWEN_Buffer_AppendString(tbuf, "int ");
2925  s=Typemaker2_Type_GetPrefix(ty);
2926  GWEN_Buffer_AppendString(tbuf, s);
2927  GWEN_Buffer_AppendString(tbuf, "_WriteObject(const ");
2928  s=Typemaker2_Type_GetIdentifier(ty);
2929  GWEN_Buffer_AppendString(tbuf, s);
2930  GWEN_Buffer_AppendString(tbuf, " *p_struct, AQDB_OBJECT *p_db);\n");
2931  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
2932  GWEN_Buffer_Reset(tbuf);
2933 
2934  /* implementation */
2935  GWEN_Buffer_AppendString(tbuf, "int ");
2936  s=Typemaker2_Type_GetPrefix(ty);
2937  GWEN_Buffer_AppendString(tbuf, s);
2938  GWEN_Buffer_AppendString(tbuf, "_WriteObject(const ");
2939  s=Typemaker2_Type_GetIdentifier(ty);
2940  GWEN_Buffer_AppendString(tbuf, s);
2941  GWEN_Buffer_AppendString(tbuf, " *p_struct, AQDB_OBJECT *p_db) {\n");
2942 
2943  if (Typemaker2_Type_GetNonVolatileMemberCount(ty)) {
2944  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
2945  GWEN_Buffer_AppendString(tbuf, "\n");
2946  }
2947  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
2948 
2949  tml=Typemaker2_Type_GetMembers(ty);
2950  if (tml) {
2951  TYPEMAKER2_MEMBER *tm;
2952 
2953  tm=Typemaker2_Member_List_First(tml);
2954  while (tm) {
2955  TYPEMAKER2_TYPE *mty;
2956 
2957  mty=Typemaker2_Member_GetTypePtr(tm);
2958  assert(mty);
2959 
2960  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)) {
2961  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2962  s=Typemaker2_Member_GetName(tm);
2963  GWEN_Buffer_AppendString(tbuf, s);
2964  GWEN_Buffer_AppendString(tbuf, "\" */\n");
2965 
2966  /* toObject */
2967  if (1) {
2968  GWEN_BUFFER *srcbuf;
2969  int rv;
2970 
2971  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
2972  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
2973  s=Typemaker2_Member_GetName(tm);
2974  GWEN_Buffer_AppendString(srcbuf, s);
2975 
2976  GWEN_Buffer_AppendString(tbuf, " ");
2977  rv=Typemaker2_Builder_Invoke_ToObjectFn(tb, ty, tm,
2978  GWEN_Buffer_GetStart(srcbuf),
2979  NULL, /* no dest */
2980  tbuf);
2981  if (rv<0) {
2982  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
2983  GWEN_Buffer_free(srcbuf);
2984  GWEN_Buffer_free(tbuf);
2985  return rv;
2986  }
2987  GWEN_Buffer_AppendString(tbuf, "\n");
2988  GWEN_Buffer_free(srcbuf);
2989  }
2990 
2991  GWEN_Buffer_AppendString(tbuf, " if (p_rv<0) {\n");
2992  GWEN_Buffer_AppendString(tbuf, " DBG_INFO(GWEN_LOGDOMAIN, \"here (%d)\\n\", p_rv);\n");
2993  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
2994  GWEN_Buffer_AppendString(tbuf, " }\n");
2995 
2996  }
2997  else {
2998  GWEN_Buffer_AppendString(tbuf, " /* member \"");
2999  s=Typemaker2_Member_GetName(tm);
3000  GWEN_Buffer_AppendString(tbuf, s);
3001  GWEN_Buffer_AppendString(tbuf, "\" is volatile, not writing to object */\n");
3002  }
3003  GWEN_Buffer_AppendString(tbuf, "\n");
3004 
3005  tm=Typemaker2_Member_List_Next(tm);
3006  }
3007  }
3008 
3009  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
3010 
3011  GWEN_Buffer_AppendString(tbuf, "}\n");
3012 
3013  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3014  GWEN_Buffer_free(tbuf);
3015 
3016  return 0;
3017 }
3018 
3019 
3020 
3021 static int _buildToObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3022 {
3023  GWEN_BUFFER *tbuf;
3024  const char *s;
3025  /* uint32_t flags; */
3026  TYPEMAKER2_TYPEMANAGER *tym;
3027 
3028  tym=Typemaker2_Builder_GetTypeManager(tb);
3029  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3030 
3031  /* flags=Typemaker2_Type_GetFlags(ty); */
3032 
3033  /* prototype */
3034  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3035  if (s) {
3036  GWEN_Buffer_AppendString(tbuf, s);
3037  GWEN_Buffer_AppendString(tbuf, " ");
3038  }
3039  GWEN_Buffer_AppendString(tbuf, "int ");
3040  s=Typemaker2_Type_GetPrefix(ty);
3041  GWEN_Buffer_AppendString(tbuf, s);
3042  GWEN_Buffer_AppendString(tbuf, "_toObject(const ");
3043  s=Typemaker2_Type_GetIdentifier(ty);
3044  GWEN_Buffer_AppendString(tbuf, s);
3045  GWEN_Buffer_AppendString(tbuf, " *p_struct, AQDB_OBJECT *p_db);\n");
3046  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3047  GWEN_Buffer_Reset(tbuf);
3048 
3049  /* implementation */
3050  GWEN_Buffer_AppendString(tbuf, "int ");
3051  s=Typemaker2_Type_GetPrefix(ty);
3052  GWEN_Buffer_AppendString(tbuf, s);
3053  GWEN_Buffer_AppendString(tbuf, "_toObject(const ");
3054  s=Typemaker2_Type_GetIdentifier(ty);
3055  GWEN_Buffer_AppendString(tbuf, s);
3056  GWEN_Buffer_AppendString(tbuf, " *p_struct, AQDB_OBJECT *p_db) {\n");
3057 
3058  GWEN_Buffer_AppendString(tbuf, " return ");
3059  s=Typemaker2_Type_GetPrefix(ty);
3060  GWEN_Buffer_AppendString(tbuf, s);
3061  GWEN_Buffer_AppendString(tbuf, "_WriteObject(p_struct, p_db);\n");
3062  GWEN_Buffer_AppendString(tbuf, "}\n");
3063 
3064  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3065  GWEN_Buffer_free(tbuf);
3066 
3067  return 0;
3068 }
3069 
3070 
3071 
3072 static int _buildFromObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3073 {
3074  GWEN_BUFFER *tbuf;
3075  const char *s;
3076  /* uint32_t flags; */
3077  TYPEMAKER2_TYPEMANAGER *tym;
3078 
3079  tym=Typemaker2_Builder_GetTypeManager(tb);
3080  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3081 
3082  /* flags=Typemaker2_Type_GetFlags(ty); */
3083 
3084  /* prototype */
3085  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3086  if (s) {
3087  GWEN_Buffer_AppendString(tbuf, s);
3088  GWEN_Buffer_AppendString(tbuf, " ");
3089  }
3090  GWEN_Buffer_AppendString(tbuf, "int ");
3091  s=Typemaker2_Type_GetPrefix(ty);
3092  GWEN_Buffer_AppendString(tbuf, s);
3093  GWEN_Buffer_AppendString(tbuf, "_fromObject(const AQDB_OBJECT *p_db, ");
3094  s=Typemaker2_Type_GetIdentifier(ty);
3095  GWEN_Buffer_AppendString(tbuf, s);
3096  GWEN_Buffer_AppendString(tbuf, " **pp_struct);\n");
3097  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3098  GWEN_Buffer_Reset(tbuf);
3099 
3100  /* implementation */
3101  GWEN_Buffer_AppendString(tbuf, "int ");
3102  s=Typemaker2_Type_GetPrefix(ty);
3103  GWEN_Buffer_AppendString(tbuf, s);
3104  GWEN_Buffer_AppendString(tbuf, "_fromObject(const AQDB_OBJECT *p_db, ");
3105  s=Typemaker2_Type_GetIdentifier(ty);
3106  GWEN_Buffer_AppendString(tbuf, s);
3107  GWEN_Buffer_AppendString(tbuf, " **pp_struct) {\n");
3108 
3109  GWEN_Buffer_AppendString(tbuf, " ");
3110  s=Typemaker2_Type_GetIdentifier(ty);
3111  GWEN_Buffer_AppendString(tbuf, s);
3112  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
3113  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
3114 
3115  GWEN_Buffer_AppendString(tbuf, " p_struct=");
3116  s=Typemaker2_Type_GetPrefix(ty);
3117  GWEN_Buffer_AppendString(tbuf, s);
3118  if (Typemaker2_Type_GetUsePrivateConstructor(ty)) {
3119  GWEN_Buffer_AppendByte(tbuf, '_');
3120  }
3121  GWEN_Buffer_AppendString(tbuf, "_new();\n");
3122 
3123  GWEN_Buffer_AppendString(tbuf, " p_rv=");
3124  s=Typemaker2_Type_GetPrefix(ty);
3125  GWEN_Buffer_AppendString(tbuf, s);
3126  GWEN_Buffer_AppendString(tbuf, "_ReadObject(p_struct, p_db);\n");
3127 
3128  GWEN_Buffer_AppendString(tbuf, " if (p_rv<0) {\n");
3129  GWEN_Buffer_AppendString(tbuf, " DBG_INFO(GWEN_LOGDOMAIN, \"here (%d)\", p_rv);\n");
3130  GWEN_Buffer_AppendString(tbuf, " ");
3131  s=Typemaker2_Type_GetPrefix(ty);
3132  GWEN_Buffer_AppendString(tbuf, s);
3133  GWEN_Buffer_AppendString(tbuf, "_free(p_struct);\n");
3134  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
3135  GWEN_Buffer_AppendString(tbuf, " }\n");
3136 
3137  GWEN_Buffer_AppendString(tbuf, " *pp_struct=p_struct;\n");
3138  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
3139  GWEN_Buffer_AppendString(tbuf, "}\n");
3140 
3141  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3142  GWEN_Buffer_free(tbuf);
3143 
3144  return 0;
3145 }
3146 
3147 
3148 
3149 static int _buildCreateColumnList(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3150 {
3151  GWEN_BUFFER *tbuf;
3152  const char *s;
3153  TYPEMAKER2_MEMBER_LIST *tml;
3154  /* uint32_t flags; */
3155  TYPEMAKER2_TYPEMANAGER *tym;
3156 
3157  tym=Typemaker2_Builder_GetTypeManager(tb);
3158  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3159 
3160  /* flags=Typemaker2_Type_GetFlags(ty); */
3161 
3162  /* prototype */
3163  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3164  if (s) {
3165  GWEN_Buffer_AppendString(tbuf, s);
3166  GWEN_Buffer_AppendString(tbuf, " ");
3167  }
3168  GWEN_Buffer_AppendString(tbuf, "AQDB_COLUMN_LIST *");
3169  s=Typemaker2_Type_GetPrefix(ty);
3170  GWEN_Buffer_AppendString(tbuf, s);
3171  GWEN_Buffer_AppendString(tbuf, "_CreateColumnList();\n");
3172  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3173  GWEN_Buffer_Reset(tbuf);
3174 
3175  /* implementation */
3176  GWEN_Buffer_AppendString(tbuf, "AQDB_COLUMN_LIST *");
3177  s=Typemaker2_Type_GetPrefix(ty);
3178  GWEN_Buffer_AppendString(tbuf, s);
3179  GWEN_Buffer_AppendString(tbuf, "_CreateColumnList() {\n");
3180 
3181  if (Typemaker2_Type_GetNonVolatileMemberCount(ty)==0) {
3182  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
3183  }
3184  else {
3185  GWEN_Buffer_AppendString(tbuf, " AQDB_COLUMN_LIST *p_cl;\n");
3186  GWEN_Buffer_AppendString(tbuf, " AQDB_COLUMN *p_c;\n");
3187  GWEN_Buffer_AppendString(tbuf, "\n");
3188 
3189  GWEN_Buffer_AppendString(tbuf, " p_cl=AQDB_Column_List_new();\n");
3190  GWEN_Buffer_AppendString(tbuf, "\n");
3191 
3192  tml=Typemaker2_Type_GetMembers(ty);
3193  if (tml) {
3194  TYPEMAKER2_MEMBER *tm;
3195 
3196  tm=Typemaker2_Member_List_First(tml);
3197  while (tm) {
3198  TYPEMAKER2_TYPE *mty;
3199 
3200  mty=Typemaker2_Member_GetTypePtr(tm);
3201  assert(mty);
3202 
3203  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_VOLATILE)) {
3204  char numbuf[32];
3205  int l;
3206 
3207  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3208  s=Typemaker2_Member_GetName(tm);
3209  GWEN_Buffer_AppendString(tbuf, s);
3210  GWEN_Buffer_AppendString(tbuf, "\" */\n");
3211 
3212  GWEN_Buffer_AppendString(tbuf, " p_c=AQDB_Column_new(");
3213  s=Typemaker2_Type_GetAqDbType(mty);
3214  if (s && *s) {
3215  GWEN_Buffer_AppendString(tbuf, s);
3216  }
3217  else {
3218  DBG_ERROR(GWEN_LOGDOMAIN, "Type has no AQDB type element");
3219  GWEN_Buffer_free(tbuf);
3220  return GWEN_ERROR_BAD_DATA;
3221  }
3222 
3223  GWEN_Buffer_AppendString(tbuf, ", \"");
3224  s=Typemaker2_Member_GetName(tm);
3225  GWEN_Buffer_AppendString(tbuf, s);
3226  GWEN_Buffer_AppendString(tbuf, "\", ");
3227 
3228  l=Typemaker2_Member_GetMaxLen(tm);
3229  if (l==0) {
3230  DBG_ERROR(GWEN_LOGDOMAIN, "Member [%s] has no maxlen attribute",
3231  Typemaker2_Member_GetName(tm));
3232  GWEN_Buffer_free(tbuf);
3233  return GWEN_ERROR_BAD_DATA;
3234  }
3235  snprintf(numbuf, sizeof(numbuf)-1, "%d", l);
3236  numbuf[sizeof(numbuf)-1]=0;
3237  GWEN_Buffer_AppendString(tbuf, numbuf);
3238  GWEN_Buffer_AppendString(tbuf, ");\n");
3239  GWEN_Buffer_AppendString(tbuf, " AQDB_Column_List_Add(p_c, p_cl);\n");
3240  }
3241  else {
3242  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3243  s=Typemaker2_Member_GetName(tm);
3244  GWEN_Buffer_AppendString(tbuf, s);
3245  GWEN_Buffer_AppendString(tbuf, "\" is volatile, not adding to column list */\n");
3246  }
3247  GWEN_Buffer_AppendString(tbuf, "\n");
3248 
3249  tm=Typemaker2_Member_List_Next(tm);
3250  }
3251  }
3252  GWEN_Buffer_AppendString(tbuf, " return p_cl;\n");
3253  }
3254 
3255  GWEN_Buffer_AppendString(tbuf, "}\n");
3256 
3257  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3258  GWEN_Buffer_free(tbuf);
3259 
3260  return 0;
3261 }
3262 
3263 
3264 
3265 static int _buildDup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3266 {
3267  GWEN_BUFFER *tbuf;
3268  const char *s;
3269  TYPEMAKER2_MEMBER_LIST *tml;
3270  /* uint32_t flags; */
3271  TYPEMAKER2_TYPEMANAGER *tym;
3272 
3273  tym=Typemaker2_Builder_GetTypeManager(tb);
3274  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3275 
3276  /* flags=Typemaker2_Type_GetFlags(ty); */
3277 
3278  /* prototype */
3279  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3280  if (s) {
3281  GWEN_Buffer_AppendString(tbuf, s);
3282  GWEN_Buffer_AppendString(tbuf, " ");
3283  }
3284  s=Typemaker2_Type_GetIdentifier(ty);
3285  GWEN_Buffer_AppendString(tbuf, s);
3286  GWEN_Buffer_AppendString(tbuf, " *");
3287  s=Typemaker2_Type_GetPrefix(ty);
3288  GWEN_Buffer_AppendString(tbuf, s);
3289  GWEN_Buffer_AppendString(tbuf, "_dup(const ");
3290  s=Typemaker2_Type_GetIdentifier(ty);
3291  GWEN_Buffer_AppendString(tbuf, s);
3292  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
3293  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3294  GWEN_Buffer_Reset(tbuf);
3295 
3296  /* implementation */
3297  s=Typemaker2_Type_GetIdentifier(ty);
3298  GWEN_Buffer_AppendString(tbuf, s);
3299  GWEN_Buffer_AppendString(tbuf, " *");
3300  s=Typemaker2_Type_GetPrefix(ty);
3301  GWEN_Buffer_AppendString(tbuf, s);
3302  GWEN_Buffer_AppendString(tbuf, "_dup(const ");
3303  s=Typemaker2_Type_GetIdentifier(ty);
3304  GWEN_Buffer_AppendString(tbuf, s);
3305  GWEN_Buffer_AppendString(tbuf, " *p_src) {\n");
3306 
3307  GWEN_Buffer_AppendString(tbuf, " ");
3308  s=Typemaker2_Type_GetIdentifier(ty);
3309  GWEN_Buffer_AppendString(tbuf, s);
3310  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
3311  GWEN_Buffer_AppendString(tbuf, "\n");
3312 
3313  GWEN_Buffer_AppendString(tbuf, " assert(p_src);\n");
3314  GWEN_Buffer_AppendString(tbuf, " p_struct=");
3315  s=Typemaker2_Type_GetPrefix(ty);
3316  GWEN_Buffer_AppendString(tbuf, s);
3317  if (Typemaker2_Type_GetUsePrivateConstructor(ty)) {
3318  GWEN_Buffer_AppendByte(tbuf, '_');
3319  }
3320  GWEN_Buffer_AppendString(tbuf, "_new();\n");
3321 
3322  tml=Typemaker2_Type_GetMembers(ty);
3323  if (tml) {
3324  TYPEMAKER2_MEMBER *tm;
3325 
3326  tm=Typemaker2_Member_List_First(tml);
3327  while (tm) {
3328  TYPEMAKER2_TYPE *mty;
3329 
3330  mty=Typemaker2_Member_GetTypePtr(tm);
3331  assert(mty);
3332 
3333  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_NODUP)) {
3334  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3335  s=Typemaker2_Member_GetName(tm);
3336  GWEN_Buffer_AppendString(tbuf, s);
3337  GWEN_Buffer_AppendString(tbuf, "\" */\n");
3338 
3339  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
3340  if (Typemaker2_Member_GetDupFlags(tm) & TYPEMAKER2_FLAGS_ASSIGN) {
3341  /* assign */
3342  if (1) {
3343  GWEN_BUFFER *dstbuf;
3344  GWEN_BUFFER *srcbuf;
3345  int rv;
3346 
3347  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3348  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3349  s=Typemaker2_Member_GetName(tm);
3350  GWEN_Buffer_AppendString(dstbuf, s);
3351 
3352  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3353  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3354  s=Typemaker2_Member_GetName(tm);
3355  GWEN_Buffer_AppendString(srcbuf, s);
3356 
3357  GWEN_Buffer_AppendString(tbuf, " ");
3358  rv=Typemaker2_Builder_Invoke_AssignFn(tb, ty, tm,
3359  GWEN_Buffer_GetStart(srcbuf),
3360  GWEN_Buffer_GetStart(dstbuf),
3361  tbuf);
3362  if (rv<0) {
3363  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3364  GWEN_Buffer_free(srcbuf);
3365  GWEN_Buffer_free(dstbuf);
3366  GWEN_Buffer_free(tbuf);
3367  return rv;
3368  }
3369  GWEN_Buffer_AppendString(tbuf, "\n");
3370  GWEN_Buffer_free(srcbuf);
3371  GWEN_Buffer_free(dstbuf);
3372  }
3373  }
3374  else {
3375  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN) {
3376  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
3377  s=Typemaker2_Member_GetName(tm);
3378  GWEN_Buffer_AppendString(tbuf, s);
3379  GWEN_Buffer_AppendString(tbuf, ") {\n");
3380 
3381  /* free */
3382  if (1) {
3383  GWEN_BUFFER *srcbuf;
3384  int rv;
3385 
3386  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3387  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
3388  s=Typemaker2_Member_GetName(tm);
3389  GWEN_Buffer_AppendString(srcbuf, s);
3390 
3391  GWEN_Buffer_AppendString(tbuf, " ");
3392  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
3393  GWEN_Buffer_GetStart(srcbuf),
3394  NULL, /* no dest */
3395  tbuf);
3396  if (rv<0) {
3397  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3398  GWEN_Buffer_free(srcbuf);
3399  GWEN_Buffer_free(tbuf);
3400  return rv;
3401  }
3402  GWEN_Buffer_AppendString(tbuf, "\n");
3403  GWEN_Buffer_free(srcbuf);
3404  }
3405 
3406  /* preset with NULL */
3407  GWEN_Buffer_AppendString(tbuf, " p_struct->");
3408  s=Typemaker2_Member_GetName(tm);
3409  GWEN_Buffer_AppendString(tbuf, s);
3410  GWEN_Buffer_AppendString(tbuf, "=NULL;\n");
3411 
3412  GWEN_Buffer_AppendString(tbuf, " }\n");
3413  }
3414  else {
3415  /* preset with NULL */
3416  GWEN_Buffer_AppendString(tbuf, " p_struct->");
3417  s=Typemaker2_Member_GetName(tm);
3418  GWEN_Buffer_AppendString(tbuf, s);
3419  GWEN_Buffer_AppendString(tbuf, "=NULL;\n");
3420  }
3421 
3422  GWEN_Buffer_AppendString(tbuf, " if (p_src->");
3423  s=Typemaker2_Member_GetName(tm);
3424  GWEN_Buffer_AppendString(tbuf, s);
3425  GWEN_Buffer_AppendString(tbuf, ") {\n");
3426 
3427  /* dup */
3428  if (1) {
3429  GWEN_BUFFER *dstbuf;
3430  GWEN_BUFFER *srcbuf;
3431  int rv;
3432 
3433  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3434  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3435  s=Typemaker2_Member_GetName(tm);
3436  GWEN_Buffer_AppendString(dstbuf, s);
3437 
3438  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3439  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3440  s=Typemaker2_Member_GetName(tm);
3441  GWEN_Buffer_AppendString(srcbuf, s);
3442 
3443  GWEN_Buffer_AppendString(tbuf, " ");
3444  rv=Typemaker2_Builder_Invoke_DupFn(tb, ty, tm,
3445  GWEN_Buffer_GetStart(srcbuf),
3446  GWEN_Buffer_GetStart(dstbuf),
3447  tbuf);
3448  if (rv<0) {
3449  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3450  GWEN_Buffer_free(srcbuf);
3451  GWEN_Buffer_free(dstbuf);
3452  GWEN_Buffer_free(tbuf);
3453  return rv;
3454  }
3455  GWEN_Buffer_AppendString(tbuf, "\n");
3456  GWEN_Buffer_free(srcbuf);
3457  GWEN_Buffer_free(dstbuf);
3458  }
3459  GWEN_Buffer_AppendString(tbuf, " }\n");
3460  }
3461 
3462  } /* if pointer */
3463  else {
3464  /* dup */
3465  if (1) {
3466  GWEN_BUFFER *dstbuf;
3467  GWEN_BUFFER *srcbuf;
3468  int rv;
3469 
3470  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3471  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3472  s=Typemaker2_Member_GetName(tm);
3473  GWEN_Buffer_AppendString(dstbuf, s);
3474 
3475  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3476  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3477  s=Typemaker2_Member_GetName(tm);
3478  GWEN_Buffer_AppendString(srcbuf, s);
3479 
3480  GWEN_Buffer_AppendString(tbuf, " ");
3481  rv=Typemaker2_Builder_Invoke_DupFn(tb, ty, tm,
3482  GWEN_Buffer_GetStart(srcbuf),
3483  GWEN_Buffer_GetStart(dstbuf),
3484  tbuf);
3485  if (rv<0) {
3486  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3487  GWEN_Buffer_free(srcbuf);
3488  GWEN_Buffer_free(dstbuf);
3489  GWEN_Buffer_free(tbuf);
3490  return rv;
3491  }
3492  GWEN_Buffer_AppendString(tbuf, "\n");
3493  GWEN_Buffer_free(srcbuf);
3494  GWEN_Buffer_free(dstbuf);
3495  }
3496  }
3497 
3498  } /* if !nodup */
3499  else {
3500  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3501  s=Typemaker2_Member_GetName(tm);
3502  GWEN_Buffer_AppendString(tbuf, s);
3503  GWEN_Buffer_AppendString(tbuf, "\" has nodup flag, not copying */\n");
3504  }
3505 
3506  GWEN_Buffer_AppendString(tbuf, "\n");
3507  tm=Typemaker2_Member_List_Next(tm);
3508  }
3509  }
3510 
3511  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
3512 
3513  GWEN_Buffer_AppendString(tbuf, "}\n");
3514 
3515  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3516  GWEN_Buffer_free(tbuf);
3517 
3518  return 0;
3519 }
3520 
3521 
3522 
3523 static int _buildCopy(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3524 {
3525  GWEN_BUFFER *tbuf;
3526  const char *s;
3527  TYPEMAKER2_MEMBER_LIST *tml;
3528  /* uint32_t flags; */
3529  TYPEMAKER2_TYPEMANAGER *tym;
3530 
3531  tym=Typemaker2_Builder_GetTypeManager(tb);
3532  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3533 
3534  /* flags=Typemaker2_Type_GetFlags(ty); */
3535 
3536  /* prototype */
3537  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3538  if (s) {
3539  GWEN_Buffer_AppendString(tbuf, s);
3540  GWEN_Buffer_AppendString(tbuf, " ");
3541  }
3542  s=Typemaker2_Type_GetIdentifier(ty);
3543  GWEN_Buffer_AppendString(tbuf, s);
3544  GWEN_Buffer_AppendString(tbuf, " *");
3545  s=Typemaker2_Type_GetPrefix(ty);
3546  GWEN_Buffer_AppendString(tbuf, s);
3547  GWEN_Buffer_AppendString(tbuf, "_copy(");
3548  s=Typemaker2_Type_GetIdentifier(ty);
3549  GWEN_Buffer_AppendString(tbuf, s);
3550  GWEN_Buffer_AppendString(tbuf, " *p_struct, const ");
3551  GWEN_Buffer_AppendString(tbuf, s);
3552  GWEN_Buffer_AppendString(tbuf, " *p_src);\n");
3553  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3554  GWEN_Buffer_Reset(tbuf);
3555 
3556  /* implementation */
3557  s=Typemaker2_Type_GetIdentifier(ty);
3558  GWEN_Buffer_AppendString(tbuf, s);
3559  GWEN_Buffer_AppendString(tbuf, " *");
3560  s=Typemaker2_Type_GetPrefix(ty);
3561  GWEN_Buffer_AppendString(tbuf, s);
3562  GWEN_Buffer_AppendString(tbuf, "_copy(");
3563  s=Typemaker2_Type_GetIdentifier(ty);
3564  GWEN_Buffer_AppendString(tbuf, s);
3565  GWEN_Buffer_AppendString(tbuf, " *p_struct, const ");
3566  GWEN_Buffer_AppendString(tbuf, s);
3567  GWEN_Buffer_AppendString(tbuf, " *p_src) {\n");
3568 
3569  GWEN_Buffer_AppendString(tbuf, " ");
3570 
3571  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
3572  GWEN_Buffer_AppendString(tbuf, " assert(p_src);\n");
3573 
3574  tml=Typemaker2_Type_GetMembers(ty);
3575  if (tml) {
3576  TYPEMAKER2_MEMBER *tm;
3577 
3578  tm=Typemaker2_Member_List_First(tml);
3579  while (tm) {
3580  TYPEMAKER2_TYPE *mty;
3581 
3582  mty=Typemaker2_Member_GetTypePtr(tm);
3583  assert(mty);
3584 
3585  if (!(Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_NOCOPY)) {
3586  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3587  s=Typemaker2_Member_GetName(tm);
3588  GWEN_Buffer_AppendString(tbuf, s);
3589  GWEN_Buffer_AppendString(tbuf, "\" */\n");
3590 
3591 #if 0
3592  /* release previous value */
3593  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer &&
3594  (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN)) {
3595  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
3596  s=Typemaker2_Member_GetName(tm);
3597  GWEN_Buffer_AppendString(tbuf, s);
3598  GWEN_Buffer_AppendString(tbuf, ") {\n");
3599 
3600  /* free */
3601  if (1) {
3602  GWEN_BUFFER *srcbuf;
3603  int rv;
3604 
3605  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3606  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
3607  s=Typemaker2_Member_GetName(tm);
3608  GWEN_Buffer_AppendString(srcbuf, s);
3609 
3610  GWEN_Buffer_AppendString(tbuf, " ");
3611  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
3612  GWEN_Buffer_GetStart(srcbuf),
3613  NULL, /* no dest */
3614  tbuf);
3615  if (rv<0) {
3616  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3617  GWEN_Buffer_free(srcbuf);
3618  GWEN_Buffer_free(tbuf);
3619  return rv;
3620  }
3621  GWEN_Buffer_AppendString(tbuf, "\n");
3622  GWEN_Buffer_free(srcbuf);
3623  }
3624  GWEN_Buffer_AppendString(tbuf, " }\n");
3625  }
3626 #endif
3627 
3628 
3629  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer) {
3630  if (Typemaker2_Member_GetCopyFlags(tm) & TYPEMAKER2_FLAGS_ASSIGN) {
3631  /* assign */
3632  if (1) {
3633  GWEN_BUFFER *dstbuf;
3634  GWEN_BUFFER *srcbuf;
3635  int rv;
3636 
3637  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3638  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3639  s=Typemaker2_Member_GetName(tm);
3640  GWEN_Buffer_AppendString(dstbuf, s);
3641 
3642  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3643  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3644  s=Typemaker2_Member_GetName(tm);
3645  GWEN_Buffer_AppendString(srcbuf, s);
3646 
3647  GWEN_Buffer_AppendString(tbuf, " ");
3648  rv=Typemaker2_Builder_Invoke_AssignFn(tb, ty, tm,
3649  GWEN_Buffer_GetStart(srcbuf),
3650  GWEN_Buffer_GetStart(dstbuf),
3651  tbuf);
3652  if (rv<0) {
3653  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3654  GWEN_Buffer_free(srcbuf);
3655  GWEN_Buffer_free(dstbuf);
3656  GWEN_Buffer_free(tbuf);
3657  return rv;
3658  }
3659  GWEN_Buffer_AppendString(tbuf, "\n");
3660  GWEN_Buffer_free(srcbuf);
3661  GWEN_Buffer_free(dstbuf);
3662  }
3663  }
3664  else {
3665  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_OWN) {
3666  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
3667  s=Typemaker2_Member_GetName(tm);
3668  GWEN_Buffer_AppendString(tbuf, s);
3669  GWEN_Buffer_AppendString(tbuf, ") {\n");
3670 
3671  /* free */
3672  if (1) {
3673  GWEN_BUFFER *srcbuf;
3674  int rv;
3675 
3676  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3677  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
3678  s=Typemaker2_Member_GetName(tm);
3679  GWEN_Buffer_AppendString(srcbuf, s);
3680 
3681  GWEN_Buffer_AppendString(tbuf, " ");
3682  rv=Typemaker2_Builder_Invoke_DestructFn(tb, ty, tm,
3683  GWEN_Buffer_GetStart(srcbuf),
3684  NULL, /* no dest */
3685  tbuf);
3686  if (rv<0) {
3687  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3688  GWEN_Buffer_free(srcbuf);
3689  GWEN_Buffer_free(tbuf);
3690  return rv;
3691  }
3692  GWEN_Buffer_AppendString(tbuf, "\n");
3693  GWEN_Buffer_free(srcbuf);
3694  }
3695 
3696  /* preset with NULL */
3697  GWEN_Buffer_AppendString(tbuf, " p_struct->");
3698  s=Typemaker2_Member_GetName(tm);
3699  GWEN_Buffer_AppendString(tbuf, s);
3700  GWEN_Buffer_AppendString(tbuf, "=NULL;\n");
3701 
3702  GWEN_Buffer_AppendString(tbuf, " }\n");
3703  }
3704  else {
3705  /* preset with NULL */
3706  GWEN_Buffer_AppendString(tbuf, " p_struct->");
3707  s=Typemaker2_Member_GetName(tm);
3708  GWEN_Buffer_AppendString(tbuf, s);
3709  GWEN_Buffer_AppendString(tbuf, "=NULL;\n");
3710  }
3711 
3712  GWEN_Buffer_AppendString(tbuf, " if (p_src->");
3713  s=Typemaker2_Member_GetName(tm);
3714  GWEN_Buffer_AppendString(tbuf, s);
3715  GWEN_Buffer_AppendString(tbuf, ") {\n");
3716 
3717  /* dup */
3718  if (1) {
3719  GWEN_BUFFER *dstbuf;
3720  GWEN_BUFFER *srcbuf;
3721  int rv;
3722 
3723  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3724  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3725  s=Typemaker2_Member_GetName(tm);
3726  GWEN_Buffer_AppendString(dstbuf, s);
3727 
3728  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3729  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3730  s=Typemaker2_Member_GetName(tm);
3731  GWEN_Buffer_AppendString(srcbuf, s);
3732 
3733  GWEN_Buffer_AppendString(tbuf, " ");
3734  rv=Typemaker2_Builder_Invoke_DupFn(tb, ty, tm,
3735  GWEN_Buffer_GetStart(srcbuf),
3736  GWEN_Buffer_GetStart(dstbuf),
3737  tbuf);
3738  if (rv<0) {
3739  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3740  GWEN_Buffer_free(srcbuf);
3741  GWEN_Buffer_free(dstbuf);
3742  GWEN_Buffer_free(tbuf);
3743  return rv;
3744  }
3745  GWEN_Buffer_AppendString(tbuf, "\n");
3746  GWEN_Buffer_free(srcbuf);
3747  GWEN_Buffer_free(dstbuf);
3748  }
3749  GWEN_Buffer_AppendString(tbuf, " }\n");
3750  }
3751 
3752  } /* if pointer */
3753  else {
3754  /* copy */
3755  if (1) {
3756  GWEN_BUFFER *dstbuf;
3757  GWEN_BUFFER *srcbuf;
3758  int rv;
3759 
3760  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
3761  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
3762  s=Typemaker2_Member_GetName(tm);
3763  GWEN_Buffer_AppendString(dstbuf, s);
3764 
3765  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
3766  GWEN_Buffer_AppendString(srcbuf, "p_src->");
3767  s=Typemaker2_Member_GetName(tm);
3768  GWEN_Buffer_AppendString(srcbuf, s);
3769 
3770  GWEN_Buffer_AppendString(tbuf, " ");
3771  rv=Typemaker2_Builder_Invoke_DupFn(tb, ty, tm,
3772  GWEN_Buffer_GetStart(srcbuf),
3773  GWEN_Buffer_GetStart(dstbuf),
3774  tbuf);
3775  if (rv<0) {
3776  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
3777  GWEN_Buffer_free(srcbuf);
3778  GWEN_Buffer_free(dstbuf);
3779  GWEN_Buffer_free(tbuf);
3780  return rv;
3781  }
3782  GWEN_Buffer_AppendString(tbuf, "\n");
3783  GWEN_Buffer_free(srcbuf);
3784  GWEN_Buffer_free(dstbuf);
3785  }
3786  }
3787 
3788  } /* if !nocopy */
3789  else {
3790  GWEN_Buffer_AppendString(tbuf, " /* member \"");
3791  s=Typemaker2_Member_GetName(tm);
3792  GWEN_Buffer_AppendString(tbuf, s);
3793  GWEN_Buffer_AppendString(tbuf, "\" has NOCOPY flag, not copying */\n");
3794  }
3795 
3796  GWEN_Buffer_AppendString(tbuf, "\n");
3797  tm=Typemaker2_Member_List_Next(tm);
3798  }
3799  }
3800 
3801  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
3802 
3803  GWEN_Buffer_AppendString(tbuf, "}\n");
3804 
3805  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3806  GWEN_Buffer_free(tbuf);
3807 
3808  return 0;
3809 }
3810 
3811 
3812 
3813 static int _buildList1Dup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3814 {
3815  GWEN_BUFFER *tbuf;
3816  const char *s;
3817  /* uint32_t flags; */
3818  TYPEMAKER2_TYPEMANAGER *tym;
3819 
3820  tym=Typemaker2_Builder_GetTypeManager(tb);
3821  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3822 
3823  /* flags=Typemaker2_Type_GetFlags(ty); */
3824 
3825  /* prototype */
3826  GWEN_Buffer_AppendString(tbuf, "/* list1 functions */\n");
3827  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3828  if (s) {
3829  GWEN_Buffer_AppendString(tbuf, s);
3830  GWEN_Buffer_AppendString(tbuf, " ");
3831  }
3832  s=Typemaker2_Type_GetIdentifier(ty);
3833  GWEN_Buffer_AppendString(tbuf, s);
3834  GWEN_Buffer_AppendString(tbuf, "_LIST *");
3835  s=Typemaker2_Type_GetPrefix(ty);
3836  GWEN_Buffer_AppendString(tbuf, s);
3837  GWEN_Buffer_AppendString(tbuf, "_List_dup(const ");
3838  s=Typemaker2_Type_GetIdentifier(ty);
3839  GWEN_Buffer_AppendString(tbuf, s);
3840  GWEN_Buffer_AppendString(tbuf, "_LIST *p_src);\n");
3841  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3842  GWEN_Buffer_Reset(tbuf);
3843 
3844  /* implementation */
3845  GWEN_Buffer_AppendString(tbuf, "/* list1 functions */\n");
3846  s=Typemaker2_Type_GetIdentifier(ty);
3847  GWEN_Buffer_AppendString(tbuf, s);
3848  GWEN_Buffer_AppendString(tbuf, "_LIST *");
3849  s=Typemaker2_Type_GetPrefix(ty);
3850  GWEN_Buffer_AppendString(tbuf, s);
3851  GWEN_Buffer_AppendString(tbuf, "_List_dup(const ");
3852  s=Typemaker2_Type_GetIdentifier(ty);
3853  GWEN_Buffer_AppendString(tbuf, s);
3854  GWEN_Buffer_AppendString(tbuf, "_LIST *p_src) {\n");
3855 
3856  GWEN_Buffer_AppendString(tbuf, " ");
3857  s=Typemaker2_Type_GetIdentifier(ty);
3858  GWEN_Buffer_AppendString(tbuf, s);
3859  GWEN_Buffer_AppendString(tbuf, "_LIST *p_dest;\n");
3860 
3861  GWEN_Buffer_AppendString(tbuf, " ");
3862  s=Typemaker2_Type_GetIdentifier(ty);
3863  GWEN_Buffer_AppendString(tbuf, s);
3864  GWEN_Buffer_AppendString(tbuf, " *p_elem;\n");
3865  GWEN_Buffer_AppendString(tbuf, "\n");
3866 
3867  GWEN_Buffer_AppendString(tbuf, " assert(p_src);\n");
3868  GWEN_Buffer_AppendString(tbuf, " p_dest=");
3869  s=Typemaker2_Type_GetPrefix(ty);
3870  GWEN_Buffer_AppendString(tbuf, s);
3871  GWEN_Buffer_AppendString(tbuf, "_List_new();\n");
3872 
3873  GWEN_Buffer_AppendString(tbuf, " p_elem=");
3874  s=Typemaker2_Type_GetPrefix(ty);
3875  GWEN_Buffer_AppendString(tbuf, s);
3876  GWEN_Buffer_AppendString(tbuf, "_List_First(p_src);\n");
3877 
3878  GWEN_Buffer_AppendString(tbuf, " while(p_elem) {\n");
3879  GWEN_Buffer_AppendString(tbuf, " ");
3880  s=Typemaker2_Type_GetIdentifier(ty);
3881  GWEN_Buffer_AppendString(tbuf, s);
3882  GWEN_Buffer_AppendString(tbuf, " *p_cpy;\n");
3883  GWEN_Buffer_AppendString(tbuf, "\n");
3884 
3885  GWEN_Buffer_AppendString(tbuf, " p_cpy=");
3886  s=Typemaker2_Type_GetPrefix(ty);
3887  GWEN_Buffer_AppendString(tbuf, s);
3888  GWEN_Buffer_AppendString(tbuf, "_dup(p_elem);\n");
3889 
3890  GWEN_Buffer_AppendString(tbuf, " ");
3891  s=Typemaker2_Type_GetPrefix(ty);
3892  GWEN_Buffer_AppendString(tbuf, s);
3893  GWEN_Buffer_AppendString(tbuf, "_List_Add(p_cpy, p_dest);\n");
3894 
3895  GWEN_Buffer_AppendString(tbuf, " p_elem=");
3896  s=Typemaker2_Type_GetPrefix(ty);
3897  GWEN_Buffer_AppendString(tbuf, s);
3898  GWEN_Buffer_AppendString(tbuf, "_List_Next(p_elem);\n");
3899  GWEN_Buffer_AppendString(tbuf, " }\n");
3900  GWEN_Buffer_AppendString(tbuf, "\n");
3901 
3902  GWEN_Buffer_AppendString(tbuf, " return p_dest;\n");
3903  GWEN_Buffer_AppendString(tbuf, "}\n");
3904 
3905  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3906  GWEN_Buffer_free(tbuf);
3907 
3908  return 0;
3909 }
3910 
3911 
3912 
3913 static int _buildCreateTable(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3914 {
3915  GWEN_BUFFER *tbuf;
3916  const char *s;
3917  /* uint32_t flags; */
3918  TYPEMAKER2_TYPEMANAGER *tym;
3919 
3920  tym=Typemaker2_Builder_GetTypeManager(tb);
3921  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3922 
3923  /* flags=Typemaker2_Type_GetFlags(ty); */
3924 
3925  /* prototype */
3926  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3927  if (s) {
3928  GWEN_Buffer_AppendString(tbuf, s);
3929  GWEN_Buffer_AppendString(tbuf, " ");
3930  }
3931  GWEN_Buffer_AppendString(tbuf, "int ");
3932  s=Typemaker2_Type_GetPrefix(ty);
3933  GWEN_Buffer_AppendString(tbuf, s);
3934  GWEN_Buffer_AppendString(tbuf, "_CreateTable(AQDB_DB *p_db, const char *p_name, uint32_t p_flags);");
3935  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3936  GWEN_Buffer_Reset(tbuf);
3937 
3938  /* implementation */
3939  GWEN_Buffer_AppendString(tbuf, "int ");
3940  s=Typemaker2_Type_GetPrefix(ty);
3941  GWEN_Buffer_AppendString(tbuf, s);
3942  GWEN_Buffer_AppendString(tbuf, "_CreateTable(AQDB_DB *p_db, const char *p_name, uint32_t p_flags) {\n");
3943 
3944  GWEN_Buffer_AppendString(tbuf, " AQDB_COLUMN_LIST *p_cl;\n");
3945  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
3946  GWEN_Buffer_AppendString(tbuf, "\n");
3947 
3948  GWEN_Buffer_AppendString(tbuf, " p_cl=");
3949  s=Typemaker2_Type_GetPrefix(ty);
3950  GWEN_Buffer_AppendString(tbuf, s);
3951  GWEN_Buffer_AppendString(tbuf, "_CreateColumnList();\n");
3952 
3953  GWEN_Buffer_AppendString(tbuf, " p_rv=AQDB_DB_CreateTable(p_db, p_name, p_flags, p_cl);\n");
3954  GWEN_Buffer_AppendString(tbuf, " AQDB_Column_List_free(p_cl);\n");
3955  GWEN_Buffer_AppendString(tbuf, " if (p_rv<0) {\n");
3956  GWEN_Buffer_AppendString(tbuf, " DBG_INFO(GWEN_LOGDOMAIN, \"here (%d)\", p_rv);\n");
3957  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
3958  GWEN_Buffer_AppendString(tbuf, " }\n");
3959 
3960  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
3961  GWEN_Buffer_AppendString(tbuf, "}\n");
3962 
3963  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
3964  GWEN_Buffer_free(tbuf);
3965 
3966  return 0;
3967 }
3968 
3969 
3970 
3971 static int _buildCreateObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
3972 {
3973  GWEN_BUFFER *tbuf;
3974  const char *s;
3975  /* uint32_t flags; */
3976  TYPEMAKER2_TYPEMANAGER *tym;
3977 
3978  tym=Typemaker2_Builder_GetTypeManager(tb);
3979  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
3980 
3981  /* flags=Typemaker2_Type_GetFlags(ty); */
3982 
3983  /* prototype */
3984  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
3985  if (s) {
3986  GWEN_Buffer_AppendString(tbuf, s);
3987  GWEN_Buffer_AppendString(tbuf, " ");
3988  }
3989  GWEN_Buffer_AppendString(tbuf, "int ");
3990  s=Typemaker2_Type_GetPrefix(ty);
3991  GWEN_Buffer_AppendString(tbuf, s);
3992  GWEN_Buffer_AppendString(tbuf, "_CreateObject(AQDB_DB *p_db, AQDB_ID p_tableId, AQDB_ID p_id, AQDB_OBJECT **pp_o);\n");
3993  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
3994  GWEN_Buffer_Reset(tbuf);
3995 
3996  /* implementation */
3997  GWEN_Buffer_AppendString(tbuf, "int ");
3998  s=Typemaker2_Type_GetPrefix(ty);
3999  GWEN_Buffer_AppendString(tbuf, s);
4000  GWEN_Buffer_AppendString(tbuf, "_CreateObject(AQDB_DB *p_db, AQDB_ID p_tableId, AQDB_ID p_id, AQDB_OBJECT **pp_o) {\n");
4001 
4002  GWEN_Buffer_AppendString(tbuf, " AQDB_OBJECT *p_o;\n");
4003  GWEN_Buffer_AppendString(tbuf, "\n");
4004 
4005  GWEN_Buffer_AppendString(tbuf, " p_o=AQDB_Object_new(p_tableId, p_id, ");
4006  s=Typemaker2_Type_GetFieldCountId(ty);
4007  if (s && *s) {
4008  }
4009  GWEN_Buffer_AppendString(tbuf, s);
4010  GWEN_Buffer_AppendString(tbuf, ");\n");
4011  GWEN_Buffer_AppendString(tbuf, " *pp_o=p_o;\n");
4012  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
4013  GWEN_Buffer_AppendString(tbuf, "}\n");
4014 
4015  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4016  GWEN_Buffer_free(tbuf);
4017 
4018  return 0;
4019 }
4020 
4021 
4022 
4023 static int _buildDefineEnums(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4024 {
4025  TYPEMAKER2_ENUM_LIST *enums;
4026  /* TYPEMAKER2_TYPEMANAGER *tym; */
4027  /* uint32_t flags; */
4028 
4029  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4030  enums=Typemaker2_Type_GetEnums(ty);
4031  /* flags=Typemaker2_Type_GetFlags(ty); */
4032 
4033  assert(enums);
4034  if (Typemaker2_Enum_List_GetCount(enums)) {
4035  GWEN_BUFFER *tbuf;
4036  const char *s;
4037  TYPEMAKER2_ENUM *te;
4038 
4039  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4040 
4041  te=Typemaker2_Enum_List_First(enums);
4042  while (te) {
4043  const char *prefix;
4044  const char *etype;
4045  TYPEMAKER2_ITEM *ti;
4046  int access=TypeMaker2_Access_Public;
4047 
4048  prefix=Typemaker2_Enum_GetPrefix(te);
4049  if (prefix==NULL || *prefix==0) {
4050  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
4051  GWEN_Buffer_free(tbuf);
4052  return GWEN_ERROR_BAD_DATA;
4053  }
4054 
4055  etype=Typemaker2_Enum_GetType(te);
4056  if (etype && *etype)
4057  GWEN_Buffer_AppendString(tbuf, "typedef enum {\n");
4058  else
4059  GWEN_Buffer_AppendString(tbuf, "enum {\n");
4060 
4061  GWEN_Buffer_AppendString(tbuf, " ");
4062  if (prefix)
4063  GWEN_Buffer_AppendString(tbuf, prefix);
4064  GWEN_Buffer_AppendString(tbuf, "Unknown = -1");
4065  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
4066  if (ti)
4067  GWEN_Buffer_AppendString(tbuf, ",");
4068  GWEN_Buffer_AppendString(tbuf, "\n");
4069  while (ti) {
4070  GWEN_Buffer_AppendString(tbuf, " ");
4071  if (prefix)
4072  GWEN_Buffer_AppendString(tbuf, prefix);
4073  s=Typemaker2_Item_GetName(ti);
4074  if (s && *s) {
4075  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4076  GWEN_Buffer_AppendString(tbuf, s+1);
4077  }
4078  s=Typemaker2_Item_GetValue(ti);
4079  if (s) {
4080  GWEN_Buffer_AppendString(tbuf, " = ");
4081  GWEN_Buffer_AppendString(tbuf, s);
4082  }
4083 
4084  ti=Typemaker2_Item_List_Next(ti);
4085  if (ti)
4086  GWEN_Buffer_AppendString(tbuf, ",");
4087  GWEN_Buffer_AppendString(tbuf, "\n");
4088  }
4089  GWEN_Buffer_AppendString(tbuf, "}");
4090 
4091  if (etype && *etype) {
4092  GWEN_Buffer_AppendString(tbuf, " ");
4093  GWEN_Buffer_AppendString(tbuf, etype);
4094  }
4095 
4096  GWEN_Buffer_AppendString(tbuf, ";\n");
4097  GWEN_Buffer_AppendString(tbuf, "\n");
4098 
4099  switch (access) {
4100  case TypeMaker2_Access_Public:
4101  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4102  break;
4103  case TypeMaker2_Access_Library:
4104  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4105  break;
4106  case TypeMaker2_Access_Protected:
4107  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4108  break;
4109  case TypeMaker2_Access_Private:
4110  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4111  break;
4112  default:
4113  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4114  GWEN_Buffer_free(tbuf);
4115  return GWEN_ERROR_BAD_DATA;
4116  }
4117  GWEN_Buffer_Reset(tbuf);
4118 
4119  te=Typemaker2_Enum_List_Next(te);
4120  }
4121  }
4122 
4123  return 0;
4124 }
4125 
4126 
4127 
4128 int _buildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
4129 {
4130  TYPEMAKER2_VIRTUALFN_LIST *fns;
4131  /* TYPEMAKER2_TYPEMANAGER *tym; */
4132  /*uint32_t flags; */
4133 
4134  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4135  fns=Typemaker2_Type_GetVirtualFns(ty);
4136  /* flags=Typemaker2_Type_GetFlags(ty); */
4137 
4138  assert(fns);
4139  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4140  GWEN_BUFFER *tbuf;
4141  const char *s;
4142  TYPEMAKER2_VIRTUALFN *vf;
4143 
4144  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4145 
4146  if (loc && *loc) {
4147  GWEN_Buffer_AppendString(tbuf, "/* definitions for virtual functions (");
4148  GWEN_Buffer_AppendString(tbuf, loc);
4149  GWEN_Buffer_AppendString(tbuf, ") */\n");
4150  }
4151  else
4152  GWEN_Buffer_AppendString(tbuf, "/* definitions for virtual functions */\n");
4153 
4154  vf=Typemaker2_VirtualFn_List_First(fns);
4155  while (vf) {
4156  s=Typemaker2_VirtualFn_GetLocation(vf);
4157  if (!(s && *s))
4158  s="pre";
4159  if (s && loc && strcasecmp(s, loc)==0) {
4160  int access=Typemaker2_VirtualFn_GetAccess(vf);
4161  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
4162  int i;
4163 
4164  GWEN_Buffer_AppendString(tbuf, "typedef ");
4165  s=Typemaker2_VirtualFn_GetReturnType(vf);
4166  if (!(s && *s)) {
4167  GWEN_Buffer_free(tbuf);
4168  return GWEN_ERROR_BAD_DATA;
4169  }
4170  GWEN_Buffer_AppendString(tbuf, s);
4171 
4172  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_GWEN_CB) {
4173  GWEN_Buffer_AppendString(tbuf, " GWENHYWFAR_CB");
4174  }
4175 
4176 
4177  GWEN_Buffer_AppendString(tbuf, " (*");
4178  s=Typemaker2_Type_GetIdentifier(ty);
4179  GWEN_Buffer_AppendString(tbuf, s);
4180  GWEN_Buffer_AppendString(tbuf, "_");
4181 
4182  s=Typemaker2_VirtualFn_GetName(vf);
4183  if (!(s && *s)) {
4184  GWEN_Buffer_free(tbuf);
4185  return GWEN_ERROR_BAD_DATA;
4186  }
4187  while (*s) {
4188  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4189  s++;
4190  }
4191  GWEN_Buffer_AppendString(tbuf, "_FN)(");
4192 
4193  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4194  GWEN_Buffer_AppendString(tbuf, "const ");
4195 
4196  s=Typemaker2_Type_GetIdentifier(ty);
4197  GWEN_Buffer_AppendString(tbuf, s);
4198  /* created structs are always pointers */
4199  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4200 
4201  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4202  if (plist) {
4203  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4204 
4205  i=1;
4206  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4207  while (prm) {
4208  const char *paramName;
4209  const char *paramType;
4210 
4211  GWEN_Buffer_AppendString(tbuf, ", ");
4212 
4213  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4214  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4215 
4216  GWEN_Buffer_AppendString(tbuf, paramType);
4217  GWEN_Buffer_AppendString(tbuf, " ");
4218 
4219  if (paramName)
4220  GWEN_Buffer_AppendString(tbuf, paramName);
4221  else {
4222  char numbuf[64];
4223 
4224  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4225  numbuf[sizeof(numbuf)-1]=0;
4226  GWEN_Buffer_AppendString(tbuf, numbuf);
4227  }
4228 
4229  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4230  i++;
4231  }
4232  }
4233 
4234  GWEN_Buffer_AppendString(tbuf, ");\n");
4235 
4236  switch (access) {
4237  case TypeMaker2_Access_Public:
4238  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4239  break;
4240  case TypeMaker2_Access_Library:
4241  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4242  break;
4243  case TypeMaker2_Access_Protected:
4244  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4245  break;
4246  case TypeMaker2_Access_Private:
4247  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4248  break;
4249  default:
4250  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4251  GWEN_Buffer_free(tbuf);
4252  return GWEN_ERROR_BAD_DATA;
4253  }
4254  GWEN_Buffer_Reset(tbuf);
4255  }
4256 
4257  vf=Typemaker2_VirtualFn_List_Next(vf);
4258  }
4259  }
4260 
4261  return 0;
4262 }
4263 
4264 
4265 
4266 int _buildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4267 {
4268  TYPEMAKER2_VIRTUALFN_LIST *fns;
4269  TYPEMAKER2_TYPEMANAGER *tym;
4270  /* uint32_t flags; */
4271 
4272  tym=Typemaker2_Builder_GetTypeManager(tb);
4273  fns=Typemaker2_Type_GetVirtualFns(ty);
4274  /* flags=Typemaker2_Type_GetFlags(ty); */
4275 
4276  assert(fns);
4277  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4278  GWEN_BUFFER *tbuf;
4279  const char *s;
4280  TYPEMAKER2_VIRTUALFN *vf;
4281 
4282  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4283 
4284  GWEN_Buffer_AppendString(tbuf, "/* prototypes for virtual functions */\n");
4285  vf=Typemaker2_VirtualFn_List_First(fns);
4286  while (vf) {
4287  int access=Typemaker2_VirtualFn_GetAccess(vf);
4288  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
4289  int i;
4290 
4291  /* write APIDOC */
4292  GWEN_Buffer_AppendString(tbuf, "/**\n");
4293  s=Typemaker2_VirtualFn_GetDescr(vf);
4294  if (s && *s) {
4295  int len;
4296 
4297  GWEN_Buffer_AppendString(tbuf, " * ");
4298  GWEN_Buffer_AppendString(tbuf, s);
4299  len=strlen(s);
4300  if (s[len-1]!='\n')
4301  GWEN_Buffer_AppendString(tbuf, "\n");
4302  }
4303 
4304  s=Typemaker2_VirtualFn_GetReturnTypeDescr(vf);
4305  if (s && *s) {
4306  int len;
4307 
4308  GWEN_Buffer_AppendString(tbuf, " * @return ");
4309  GWEN_Buffer_AppendString(tbuf, s);
4310  len=strlen(s);
4311  if (s[len-1]!='\n')
4312  GWEN_Buffer_AppendString(tbuf, "\n");
4313  }
4314 
4315 
4316  i=1;
4317  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4318  if (plist) {
4319  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4320 
4321  i=1;
4322  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4323  while (prm) {
4324  const char *paramDescr;
4325 
4326  paramDescr=Typemaker2_VirtualFn_Param_GetDescr(prm);
4327  if (paramDescr && *paramDescr) {
4328  const char *paramName;
4329  int len;
4330 
4331  GWEN_Buffer_AppendString(tbuf, " * @param ");
4332  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4333  if (paramName)
4334  GWEN_Buffer_AppendString(tbuf, paramName);
4335  else {
4336  char numbuf[64];
4337 
4338  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4339  numbuf[sizeof(numbuf)-1]=0;
4340  GWEN_Buffer_AppendString(tbuf, numbuf);
4341  }
4342 
4343  GWEN_Buffer_AppendString(tbuf, " ");
4344  GWEN_Buffer_AppendString(tbuf, paramDescr);
4345  len=strlen(paramDescr);
4346  if (paramDescr[len-1]!='\n')
4347  GWEN_Buffer_AppendString(tbuf, "\n");
4348  }
4349 
4350  i++;
4351  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4352  }
4353  }
4354  GWEN_Buffer_AppendString(tbuf, " */\n");
4355 
4356 
4357  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4358  if (s && *s) {
4359  GWEN_Buffer_AppendString(tbuf, s);
4360  GWEN_Buffer_AppendString(tbuf, " ");
4361  }
4362 
4363  s=Typemaker2_VirtualFn_GetReturnType(vf);
4364  if (!(s && *s)) {
4365  GWEN_Buffer_free(tbuf);
4366  return GWEN_ERROR_BAD_DATA;
4367  }
4368  GWEN_Buffer_AppendString(tbuf, s);
4369  GWEN_Buffer_AppendString(tbuf, " ");
4370 
4371  s=Typemaker2_Type_GetPrefix(ty);
4372  GWEN_Buffer_AppendString(tbuf, s);
4373  GWEN_Buffer_AppendString(tbuf, "_");
4374  s=Typemaker2_VirtualFn_GetName(vf);
4375  if (!(s && *s)) {
4376  GWEN_Buffer_free(tbuf);
4377  return GWEN_ERROR_BAD_DATA;
4378  }
4379  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4380  GWEN_Buffer_AppendString(tbuf, s+1);
4381  GWEN_Buffer_AppendString(tbuf, "(");
4382 
4383  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4384  GWEN_Buffer_AppendString(tbuf, "const ");
4385 
4386  s=Typemaker2_Type_GetIdentifier(ty);
4387  GWEN_Buffer_AppendString(tbuf, s);
4388  /* created structs are always pointers */
4389  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4390 
4391 
4392  i=1;
4393  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4394  if (plist) {
4395  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4396 
4397  i=1;
4398  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4399  while (prm) {
4400  const char *paramName;
4401  const char *paramType;
4402 
4403  GWEN_Buffer_AppendString(tbuf, ", ");
4404 
4405  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4406  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4407 
4408  GWEN_Buffer_AppendString(tbuf, paramType);
4409  GWEN_Buffer_AppendString(tbuf, " ");
4410 
4411  if (paramName)
4412  GWEN_Buffer_AppendString(tbuf, paramName);
4413  else {
4414  char numbuf[64];
4415 
4416  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4417  numbuf[sizeof(numbuf)-1]=0;
4418  GWEN_Buffer_AppendString(tbuf, numbuf);
4419  }
4420 
4421  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4422  i++;
4423  }
4424  }
4425  GWEN_Buffer_AppendString(tbuf, ");\n");
4426 
4427 
4428  switch (access) {
4429  case TypeMaker2_Access_Public:
4430  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4431  break;
4432  case TypeMaker2_Access_Library:
4433  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4434  break;
4435  case TypeMaker2_Access_Protected:
4436  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4437  break;
4438  case TypeMaker2_Access_Private:
4439  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4440  break;
4441  default:
4442  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4443  GWEN_Buffer_free(tbuf);
4444  return GWEN_ERROR_BAD_DATA;
4445  }
4446  GWEN_Buffer_Reset(tbuf);
4447 
4448  vf=Typemaker2_VirtualFn_List_Next(vf);
4449  }
4450  }
4451 
4452  return 0;
4453 }
4454 
4455 
4456 
4457 int _buildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4458 {
4459  TYPEMAKER2_VIRTUALFN_LIST *fns;
4460  /* TYPEMAKER2_TYPEMANAGER *tym; */
4461  /* uint32_t flags; */
4462 
4463  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4464  fns=Typemaker2_Type_GetVirtualFns(ty);
4465  /* flags=Typemaker2_Type_GetFlags(ty); */
4466 
4467  assert(fns);
4468  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4469  GWEN_BUFFER *tbuf;
4470  const char *s;
4471  TYPEMAKER2_VIRTUALFN *vf;
4472 
4473  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4474 
4475  GWEN_Buffer_AppendString(tbuf, "/* code for virtual functions */\n");
4476  vf=Typemaker2_VirtualFn_List_First(fns);
4477  while (vf) {
4478  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
4479  int i;
4480 
4481  s=Typemaker2_VirtualFn_GetReturnType(vf);
4482  if (!(s && *s)) {
4483  GWEN_Buffer_free(tbuf);
4484  return GWEN_ERROR_BAD_DATA;
4485  }
4486  GWEN_Buffer_AppendString(tbuf, s);
4487  GWEN_Buffer_AppendString(tbuf, " ");
4488 
4489  s=Typemaker2_Type_GetPrefix(ty);
4490  GWEN_Buffer_AppendString(tbuf, s);
4491  GWEN_Buffer_AppendString(tbuf, "_");
4492  s=Typemaker2_VirtualFn_GetName(vf);
4493  if (!(s && *s)) {
4494  GWEN_Buffer_free(tbuf);
4495  return GWEN_ERROR_BAD_DATA;
4496  }
4497  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4498  GWEN_Buffer_AppendString(tbuf, s+1);
4499  GWEN_Buffer_AppendString(tbuf, "(");
4500 
4501  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4502  GWEN_Buffer_AppendString(tbuf, "const ");
4503 
4504  s=Typemaker2_Type_GetIdentifier(ty);
4505  GWEN_Buffer_AppendString(tbuf, s);
4506  /* created structs are always pointers */
4507  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4508 
4509 
4510  i=1;
4511  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4512  if (plist) {
4513  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4514 
4515  i=1;
4516  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4517  while (prm) {
4518  const char *paramName;
4519  const char *paramType;
4520 
4521  GWEN_Buffer_AppendString(tbuf, ", ");
4522 
4523  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4524  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4525 
4526  GWEN_Buffer_AppendString(tbuf, paramType);
4527  GWEN_Buffer_AppendString(tbuf, " ");
4528 
4529  if (paramName)
4530  GWEN_Buffer_AppendString(tbuf, paramName);
4531  else {
4532  char numbuf[64];
4533 
4534  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4535  numbuf[sizeof(numbuf)-1]=0;
4536  GWEN_Buffer_AppendString(tbuf, numbuf);
4537  }
4538 
4539  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4540  i++;
4541  }
4542  }
4543  GWEN_Buffer_AppendString(tbuf, ") {\n");
4544 
4545  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
4546  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
4547  s=Typemaker2_VirtualFn_GetName(vf);
4548  if (!(s && *s)) {
4549  DBG_ERROR(0, "Virtual functions has no name");
4550  GWEN_Buffer_free(tbuf);
4551  return GWEN_ERROR_BAD_DATA;
4552  }
4553  GWEN_Buffer_AppendString(tbuf, s);
4554  GWEN_Buffer_AppendString(tbuf, "Fn)\n");
4555  GWEN_Buffer_AppendString(tbuf, " return p_struct->");
4556  GWEN_Buffer_AppendString(tbuf, s);
4557  GWEN_Buffer_AppendString(tbuf, "Fn(p_struct");
4558 
4559  i=1;
4560  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4561  if (plist) {
4562  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4563 
4564  i=1;
4565  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4566  while (prm) {
4567  const char *paramName;
4568 
4569  GWEN_Buffer_AppendString(tbuf, ", ");
4570 
4571  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4572 
4573  if (paramName)
4574  GWEN_Buffer_AppendString(tbuf, paramName);
4575  else {
4576  char numbuf[64];
4577 
4578  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4579  numbuf[sizeof(numbuf)-1]=0;
4580  GWEN_Buffer_AppendString(tbuf, numbuf);
4581  }
4582 
4583  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4584  i++;
4585  }
4586  }
4587  GWEN_Buffer_AppendString(tbuf, ");\n");
4588 
4589  GWEN_Buffer_AppendString(tbuf, " else\n");
4590  GWEN_Buffer_AppendString(tbuf, " return ");
4591  s=Typemaker2_VirtualFn_GetDefaultReturnValue(vf);
4592  if (!(s && *s)) {
4593  DBG_ERROR(0, "No default return value");
4594  GWEN_Buffer_free(tbuf);
4595  return GWEN_ERROR_BAD_DATA;
4596  }
4597  GWEN_Buffer_AppendString(tbuf, s);
4598  GWEN_Buffer_AppendString(tbuf, ";\n");
4599  GWEN_Buffer_AppendString(tbuf, "}\n");
4600 
4601  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4602  GWEN_Buffer_Reset(tbuf);
4603 
4604  vf=Typemaker2_VirtualFn_List_Next(vf);
4605  }
4606  }
4607 
4608  return 0;
4609 }
4610 
4611 
4612 
4613 int _buildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4614 {
4615  TYPEMAKER2_VIRTUALFN_LIST *fns;
4616  TYPEMAKER2_TYPEMANAGER *tym;
4617  /* uint32_t flags; */
4618 
4619  tym=Typemaker2_Builder_GetTypeManager(tb);
4620  fns=Typemaker2_Type_GetVirtualFns(ty);
4621  /* flags=Typemaker2_Type_GetFlags(ty); */
4622 
4623  assert(fns);
4624  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4625  GWEN_BUFFER *tbuf;
4626  const char *s;
4627  TYPEMAKER2_VIRTUALFN *vf;
4628 
4629  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4630 
4631  GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
4632  vf=Typemaker2_VirtualFn_List_First(fns);
4633  while (vf) {
4634  int access=Typemaker2_VirtualFn_GetAccess(vf);
4635 
4636  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4637  if (s && *s) {
4638  GWEN_Buffer_AppendString(tbuf, s);
4639  GWEN_Buffer_AppendString(tbuf, " ");
4640  }
4641 
4642  s=Typemaker2_Type_GetIdentifier(ty);
4643  GWEN_Buffer_AppendString(tbuf, s);
4644  GWEN_Buffer_AppendString(tbuf, "_");
4645  s=Typemaker2_VirtualFn_GetName(vf);
4646  if (!(s && *s)) {
4647  GWEN_Buffer_free(tbuf);
4648  return GWEN_ERROR_BAD_DATA;
4649  }
4650  while (*s)
4651  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4652  GWEN_Buffer_AppendString(tbuf, "_FN ");
4653 
4654  s=Typemaker2_Type_GetPrefix(ty);
4655  GWEN_Buffer_AppendString(tbuf, s);
4656  GWEN_Buffer_AppendString(tbuf, "_Set");
4657  s=Typemaker2_VirtualFn_GetName(vf);
4658  if (!(s && *s)) {
4659  GWEN_Buffer_free(tbuf);
4660  return GWEN_ERROR_BAD_DATA;
4661  }
4662  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4663  GWEN_Buffer_AppendString(tbuf, s+1);
4664  GWEN_Buffer_AppendString(tbuf, "Fn(");
4665 
4666  s=Typemaker2_Type_GetIdentifier(ty);
4667  GWEN_Buffer_AppendString(tbuf, s);
4668  /* created structs are always pointers */
4669  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
4670 
4671  s=Typemaker2_Type_GetIdentifier(ty);
4672  GWEN_Buffer_AppendString(tbuf, s);
4673  GWEN_Buffer_AppendString(tbuf, "_");
4674  s=Typemaker2_VirtualFn_GetName(vf);
4675  if (!(s && *s)) {
4676  GWEN_Buffer_free(tbuf);
4677  return GWEN_ERROR_BAD_DATA;
4678  }
4679  while (*s)
4680  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4681  GWEN_Buffer_AppendString(tbuf, "_FN fn);\n");
4682 
4683  switch (access) {
4684  case TypeMaker2_Access_Public:
4685  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4686  break;
4687  case TypeMaker2_Access_Library:
4688  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4689  break;
4690  case TypeMaker2_Access_Protected:
4691  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4692  break;
4693  case TypeMaker2_Access_Private:
4694  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4695  break;
4696  default:
4697  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4698  GWEN_Buffer_free(tbuf);
4699  return GWEN_ERROR_BAD_DATA;
4700  }
4701  GWEN_Buffer_Reset(tbuf);
4702 
4703  vf=Typemaker2_VirtualFn_List_Next(vf);
4704  }
4705  }
4706 
4707  return 0;
4708 }
4709 
4710 
4711 
4712 int _buildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4713 {
4714  TYPEMAKER2_VIRTUALFN_LIST *fns;
4715  /* TYPEMAKER2_TYPEMANAGER *tym; */
4716  /* uint32_t flags; */
4717 
4718  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4719  fns=Typemaker2_Type_GetVirtualFns(ty);
4720  /* flags=Typemaker2_Type_GetFlags(ty); */
4721 
4722  assert(fns);
4723  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4724  GWEN_BUFFER *tbuf;
4725  const char *s;
4726  TYPEMAKER2_VIRTUALFN *vf;
4727 
4728  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4729 
4730  GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
4731  vf=Typemaker2_VirtualFn_List_First(fns);
4732  while (vf) {
4733 
4734  s=Typemaker2_Type_GetIdentifier(ty);
4735  GWEN_Buffer_AppendString(tbuf, s);
4736  GWEN_Buffer_AppendString(tbuf, "_");
4737 
4738  s=Typemaker2_VirtualFn_GetName(vf);
4739  if (!(s && *s)) {
4740  GWEN_Buffer_free(tbuf);
4741  return GWEN_ERROR_BAD_DATA;
4742  }
4743  while (*s)
4744  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4745  GWEN_Buffer_AppendString(tbuf, "_FN ");
4746 
4747  s=Typemaker2_Type_GetPrefix(ty);
4748  GWEN_Buffer_AppendString(tbuf, s);
4749  GWEN_Buffer_AppendString(tbuf, "_Set");
4750  s=Typemaker2_VirtualFn_GetName(vf);
4751  if (!(s && *s)) {
4752  GWEN_Buffer_free(tbuf);
4753  return GWEN_ERROR_BAD_DATA;
4754  }
4755  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4756  GWEN_Buffer_AppendString(tbuf, s+1);
4757  GWEN_Buffer_AppendString(tbuf, "Fn(");
4758 
4759  s=Typemaker2_Type_GetIdentifier(ty);
4760  GWEN_Buffer_AppendString(tbuf, s);
4761  /* created structs are always pointers */
4762  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
4763 
4764  s=Typemaker2_Type_GetIdentifier(ty);
4765  GWEN_Buffer_AppendString(tbuf, s);
4766  GWEN_Buffer_AppendString(tbuf, "_");
4767  s=Typemaker2_VirtualFn_GetName(vf);
4768  if (!(s && *s)) {
4769  GWEN_Buffer_free(tbuf);
4770  return GWEN_ERROR_BAD_DATA;
4771  }
4772  while (*s)
4773  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4774  GWEN_Buffer_AppendString(tbuf, "_FN fn){\n");
4775 
4776  GWEN_Buffer_AppendString(tbuf, " ");
4777  s=Typemaker2_Type_GetIdentifier(ty);
4778  GWEN_Buffer_AppendString(tbuf, s);
4779  GWEN_Buffer_AppendString(tbuf, "_");
4780  s=Typemaker2_VirtualFn_GetName(vf);
4781  if (!(s && *s)) {
4782  GWEN_Buffer_free(tbuf);
4783  return GWEN_ERROR_BAD_DATA;
4784  }
4785  while (*s)
4786  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4787  GWEN_Buffer_AppendString(tbuf, "_FN oldFn;\n\n");
4788 
4789  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
4790  GWEN_Buffer_AppendString(tbuf, " oldFn=p_struct->");
4791  s=Typemaker2_VirtualFn_GetName(vf);
4792  if (!(s && *s)) {
4793  GWEN_Buffer_free(tbuf);
4794  return GWEN_ERROR_BAD_DATA;
4795  }
4796  GWEN_Buffer_AppendString(tbuf, s);
4797  GWEN_Buffer_AppendString(tbuf, "Fn;\n");
4798 
4799  GWEN_Buffer_AppendString(tbuf, " p_struct->");
4800  s=Typemaker2_VirtualFn_GetName(vf);
4801  if (!(s && *s)) {
4802  GWEN_Buffer_free(tbuf);
4803  return GWEN_ERROR_BAD_DATA;
4804  }
4805  GWEN_Buffer_AppendString(tbuf, s);
4806  GWEN_Buffer_AppendString(tbuf, "Fn=fn;\n");
4807  GWEN_Buffer_AppendString(tbuf, " return oldFn;\n");
4808  GWEN_Buffer_AppendString(tbuf, "}\n");
4809 
4810  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4811  GWEN_Buffer_Reset(tbuf);
4812 
4813  vf=Typemaker2_VirtualFn_List_Next(vf);
4814  }
4815  }
4816 
4817  return 0;
4818 }
4819 
4820 
4821 
4822 static int _setEnumStringFns(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4823 {
4824  TYPEMAKER2_ENUM_LIST *enums;
4825  /* TYPEMAKER2_TYPEMANAGER *tym; */
4826  /* uint32_t flags; */
4827 
4828  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4829  enums=Typemaker2_Type_GetEnums(ty);
4830  /* flags=Typemaker2_Type_GetFlags(ty); */
4831 
4832  assert(enums);
4833  if (Typemaker2_Enum_List_GetCount(enums)) {
4834  TYPEMAKER2_ENUM *te;
4835 
4836  te=Typemaker2_Enum_List_First(enums);
4837  while (te) {
4838  const char *prefix;
4839  GWEN_BUFFER *tbuf;
4840 
4841  prefix=Typemaker2_Enum_GetPrefix(te);
4842  if (prefix==NULL || *prefix==0) {
4843  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
4844  return GWEN_ERROR_BAD_DATA;
4845  }
4846 
4847  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4848  if (prefix && *prefix) {
4849  GWEN_Buffer_AppendString(tbuf, prefix);
4850  if (prefix[strlen(prefix)-1]!='_')
4851  GWEN_Buffer_AppendString(tbuf, "_");
4852  }
4853  GWEN_Buffer_AppendString(tbuf, "fromString");
4854  Typemaker2_Enum_SetFromStringFn(te, GWEN_Buffer_GetStart(tbuf));
4855  GWEN_Buffer_Reset(tbuf);
4856 
4857  if (prefix && *prefix) {
4858  GWEN_Buffer_AppendString(tbuf, prefix);
4859  if (prefix[strlen(prefix)-1]!='_')
4860  GWEN_Buffer_AppendString(tbuf, "_");
4861  }
4862  GWEN_Buffer_AppendString(tbuf, "toString");
4863  Typemaker2_Enum_SetToStringFn(te, GWEN_Buffer_GetStart(tbuf));
4864  GWEN_Buffer_free(tbuf);
4865 
4866  te=Typemaker2_Enum_List_Next(te);
4867  }
4868  }
4869 
4870  return 0;
4871 }
4872 
4873 
4874 
4875 static int _buildEnumFromString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4876 {
4877  TYPEMAKER2_ENUM_LIST *enums;
4878  TYPEMAKER2_TYPEMANAGER *tym;
4879  /* uint32_t flags; */
4880 
4881  tym=Typemaker2_Builder_GetTypeManager(tb);
4882  enums=Typemaker2_Type_GetEnums(ty);
4883  /* flags=Typemaker2_Type_GetFlags(ty); */
4884 
4885  assert(enums);
4886  if (Typemaker2_Enum_List_GetCount(enums)) {
4887  GWEN_BUFFER *tbuf;
4888  const char *s;
4889  TYPEMAKER2_ENUM *te;
4890 
4891  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4892 
4893  te=Typemaker2_Enum_List_First(enums);
4894  while (te) {
4895  const char *prefix;
4896  const char *etype;
4897  TYPEMAKER2_ITEM *ti;
4898  int acc=TypeMaker2_Access_Public;
4899  int i;
4900 
4901  prefix=Typemaker2_Enum_GetPrefix(te);
4902  if (prefix==NULL || *prefix==0) {
4903  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
4904  GWEN_Buffer_free(tbuf);
4905  return GWEN_ERROR_BAD_DATA;
4906  }
4907 
4908  etype=Typemaker2_Enum_GetType(te);
4909 
4910  /* prototype */
4911  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4912  if (s) {
4913  GWEN_Buffer_AppendString(tbuf, s);
4914  GWEN_Buffer_AppendString(tbuf, " ");
4915  }
4916  if (etype && *etype) {
4917  GWEN_Buffer_AppendString(tbuf, etype);
4918  GWEN_Buffer_AppendString(tbuf, " ");
4919  }
4920  else
4921  GWEN_Buffer_AppendString(tbuf, "int ");
4922  if (prefix && *prefix) {
4923  GWEN_Buffer_AppendString(tbuf, prefix);
4924  if (prefix[strlen(prefix)-1]!='_')
4925  GWEN_Buffer_AppendString(tbuf, "_");
4926  }
4927  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s);\n");
4928  switch (acc) {
4929  case TypeMaker2_Access_Public:
4930  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4931  break;
4932  case TypeMaker2_Access_Library:
4933  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4934  break;
4935  case TypeMaker2_Access_Protected:
4936  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4937  break;
4938  case TypeMaker2_Access_Private:
4939  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4940  break;
4941  default:
4942  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4943  GWEN_Buffer_free(tbuf);
4944  return GWEN_ERROR_BAD_DATA;
4945  }
4946  GWEN_Buffer_Reset(tbuf);
4947 
4948  /* implementation */
4949  if (etype && *etype) {
4950  GWEN_Buffer_AppendString(tbuf, etype);
4951  GWEN_Buffer_AppendString(tbuf, " ");
4952  }
4953  else
4954  GWEN_Buffer_AppendString(tbuf, "int ");
4955  if (prefix && *prefix) {
4956  GWEN_Buffer_AppendString(tbuf, prefix);
4957  if (prefix[strlen(prefix)-1]!='_')
4958  GWEN_Buffer_AppendString(tbuf, "_");
4959  }
4960  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s) {\n");
4961 
4962  GWEN_Buffer_AppendString(tbuf, " if (p_s && *p_s) {\n");
4963 
4964  i=0;
4965  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
4966  while (ti) {
4967  GWEN_Buffer_AppendString(tbuf, " ");
4968  if (i++)
4969  GWEN_Buffer_AppendString(tbuf, "else ");
4970  GWEN_Buffer_AppendString(tbuf, "if (strcasecmp(p_s, \"");
4971  s=Typemaker2_Item_GetName(ti);
4972  if (s && *s) {
4973  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
4974  GWEN_Buffer_AppendString(tbuf, s+1);
4975  }
4976  GWEN_Buffer_AppendString(tbuf, "\")==0)\n");
4977  GWEN_Buffer_AppendString(tbuf, " return ");
4978  if (prefix)
4979  GWEN_Buffer_AppendString(tbuf, prefix);
4980  s=Typemaker2_Item_GetName(ti);
4981  if (s && *s) {
4982  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4983  GWEN_Buffer_AppendString(tbuf, s+1);
4984  }
4985  GWEN_Buffer_AppendString(tbuf, ";\n");
4986 
4987  ti=Typemaker2_Item_List_Next(ti);
4988  }
4989  GWEN_Buffer_AppendString(tbuf, " }\n");
4990  GWEN_Buffer_AppendString(tbuf, " return ");
4991  if (prefix)
4992  GWEN_Buffer_AppendString(tbuf, prefix);
4993  GWEN_Buffer_AppendString(tbuf, "Unknown;\n");
4994  GWEN_Buffer_AppendString(tbuf, "}\n");
4995 
4996  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4997  GWEN_Buffer_Reset(tbuf);
4998  te=Typemaker2_Enum_List_Next(te);
4999  }
5000  GWEN_Buffer_free(tbuf);
5001  } /* if enums */
5002 
5003  return 0;
5004 }
5005 
5006 
5007 
5008 static int _buildEnumToString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5009 {
5010  TYPEMAKER2_ENUM_LIST *enums;
5011  TYPEMAKER2_TYPEMANAGER *tym;
5012  /* uint32_t flags; */
5013 
5014  tym=Typemaker2_Builder_GetTypeManager(tb);
5015  enums=Typemaker2_Type_GetEnums(ty);
5016  /* flags=Typemaker2_Type_GetFlags(ty); */
5017 
5018  assert(enums);
5019  if (Typemaker2_Enum_List_GetCount(enums)) {
5020  GWEN_BUFFER *tbuf;
5021  const char *s;
5022  TYPEMAKER2_ENUM *te;
5023 
5024  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5025 
5026  te=Typemaker2_Enum_List_First(enums);
5027  while (te) {
5028  const char *prefix;
5029  const char *etype;
5030  TYPEMAKER2_ITEM *ti;
5031  int acc=TypeMaker2_Access_Public;
5032 
5033  prefix=Typemaker2_Enum_GetPrefix(te);
5034  if (prefix==NULL || *prefix==0) {
5035  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
5036  GWEN_Buffer_free(tbuf);
5037  return GWEN_ERROR_BAD_DATA;
5038  }
5039 
5040  etype=Typemaker2_Enum_GetType(te);
5041 
5042  /* prototype */
5043  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5044  if (s) {
5045  GWEN_Buffer_AppendString(tbuf, s);
5046  GWEN_Buffer_AppendString(tbuf, " ");
5047  }
5048  GWEN_Buffer_AppendString(tbuf, "const char *");
5049  if (prefix && *prefix) {
5050  GWEN_Buffer_AppendString(tbuf, prefix);
5051  if (prefix[strlen(prefix)-1]!='_')
5052  GWEN_Buffer_AppendString(tbuf, "_");
5053  }
5054  GWEN_Buffer_AppendString(tbuf, "toString(");
5055  if (etype && *etype)
5056  GWEN_Buffer_AppendString(tbuf, etype);
5057  else
5058  GWEN_Buffer_AppendString(tbuf, "int");
5059  GWEN_Buffer_AppendString(tbuf, " p_i);\n");
5060 
5061  switch (acc) {
5062  case TypeMaker2_Access_Public:
5063  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5064  break;
5065  case TypeMaker2_Access_Library:
5066  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5067  break;
5068  case TypeMaker2_Access_Protected:
5069  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5070  break;
5071  case TypeMaker2_Access_Private:
5072  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5073  break;
5074  default:
5075  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5076  GWEN_Buffer_free(tbuf);
5077  return GWEN_ERROR_BAD_DATA;
5078  }
5079  GWEN_Buffer_Reset(tbuf);
5080 
5081  /* implementation */
5082  GWEN_Buffer_AppendString(tbuf, "const char *");
5083  if (prefix && *prefix) {
5084  GWEN_Buffer_AppendString(tbuf, prefix);
5085  if (prefix[strlen(prefix)-1]!='_')
5086  GWEN_Buffer_AppendString(tbuf, "_");
5087  }
5088  GWEN_Buffer_AppendString(tbuf, "toString(");
5089  if (etype && *etype)
5090  GWEN_Buffer_AppendString(tbuf, etype);
5091  else
5092  GWEN_Buffer_AppendString(tbuf, "int");
5093  GWEN_Buffer_AppendString(tbuf, " p_i) {\n");
5094 
5095  GWEN_Buffer_AppendString(tbuf, " switch(p_i) {\n");
5096  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
5097  while (ti) {
5098  GWEN_Buffer_AppendString(tbuf, " case ");
5099  if (prefix)
5100  GWEN_Buffer_AppendString(tbuf, prefix);
5101  s=Typemaker2_Item_GetName(ti);
5102  if (s && *s) {
5103  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5104  GWEN_Buffer_AppendString(tbuf, s+1);
5105  }
5106  GWEN_Buffer_AppendString(tbuf, ": return \"");
5107  s=Typemaker2_Item_GetName(ti);
5108  if (s && *s) {
5109  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
5110  GWEN_Buffer_AppendString(tbuf, s+1);
5111  }
5112  GWEN_Buffer_AppendString(tbuf, "\";\n");
5113 
5114  ti=Typemaker2_Item_List_Next(ti);
5115  }
5116 
5117  /* handle "unknown" */
5118  GWEN_Buffer_AppendString(tbuf, " case ");
5119  if (prefix)
5120  GWEN_Buffer_AppendString(tbuf, prefix);
5121  GWEN_Buffer_AppendString(tbuf, "Unknown:\n");
5122 
5123  /* handle default */
5124  GWEN_Buffer_AppendString(tbuf, " default: return \"unknown\";\n");
5125  GWEN_Buffer_AppendString(tbuf, " }\n");
5126  GWEN_Buffer_AppendString(tbuf, "}\n");
5127 
5128  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5129  GWEN_Buffer_Reset(tbuf);
5130  te=Typemaker2_Enum_List_Next(te);
5131  }
5132  GWEN_Buffer_free(tbuf);
5133  } /* if enums */
5134 
5135  return 0;
5136 }
5137 
5138 
5139 
5140 static int _buildList1GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5141 {
5142  GWEN_BUFFER *tbuf;
5143  const char *s;
5144  /* uint32_t flags; */
5145  TYPEMAKER2_TYPEMANAGER *tym;
5146  TYPEMAKER2_TYPE *mty;
5147 
5148  tym=Typemaker2_Builder_GetTypeManager(tb);
5149  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5150 
5151  /* flags=Typemaker2_Type_GetFlags(ty); */
5152 
5153  mty=Typemaker2_Member_GetTypePtr(tm);
5154  assert(mty);
5155 
5156  /* prototype */
5157  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5158  if (s) {
5159  GWEN_Buffer_AppendString(tbuf, s);
5160  GWEN_Buffer_AppendString(tbuf, " ");
5161  }
5162 
5163  s=Typemaker2_Type_GetIdentifier(ty);
5164  GWEN_Buffer_AppendString(tbuf, s);
5165  GWEN_Buffer_AppendString(tbuf, " *");
5166 
5167  s=Typemaker2_Type_GetPrefix(ty);
5168  GWEN_Buffer_AppendString(tbuf, s);
5169  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5170  GWEN_Buffer_AppendString(tbuf, "By");
5171  s=Typemaker2_Member_GetName(tm);
5172  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5173  GWEN_Buffer_AppendString(tbuf, s+1);
5174  GWEN_Buffer_AppendString(tbuf, "(const ");
5175  s=Typemaker2_Type_GetIdentifier(ty);
5176  GWEN_Buffer_AppendString(tbuf, s);
5177  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5178  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5179  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5180  GWEN_Buffer_AppendString(tbuf, " const ");
5181  s=Typemaker2_Type_GetIdentifier(mty);
5182  GWEN_Buffer_AppendString(tbuf, s);
5183  GWEN_Buffer_AppendString(tbuf, " *");
5184  }
5185  else {
5186  s=Typemaker2_Type_GetIdentifier(mty);
5187  GWEN_Buffer_AppendString(tbuf, s);
5188  GWEN_Buffer_AppendString(tbuf, " ");
5189  }
5190  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5191 
5192  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5193  GWEN_Buffer_Reset(tbuf);
5194 
5195  /* implementation */
5196  s=Typemaker2_Type_GetIdentifier(ty);
5197  GWEN_Buffer_AppendString(tbuf, s);
5198  GWEN_Buffer_AppendString(tbuf, " *");
5199 
5200  s=Typemaker2_Type_GetPrefix(ty);
5201  GWEN_Buffer_AppendString(tbuf, s);
5202  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5203  GWEN_Buffer_AppendString(tbuf, "By");
5204  s=Typemaker2_Member_GetName(tm);
5205  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5206  GWEN_Buffer_AppendString(tbuf, s+1);
5207  GWEN_Buffer_AppendString(tbuf, "(const ");
5208  s=Typemaker2_Type_GetIdentifier(ty);
5209  GWEN_Buffer_AppendString(tbuf, s);
5210  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5211  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5212  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5213  GWEN_Buffer_AppendString(tbuf, " const ");
5214  s=Typemaker2_Type_GetIdentifier(mty);
5215  GWEN_Buffer_AppendString(tbuf, s);
5216  GWEN_Buffer_AppendString(tbuf, " *");
5217  }
5218  else {
5219  s=Typemaker2_Type_GetIdentifier(mty);
5220  GWEN_Buffer_AppendString(tbuf, s);
5221  GWEN_Buffer_AppendString(tbuf, " ");
5222  }
5223  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5224 
5225  GWEN_Buffer_AppendString(tbuf, " ");
5226  s=Typemaker2_Type_GetIdentifier(ty);
5227  GWEN_Buffer_AppendString(tbuf, s);
5228  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5229  GWEN_Buffer_AppendString(tbuf, "\n");
5230 
5231  GWEN_Buffer_AppendString(tbuf, " assert(p_list);\n");
5232  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5233  s=Typemaker2_Type_GetPrefix(ty);
5234  GWEN_Buffer_AppendString(tbuf, s);
5235  GWEN_Buffer_AppendString(tbuf, "_List_First(p_list);\n");
5236  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5237  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5238  GWEN_Buffer_AppendString(tbuf, "\n");
5239 
5240  GWEN_Buffer_AppendString(tbuf, " ");
5241  if (1) {
5242  GWEN_BUFFER *dstbuf;
5243  GWEN_BUFFER *srcbuf;
5244  int rv;
5245 
5246  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5247  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5248 
5249  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5250  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5251  s=Typemaker2_Member_GetName(tm);
5252  GWEN_Buffer_AppendString(dstbuf, s);
5253 
5254  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5255  GWEN_Buffer_GetStart(srcbuf),
5256  GWEN_Buffer_GetStart(dstbuf),
5257  tbuf);
5258  if (rv<0) {
5259  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5260  GWEN_Buffer_free(srcbuf);
5261  GWEN_Buffer_free(dstbuf);
5262  GWEN_Buffer_free(tbuf);
5263  return rv;
5264  }
5265  GWEN_Buffer_AppendString(tbuf, "\n");
5266  GWEN_Buffer_free(srcbuf);
5267  GWEN_Buffer_free(dstbuf);
5268  }
5269 
5270 
5271  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5272  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5273 
5274  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5275  s=Typemaker2_Type_GetPrefix(ty);
5276  GWEN_Buffer_AppendString(tbuf, s);
5277  GWEN_Buffer_AppendString(tbuf, "_List_Next(p_struct);\n");
5278 
5279  GWEN_Buffer_AppendString(tbuf, " }\n");
5280 
5281  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5282  GWEN_Buffer_AppendString(tbuf, "}\n");
5283 
5284  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5285  GWEN_Buffer_free(tbuf);
5286 
5287  return 0;
5288 }
5289 
5290 
5291 
5292 static int _buildTreeGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5293 {
5294  GWEN_BUFFER *tbuf;
5295  const char *s;
5296  /* uint32_t flags; */
5297  TYPEMAKER2_TYPEMANAGER *tym;
5298  TYPEMAKER2_TYPE *mty;
5299 
5300  tym=Typemaker2_Builder_GetTypeManager(tb);
5301  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5302 
5303  /* flags=Typemaker2_Type_GetFlags(ty); */
5304 
5305  mty=Typemaker2_Member_GetTypePtr(tm);
5306  assert(mty);
5307 
5308  /* prototype */
5309  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5310  if (s) {
5311  GWEN_Buffer_AppendString(tbuf, s);
5312  GWEN_Buffer_AppendString(tbuf, " ");
5313  }
5314 
5315  s=Typemaker2_Type_GetIdentifier(ty);
5316  GWEN_Buffer_AppendString(tbuf, s);
5317  GWEN_Buffer_AppendString(tbuf, " *");
5318 
5319  s=Typemaker2_Type_GetPrefix(ty);
5320  GWEN_Buffer_AppendString(tbuf, s);
5321  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5322  GWEN_Buffer_AppendString(tbuf, "By");
5323  s=Typemaker2_Member_GetName(tm);
5324  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5325  GWEN_Buffer_AppendString(tbuf, s+1);
5326  GWEN_Buffer_AppendString(tbuf, "(const ");
5327  s=Typemaker2_Type_GetIdentifier(ty);
5328  GWEN_Buffer_AppendString(tbuf, s);
5329  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5330  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5331  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5332  GWEN_Buffer_AppendString(tbuf, " const ");
5333  s=Typemaker2_Type_GetIdentifier(mty);
5334  GWEN_Buffer_AppendString(tbuf, s);
5335  GWEN_Buffer_AppendString(tbuf, " *");
5336  }
5337  else {
5338  s=Typemaker2_Type_GetIdentifier(mty);
5339  GWEN_Buffer_AppendString(tbuf, s);
5340  GWEN_Buffer_AppendString(tbuf, " ");
5341  }
5342  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5343 
5344  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5345  GWEN_Buffer_Reset(tbuf);
5346 
5347  /* implementation */
5348  s=Typemaker2_Type_GetIdentifier(ty);
5349  GWEN_Buffer_AppendString(tbuf, s);
5350  GWEN_Buffer_AppendString(tbuf, " *");
5351 
5352  s=Typemaker2_Type_GetPrefix(ty);
5353  GWEN_Buffer_AppendString(tbuf, s);
5354  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5355  GWEN_Buffer_AppendString(tbuf, "By");
5356  s=Typemaker2_Member_GetName(tm);
5357  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5358  GWEN_Buffer_AppendString(tbuf, s+1);
5359  GWEN_Buffer_AppendString(tbuf, "(const ");
5360  s=Typemaker2_Type_GetIdentifier(ty);
5361  GWEN_Buffer_AppendString(tbuf, s);
5362  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5363  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5364  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5365  GWEN_Buffer_AppendString(tbuf, " const ");
5366  s=Typemaker2_Type_GetIdentifier(mty);
5367  GWEN_Buffer_AppendString(tbuf, s);
5368  GWEN_Buffer_AppendString(tbuf, " *");
5369  }
5370  else {
5371  s=Typemaker2_Type_GetIdentifier(mty);
5372  GWEN_Buffer_AppendString(tbuf, s);
5373  GWEN_Buffer_AppendString(tbuf, " ");
5374  }
5375  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5376 
5377  GWEN_Buffer_AppendString(tbuf, " ");
5378  s=Typemaker2_Type_GetIdentifier(ty);
5379  GWEN_Buffer_AppendString(tbuf, s);
5380  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5381  GWEN_Buffer_AppendString(tbuf, "\n");
5382 
5383  GWEN_Buffer_AppendString(tbuf, " assert(p_tree);\n");
5384  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5385  s=Typemaker2_Type_GetPrefix(ty);
5386  GWEN_Buffer_AppendString(tbuf, s);
5387  GWEN_Buffer_AppendString(tbuf, "_Tree_GetFirst(p_tree);\n");
5388  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5389  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5390  GWEN_Buffer_AppendString(tbuf, "\n");
5391 
5392  GWEN_Buffer_AppendString(tbuf, " ");
5393  if (1) {
5394  GWEN_BUFFER *dstbuf;
5395  GWEN_BUFFER *srcbuf;
5396  int rv;
5397 
5398  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5399  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5400 
5401  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5402  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5403  s=Typemaker2_Member_GetName(tm);
5404  GWEN_Buffer_AppendString(dstbuf, s);
5405 
5406  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5407  GWEN_Buffer_GetStart(srcbuf),
5408  GWEN_Buffer_GetStart(dstbuf),
5409  tbuf);
5410  if (rv<0) {
5411  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5412  GWEN_Buffer_free(srcbuf);
5413  GWEN_Buffer_free(dstbuf);
5414  GWEN_Buffer_free(tbuf);
5415  return rv;
5416  }
5417  GWEN_Buffer_AppendString(tbuf, "\n");
5418  GWEN_Buffer_free(srcbuf);
5419  GWEN_Buffer_free(dstbuf);
5420  }
5421 
5422 
5423  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5424  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5425 
5426  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5427  s=Typemaker2_Type_GetPrefix(ty);
5428  GWEN_Buffer_AppendString(tbuf, s);
5429  GWEN_Buffer_AppendString(tbuf, "_Tree_GetBelow(p_struct);\n");
5430 
5431  GWEN_Buffer_AppendString(tbuf, " }\n");
5432 
5433  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5434  GWEN_Buffer_AppendString(tbuf, "}\n");
5435 
5436  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5437  GWEN_Buffer_free(tbuf);
5438 
5439  return 0;
5440 }
5441 
5442 
5443 
5444 static int _buildTree2GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5445 {
5446  GWEN_BUFFER *tbuf;
5447  const char *s;
5448  /* uint32_t flags; */
5449  TYPEMAKER2_TYPEMANAGER *tym;
5450  TYPEMAKER2_TYPE *mty;
5451 
5452  tym=Typemaker2_Builder_GetTypeManager(tb);
5453  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5454 
5455  /* flags=Typemaker2_Type_GetFlags(ty); */
5456 
5457  mty=Typemaker2_Member_GetTypePtr(tm);
5458  assert(mty);
5459 
5460  /* prototype */
5461  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5462  if (s) {
5463  GWEN_Buffer_AppendString(tbuf, s);
5464  GWEN_Buffer_AppendString(tbuf, " ");
5465  }
5466 
5467  s=Typemaker2_Type_GetIdentifier(ty);
5468  GWEN_Buffer_AppendString(tbuf, s);
5469  GWEN_Buffer_AppendString(tbuf, " *");
5470 
5471  s=Typemaker2_Type_GetPrefix(ty);
5472  GWEN_Buffer_AppendString(tbuf, s);
5473  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5474  GWEN_Buffer_AppendString(tbuf, "By");
5475  s=Typemaker2_Member_GetName(tm);
5476  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5477  GWEN_Buffer_AppendString(tbuf, s+1);
5478  GWEN_Buffer_AppendString(tbuf, "(const ");
5479  s=Typemaker2_Type_GetIdentifier(ty);
5480  GWEN_Buffer_AppendString(tbuf, s);
5481  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5482  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5483  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5484  GWEN_Buffer_AppendString(tbuf, " const ");
5485  s=Typemaker2_Type_GetIdentifier(mty);
5486  GWEN_Buffer_AppendString(tbuf, s);
5487  GWEN_Buffer_AppendString(tbuf, " *");
5488  }
5489  else {
5490  s=Typemaker2_Type_GetIdentifier(mty);
5491  GWEN_Buffer_AppendString(tbuf, s);
5492  GWEN_Buffer_AppendString(tbuf, " ");
5493  }
5494  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5495 
5496  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5497  GWEN_Buffer_Reset(tbuf);
5498 
5499  /* implementation */
5500  s=Typemaker2_Type_GetIdentifier(ty);
5501  GWEN_Buffer_AppendString(tbuf, s);
5502  GWEN_Buffer_AppendString(tbuf, " *");
5503 
5504  s=Typemaker2_Type_GetPrefix(ty);
5505  GWEN_Buffer_AppendString(tbuf, s);
5506  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5507  GWEN_Buffer_AppendString(tbuf, "By");
5508  s=Typemaker2_Member_GetName(tm);
5509  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5510  GWEN_Buffer_AppendString(tbuf, s+1);
5511  GWEN_Buffer_AppendString(tbuf, "(const ");
5512  s=Typemaker2_Type_GetIdentifier(ty);
5513  GWEN_Buffer_AppendString(tbuf, s);
5514  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5515  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5516  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5517  GWEN_Buffer_AppendString(tbuf, " const ");
5518  s=Typemaker2_Type_GetIdentifier(mty);
5519  GWEN_Buffer_AppendString(tbuf, s);
5520  GWEN_Buffer_AppendString(tbuf, " *");
5521  }
5522  else {
5523  s=Typemaker2_Type_GetIdentifier(mty);
5524  GWEN_Buffer_AppendString(tbuf, s);
5525  GWEN_Buffer_AppendString(tbuf, " ");
5526  }
5527  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5528 
5529  GWEN_Buffer_AppendString(tbuf, " ");
5530  s=Typemaker2_Type_GetIdentifier(ty);
5531  GWEN_Buffer_AppendString(tbuf, s);
5532  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5533  GWEN_Buffer_AppendString(tbuf, "\n");
5534 
5535  GWEN_Buffer_AppendString(tbuf, " assert(p_object);\n");
5536  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5537  s=Typemaker2_Type_GetPrefix(ty);
5538  GWEN_Buffer_AppendString(tbuf, s);
5539  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetFirstChild(p_object);\n");
5540  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5541  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5542  GWEN_Buffer_AppendString(tbuf, "\n");
5543 
5544  GWEN_Buffer_AppendString(tbuf, " ");
5545  if (1) {
5546  GWEN_BUFFER *dstbuf;
5547  GWEN_BUFFER *srcbuf;
5548  int rv;
5549 
5550  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5551  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5552 
5553  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5554  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5555  s=Typemaker2_Member_GetName(tm);
5556  GWEN_Buffer_AppendString(dstbuf, s);
5557 
5558  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5559  GWEN_Buffer_GetStart(srcbuf),
5560  GWEN_Buffer_GetStart(dstbuf),
5561  tbuf);
5562  if (rv<0) {
5563  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5564  GWEN_Buffer_free(srcbuf);
5565  GWEN_Buffer_free(dstbuf);
5566  GWEN_Buffer_free(tbuf);
5567  return rv;
5568  }
5569  GWEN_Buffer_AppendString(tbuf, "\n");
5570  GWEN_Buffer_free(srcbuf);
5571  GWEN_Buffer_free(dstbuf);
5572  }
5573 
5574 
5575  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5576  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5577 
5578  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5579  s=Typemaker2_Type_GetPrefix(ty);
5580  GWEN_Buffer_AppendString(tbuf, s);
5581  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetBelow(p_struct);\n");
5582 
5583  GWEN_Buffer_AppendString(tbuf, " }\n");
5584 
5585  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5586  GWEN_Buffer_AppendString(tbuf, "}\n");
5587 
5588  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5589  GWEN_Buffer_free(tbuf);
5590 
5591  return 0;
5592 }
5593 
5594 
5595 
5596 static int _buildGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5597 {
5598  GWEN_BUFFER *tbuf;
5599  TYPEMAKER2_MEMBER_LIST *tml;
5600  uint32_t flags;
5601  /* TYPEMAKER2_TYPEMANAGER *tym; */
5602 
5603  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5604  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5605 
5606  flags=Typemaker2_Type_GetFlags(ty);
5607 
5608  tml=Typemaker2_Type_GetMembers(ty);
5609  if (tml) {
5610  TYPEMAKER2_MEMBER *tm;
5611 
5612  tm=Typemaker2_Member_List_First(tml);
5613  while (tm) {
5614  TYPEMAKER2_TYPE *mty;
5615  int rv;
5616 
5617  mty=Typemaker2_Member_GetTypePtr(tm);
5618  assert(mty);
5619 
5620  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_GETBYMEMBER) {
5621  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
5622  rv=_buildList1GetByMember(tb, ty, tm);
5623  if (rv<0) {
5624  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5625  return rv;
5626  }
5627  }
5628 
5629  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
5630  rv=_buildTreeGetByMember(tb, ty, tm);
5631  if (rv<0) {
5632  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5633  return rv;
5634  }
5635  }
5636 
5637  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
5638  rv=_buildTree2GetByMember(tb, ty, tm);
5639  if (rv<0) {
5640  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5641  return rv;
5642  }
5643  }
5644 
5645  }
5646  tm=Typemaker2_Member_List_Next(tm);
5647  }
5648  GWEN_Buffer_AppendString(tbuf, " return p_cl;\n");
5649  }
5650 
5651  return 0;
5652 }
5653 
5654 
5655 
5656 static int _buildList1SortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5657 {
5658  GWEN_BUFFER *tbuf;
5659  const char *s;
5660  /* uint32_t flags; */
5661  TYPEMAKER2_TYPEMANAGER *tym;
5662  TYPEMAKER2_TYPE *mty;
5663 
5664  tym=Typemaker2_Builder_GetTypeManager(tb);
5665  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5666 
5667  /* flags=Typemaker2_Type_GetFlags(ty); */
5668 
5669  mty=Typemaker2_Member_GetTypePtr(tm);
5670  assert(mty);
5671 
5672  /* ==== prototypes ========================================================*/
5673  /* ---- _List_SortByMember ----------------------------------------------- */
5674  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5675  if (s) {
5676  GWEN_Buffer_AppendString(tbuf, s);
5677  GWEN_Buffer_AppendString(tbuf, " ");
5678  }
5679 
5680  /* return type */
5681  GWEN_Buffer_AppendString(tbuf, "void ");
5682 
5683  /* function name */
5684  s=Typemaker2_Type_GetPrefix(ty);
5685  GWEN_Buffer_AppendString(tbuf, s);
5686  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5687  s=Typemaker2_Member_GetName(tm);
5688  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5689  GWEN_Buffer_AppendString(tbuf, s+1);
5690 
5691  /* argument list */
5692  GWEN_Buffer_AppendString(tbuf, "(");
5693  s=Typemaker2_Type_GetIdentifier(ty);
5694  GWEN_Buffer_AppendString(tbuf, s);
5695  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending);\n");
5696 
5697  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5698  GWEN_Buffer_Reset(tbuf);
5699 
5700 
5701  /* ---- _List_Compare_Member --------------------------------------------- */
5702  /* return type */
5703  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5704 
5705  /* function name */
5706  s=Typemaker2_Type_GetPrefix(ty);
5707  GWEN_Buffer_AppendString(tbuf, s);
5708  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5709  s=Typemaker2_Member_GetName(tm);
5710  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5711  GWEN_Buffer_AppendString(tbuf, s+1);
5712 
5713  /* argument list */
5714  GWEN_Buffer_AppendString(tbuf, "(const ");
5715  s=Typemaker2_Type_GetIdentifier(ty);
5716  GWEN_Buffer_AppendString(tbuf, s);
5717  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5718  GWEN_Buffer_AppendString(tbuf, "const ");
5719  GWEN_Buffer_AppendString(tbuf, s);
5720  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5721  GWEN_Buffer_AppendString(tbuf, "int p_ascending);\n");
5722 
5723  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5724  GWEN_Buffer_Reset(tbuf);
5725 
5726 
5727  /* ==== implementations =================================================== */
5728  /* ---- _List_SortByMember ----------------------------------------------- */
5729  /* return type */
5730  GWEN_Buffer_AppendString(tbuf, "void ");
5731 
5732  /* function name */
5733  s=Typemaker2_Type_GetPrefix(ty);
5734  GWEN_Buffer_AppendString(tbuf, s);
5735  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5736  s=Typemaker2_Member_GetName(tm);
5737  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5738  GWEN_Buffer_AppendString(tbuf, s+1);
5739 
5740  /* argument list */
5741  GWEN_Buffer_AppendString(tbuf, "(");
5742  s=Typemaker2_Type_GetIdentifier(ty);
5743  GWEN_Buffer_AppendString(tbuf, s);
5744  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending) {\n");
5745 
5746 
5747  GWEN_Buffer_AppendString(tbuf, " ");
5748 
5749  s=Typemaker2_Type_GetIdentifier(ty);
5750  GWEN_Buffer_AppendString(tbuf, s);
5751  GWEN_Buffer_AppendString(tbuf, "_LIST_SORT_FN oldSortFn;\n");
5752 
5753  GWEN_Buffer_AppendString(tbuf, "\n");
5754  GWEN_Buffer_AppendString(tbuf, " oldSortFn=");
5755  s=Typemaker2_Type_GetPrefix(ty);
5756  GWEN_Buffer_AppendString(tbuf, s);
5757  GWEN_Buffer_AppendString(tbuf, "_List_SetSortFn(p_list, ");
5758 
5759  s=Typemaker2_Type_GetPrefix(ty);
5760  GWEN_Buffer_AppendString(tbuf, s);
5761  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5762  s=Typemaker2_Member_GetName(tm);
5763  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5764  GWEN_Buffer_AppendString(tbuf, s+1);
5765  GWEN_Buffer_AppendString(tbuf, ");\n");
5766 
5767  GWEN_Buffer_AppendString(tbuf, " ");
5768  s=Typemaker2_Type_GetPrefix(ty);
5769  GWEN_Buffer_AppendString(tbuf, s);
5770  GWEN_Buffer_AppendString(tbuf, "_List_Sort(p_list, p_ascending);\n");
5771 
5772  GWEN_Buffer_AppendString(tbuf, " ");
5773  s=Typemaker2_Type_GetPrefix(ty);
5774  GWEN_Buffer_AppendString(tbuf, s);
5775  GWEN_Buffer_AppendString(tbuf, "_List_SetSortFn(p_list, oldSortFn);\n");
5776 
5777  GWEN_Buffer_AppendString(tbuf, "}\n");
5778 
5779  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5780  GWEN_Buffer_Reset(tbuf);
5781 
5782 
5783  /* ---- _List_Compare_Member --------------------------------------------- */
5784  /* return type */
5785  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5786 
5787  /* function name */
5788  s=Typemaker2_Type_GetPrefix(ty);
5789  GWEN_Buffer_AppendString(tbuf, s);
5790  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5791  s=Typemaker2_Member_GetName(tm);
5792  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5793  GWEN_Buffer_AppendString(tbuf, s+1);
5794 
5795  /* argument list */
5796  GWEN_Buffer_AppendString(tbuf, "(const ");
5797  s=Typemaker2_Type_GetIdentifier(ty);
5798  GWEN_Buffer_AppendString(tbuf, s);
5799  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5800  GWEN_Buffer_AppendString(tbuf, "const ");
5801  GWEN_Buffer_AppendString(tbuf, s);
5802  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5803  GWEN_Buffer_AppendString(tbuf, "int p_ascending) {\n");
5804 
5805  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5806  GWEN_Buffer_AppendString(tbuf, "\n");
5807 
5808  if (1) {
5809  GWEN_BUFFER *dstbuf;
5810  GWEN_BUFFER *srcbuf;
5811  int rv;
5812 
5813  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5814  GWEN_Buffer_AppendString(srcbuf, "p_a->");
5815  s=Typemaker2_Member_GetName(tm);
5816  GWEN_Buffer_AppendString(srcbuf, s);
5817 
5818 
5819  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5820  GWEN_Buffer_AppendString(dstbuf, "p_b->");
5821  s=Typemaker2_Member_GetName(tm);
5822  GWEN_Buffer_AppendString(dstbuf, s);
5823 
5824  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5825  GWEN_Buffer_GetStart(srcbuf),
5826  GWEN_Buffer_GetStart(dstbuf),
5827  tbuf);
5828  if (rv<0) {
5829  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5830  GWEN_Buffer_free(srcbuf);
5831  GWEN_Buffer_free(dstbuf);
5832  GWEN_Buffer_free(tbuf);
5833  return rv;
5834  }
5835  GWEN_Buffer_AppendString(tbuf, "\n");
5836  GWEN_Buffer_free(srcbuf);
5837  GWEN_Buffer_free(dstbuf);
5838  }
5839 
5840  GWEN_Buffer_AppendString(tbuf, " if (p_ascending)\n");
5841  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
5842  GWEN_Buffer_AppendString(tbuf, " else\n");
5843  GWEN_Buffer_AppendString(tbuf, " return -p_rv;\n");
5844  GWEN_Buffer_AppendString(tbuf, "}\n");
5845 
5846  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5847  GWEN_Buffer_free(tbuf);
5848 
5849  return 0;
5850 }
5851 
5852 
5853 
5854 static int _buildSortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5855 {
5856  TYPEMAKER2_MEMBER_LIST *tml;
5857  uint32_t flags;
5858  /* TYPEMAKER2_TYPEMANAGER *tym; */
5859 
5860  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5861 
5862  flags=Typemaker2_Type_GetFlags(ty);
5863 
5864  tml=Typemaker2_Type_GetMembers(ty);
5865  if (tml) {
5866  TYPEMAKER2_MEMBER *tm;
5867 
5868  tm=Typemaker2_Member_List_First(tml);
5869  while (tm) {
5870  TYPEMAKER2_TYPE *mty;
5871  int rv;
5872 
5873  mty=Typemaker2_Member_GetTypePtr(tm);
5874  assert(mty);
5875 
5876  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_SORTBYMEMBER) {
5877  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
5878  rv=_buildList1SortByMember(tb, ty, tm);
5879  if (rv<0) {
5880  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5881  return rv;
5882  }
5883  }
5884  }
5885  tm=Typemaker2_Member_List_Next(tm);
5886  }
5887  }
5888 
5889  return 0;
5890 }
5891 
5892 
5893 
5894 static int _buildDefineDefines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5895 {
5896  TYPEMAKER2_DEFINE_LIST *defines;
5897  /* TYPEMAKER2_TYPEMANAGER *tym; */
5898  /* uint32_t flags; */
5899 
5900  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5901  defines=Typemaker2_Type_GetDefines(ty);
5902  /* flags=Typemaker2_Type_GetFlags(ty); */
5903 
5904  assert(defines);
5905  if (Typemaker2_Define_List_GetCount(defines)) {
5906  GWEN_BUFFER *tbuf;
5907  const char *s;
5908  TYPEMAKER2_DEFINE *td;
5909 
5910  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5911 
5912  td=Typemaker2_Define_List_First(defines);
5913  while (td) {
5914  const char *prefix;
5915  TYPEMAKER2_ITEM *ti;
5916  int access=TypeMaker2_Access_Public;
5917  int j=Typemaker2_Define_GetStartValue(td);
5918 
5919  GWEN_Buffer_AppendString(tbuf, "/* define ");
5920  s=Typemaker2_Define_GetId(td);
5921  if (s && *s)
5922  GWEN_Buffer_AppendString(tbuf, s);
5923  GWEN_Buffer_AppendString(tbuf, " */\n");
5924 
5925  prefix=Typemaker2_Define_GetPrefix(td);
5926  if (prefix==NULL || *prefix==0) {
5927  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in define definition");
5928  GWEN_Buffer_free(tbuf);
5929  return GWEN_ERROR_BAD_DATA;
5930  }
5931 
5932  ti=Typemaker2_Item_List_First(Typemaker2_Define_GetItems(td));
5933  while (ti) {
5934  GWEN_Buffer_AppendString(tbuf, "#define ");
5935  if (prefix)
5936  GWEN_Buffer_AppendString(tbuf, prefix);
5937  s=Typemaker2_Item_GetName(ti);
5938  if (s && *s) {
5939  GWEN_Buffer_AppendString(tbuf, s);
5940  }
5941  s=Typemaker2_Item_GetValue(ti);
5942  if (s) {
5943  GWEN_Buffer_AppendString(tbuf, " ");
5944  GWEN_Buffer_AppendString(tbuf, s);
5945  }
5946  else {
5947  char numbuf[32];
5948  int k=0;
5949 
5950  switch (Typemaker2_Define_GetMode(td)) {
5951  case Typemaker2_Define_Mode_BitField:
5952  k=1<<j;
5953  break;
5954  case Typemaker2_Define_Mode_Sequence:
5955  default:
5956  k=j;
5957  }
5958  snprintf(numbuf, sizeof(numbuf)-1, "%d", k);
5959  numbuf[sizeof(numbuf)-1]=0;
5960  GWEN_Buffer_AppendString(tbuf, " ");
5961  GWEN_Buffer_AppendString(tbuf, numbuf);
5962  j++;
5963  }
5964 
5965  GWEN_Buffer_AppendString(tbuf, "\n");
5966  ti=Typemaker2_Item_List_Next(ti);
5967  }
5968  GWEN_Buffer_AppendString(tbuf, "\n");
5969 
5970  switch (access) {
5971  case TypeMaker2_Access_Public:
5972  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5973  break;
5974  case TypeMaker2_Access_Library:
5975  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5976  break;
5977  case TypeMaker2_Access_Protected:
5978  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5979  break;
5980  case TypeMaker2_Access_Private:
5981  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5982  break;
5983  default:
5984  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5985  GWEN_Buffer_free(tbuf);
5986  return GWEN_ERROR_BAD_DATA;
5987  }
5988  GWEN_Buffer_Reset(tbuf);
5989 
5990  td=Typemaker2_Define_List_Next(td);
5991  }
5992  }
5993  return 0;
5994 }
5995 
5996 
5997 
5998 static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5999 {
6000  GWEN_BUFFER *tbuf;
6001  const char *s;
6002  /* uint32_t flags; */
6003  TYPEMAKER2_TYPEMANAGER *tym;
6004  TYPEMAKER2_MEMBER_LIST *tml;
6005 
6006  tym=Typemaker2_Builder_GetTypeManager(tb);
6007  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6008 
6009  /* flags=Typemaker2_Type_GetFlags(ty); */
6010 
6011  /* prototype */
6012  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6013  if (s) {
6014  GWEN_Buffer_AppendString(tbuf, s);
6015  GWEN_Buffer_AppendString(tbuf, " ");
6016  }
6017 
6018  GWEN_Buffer_AppendString(tbuf, "void ");
6019  s=Typemaker2_Type_GetPrefix(ty);
6020  GWEN_Buffer_AppendString(tbuf, s);
6021  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6022  GWEN_Buffer_AppendString(tbuf, "(const ");
6023  s=Typemaker2_Type_GetIdentifier(ty);
6024  GWEN_Buffer_AppendString(tbuf, s);
6025  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer);\n");
6026 
6027  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6028  GWEN_Buffer_Reset(tbuf);
6029 
6030  /* implementation */
6031  GWEN_Buffer_AppendString(tbuf, "void ");
6032  s=Typemaker2_Type_GetPrefix(ty);
6033  GWEN_Buffer_AppendString(tbuf, s);
6034  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6035  GWEN_Buffer_AppendString(tbuf, "(const ");
6036  s=Typemaker2_Type_GetIdentifier(ty);
6037  GWEN_Buffer_AppendString(tbuf, s);
6038  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer) {\n");
6039 
6040  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6041 
6042 
6043  tml=Typemaker2_Type_GetMembers(ty);
6044  if (tml) {
6045  TYPEMAKER2_MEMBER *tm;
6046 
6047  tm=Typemaker2_Member_List_First(tml);
6048  while (tm) {
6049  TYPEMAKER2_TYPE *mty;
6050 
6051  mty=Typemaker2_Member_GetTypePtr(tm);
6052  assert(mty);
6053 
6054  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_HASH) {
6055  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6056  s=Typemaker2_Member_GetName(tm);
6057  GWEN_Buffer_AppendString(tbuf, s);
6058  GWEN_Buffer_AppendString(tbuf, "\" */\n");
6059 
6060  /* toHashString */
6061  if (1) {
6062  GWEN_BUFFER *srcbuf;
6063  int rv;
6064 
6065  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
6066  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
6067  s=Typemaker2_Member_GetName(tm);
6068  GWEN_Buffer_AppendString(srcbuf, s);
6069 
6070  GWEN_Buffer_AppendString(tbuf, " ");
6071  rv=Typemaker2_Builder_Invoke_ToHashStringFn(tb, ty, tm,
6072  GWEN_Buffer_GetStart(srcbuf),
6073  NULL, /* no dest */
6074  tbuf);
6075  if (rv<0) {
6076  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6077  GWEN_Buffer_free(srcbuf);
6078  GWEN_Buffer_free(tbuf);
6079  return rv;
6080  }
6081  GWEN_Buffer_AppendString(tbuf, "\n");
6082  GWEN_Buffer_free(srcbuf);
6083  }
6084 
6085  GWEN_Buffer_AppendString(tbuf, " GWEN_Buffer_AppendByte(p_buffer, \':\');\n");
6086  }
6087  else {
6088  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6089  s=Typemaker2_Member_GetName(tm);
6090  GWEN_Buffer_AppendString(tbuf, s);
6091  GWEN_Buffer_AppendString(tbuf, "\" does not have the with_hash flag, ignoring */\n");
6092  }
6093 
6094  tm=Typemaker2_Member_List_Next(tm);
6095  }
6096  }
6097 
6098 
6099  GWEN_Buffer_AppendString(tbuf, "}\n");
6100 
6101  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6102  GWEN_Buffer_free(tbuf);
6103 
6104  return 0;
6105 }
6106 
6107 
6108 
6109 static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6110 {
6111  GWEN_BUFFER *tbuf;
6112  uint32_t flags;
6113  /* TYPEMAKER2_TYPEMANAGER *tym; */
6114 
6115  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6116  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6117 
6118  flags=Typemaker2_Type_GetFlags(ty);
6119 
6120  while (ty) {
6121  TYPEMAKER2_INLINE *ti;
6122 
6123  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(ty));
6124  while (ti) {
6125  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6126  const char *content;
6127 
6128  content=Typemaker2_Inline_GetContent(ti);
6129  if (content && *content) {
6130  GWEN_DB_NODE *db;
6131  int rv;
6132 
6133  db=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
6134  assert(db);
6135  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6136  if (rv<0) {
6137  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6138  GWEN_Buffer_free(tbuf);
6139  return rv;
6140  }
6141 
6142  /* include code */
6143  switch (Typemaker2_Inline_GetLocation(ti)) {
6144  case Typemaker2_InlineLocation_Header:
6145  switch (Typemaker2_Inline_GetAccess(ti)) {
6146  case TypeMaker2_Access_Public:
6147  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6148  break;
6149  case TypeMaker2_Access_Library:
6150  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6151  break;
6152  case TypeMaker2_Access_Protected:
6153  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6154  break;
6155  case TypeMaker2_Access_Private:
6156  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6157  break;
6158  default:
6159  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6160  GWEN_Buffer_free(tbuf);
6161  return GWEN_ERROR_BAD_DATA;
6162  }
6163  break;
6164 
6165  case Typemaker2_InlineLocation_Code:
6166  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6167  break;
6168  }
6169  }
6170  GWEN_Buffer_Reset(tbuf);
6171  }
6172 
6173  ti=Typemaker2_Inline_List_Next(ti);
6174  }
6175  ty=Typemaker2_Type_GetExtendsPtr(ty);
6176  }
6177 
6178  return 0;
6179 }
6180 
6181 
6182 
6183 static int _buildMemberInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6184 {
6185  GWEN_BUFFER *tbuf;
6186  uint32_t flags;
6187  /* TYPEMAKER2_TYPEMANAGER *tym; */
6188 
6189  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6190  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6191 
6192  flags=Typemaker2_Type_GetFlags(ty);
6193 
6194  while (ty) {
6195  TYPEMAKER2_MEMBER_LIST *tml;
6196 
6197  tml=Typemaker2_Type_GetMembers(ty);
6198  if (tml) {
6199  TYPEMAKER2_MEMBER *tm;
6200 
6201  tm=Typemaker2_Member_List_First(tml);
6202  while (tm) {
6203  TYPEMAKER2_TYPE *mty;
6204 
6205  mty=Typemaker2_Member_GetTypePtr(tm);
6206  if (mty) {
6207  TYPEMAKER2_INLINE *ti;
6208 
6209  /* get inlines from member type */
6210  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(mty));
6211  while (ti) {
6212  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6213  const char *content;
6214 
6215  content=Typemaker2_Inline_GetContent(ti);
6216  if (content && *content) {
6217  GWEN_DB_NODE *db;
6218  int rv;
6219 
6220  /* replace vars in context of the struct type, not the particular member type */
6221  db=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
6222  assert(db);
6223  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6224  if (rv<0) {
6225  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6226  GWEN_Buffer_free(tbuf);
6227  return rv;
6228  }
6229 
6230  /* include code */
6231  switch (Typemaker2_Inline_GetLocation(ti)) {
6232  case Typemaker2_InlineLocation_Header:
6233  switch (Typemaker2_Inline_GetAccess(ti)) {
6234  case TypeMaker2_Access_Public:
6235  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6236  break;
6237  case TypeMaker2_Access_Library:
6238  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6239  break;
6240  case TypeMaker2_Access_Protected:
6241  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6242  break;
6243  case TypeMaker2_Access_Private:
6244  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6245  break;
6246  default:
6247  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6248  GWEN_Buffer_free(tbuf);
6249  return GWEN_ERROR_BAD_DATA;
6250  }
6251  break;
6252 
6253  case Typemaker2_InlineLocation_Code:
6254  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6255  break;
6256  }
6257  }
6258  GWEN_Buffer_Reset(tbuf);
6259  }
6260 
6261  ti=Typemaker2_Inline_List_Next(ti);
6262  }
6263  } /* if mty */
6264 
6265  tm=Typemaker2_Member_List_Next(tm);
6266  } /* while tm */
6267  } /* if tml */
6268 
6269  ty=Typemaker2_Type_GetExtendsPtr(ty);
6270  }
6271 
6272  return 0;
6273 }
6274 
6275 
6276 
6277 static int _buildAttach(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6278 {
6279  GWEN_BUFFER *tbuf;
6280  const char *s;
6281  /* uint32_t flags; */
6282  TYPEMAKER2_TYPEMANAGER *tym;
6283 
6284  tym=Typemaker2_Builder_GetTypeManager(tb);
6285  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6286 
6287  /* flags=Typemaker2_Type_GetFlags(ty); */
6288 
6289  /* prototype */
6290  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6291  if (s) {
6292  GWEN_Buffer_AppendString(tbuf, s);
6293  GWEN_Buffer_AppendString(tbuf, " ");
6294  }
6295  GWEN_Buffer_AppendString(tbuf, "void ");
6296  s=Typemaker2_Type_GetPrefix(ty);
6297  GWEN_Buffer_AppendString(tbuf, s);
6298  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6299  s=Typemaker2_Type_GetIdentifier(ty);
6300  GWEN_Buffer_AppendString(tbuf, s);
6301  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6302 
6303  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6304  GWEN_Buffer_Reset(tbuf);
6305 
6306  /* implementation */
6307  GWEN_Buffer_AppendString(tbuf, "void ");
6308  s=Typemaker2_Type_GetPrefix(ty);
6309  GWEN_Buffer_AppendString(tbuf, s);
6310  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6311  s=Typemaker2_Type_GetIdentifier(ty);
6312  GWEN_Buffer_AppendString(tbuf, s);
6313  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6314 
6315  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6316  GWEN_Buffer_AppendString(tbuf, " assert(p_struct->_refCount);\n");
6317  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount++;\n");
6318  GWEN_Buffer_AppendString(tbuf, "}\n");
6319 
6320  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6321  GWEN_Buffer_free(tbuf);
6322 
6323  return 0;
6324 }
6325 
6326 
6327 
6328 static int _buildSignalFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6329 {
6330  GWEN_BUFFER *tbuf;
6331  const char *s;
6332  /* uint32_t flags; */
6333  TYPEMAKER2_TYPEMANAGER *tym;
6334  TYPEMAKER2_SIGNAL_LIST *sigList;
6335 
6336  tym=Typemaker2_Builder_GetTypeManager(tb);
6337  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6338 
6339  /* flags=Typemaker2_Type_GetFlags(ty); */
6340 
6341  sigList=Typemaker2_Type_GetSignals(ty);
6342  if (sigList) {
6343  TYPEMAKER2_SIGNAL *sig;
6344 
6345  /* prototype */
6346  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6347  sig=Typemaker2_Signal_List_First(sigList);
6348  while (sig) {
6349 
6350  /* SignalConnect */
6351  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6352  if (s) {
6353  GWEN_Buffer_AppendString(tbuf, s);
6354  GWEN_Buffer_AppendString(tbuf, " ");
6355  }
6356  GWEN_Buffer_AppendString(tbuf, "int ");
6357  s=Typemaker2_Type_GetPrefix(ty);
6358  GWEN_Buffer_AppendString(tbuf, s);
6359  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6360  s=Typemaker2_Signal_GetName(sig);
6361  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6362  GWEN_Buffer_AppendString(tbuf, s+1);
6363  GWEN_Buffer_AppendString(tbuf, "(");
6364  s=Typemaker2_Type_GetIdentifier(ty);
6365  GWEN_Buffer_AppendString(tbuf, s);
6366  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6367 
6368  /* SignalDisconnect */
6369  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6370  if (s) {
6371  GWEN_Buffer_AppendString(tbuf, s);
6372  GWEN_Buffer_AppendString(tbuf, " ");
6373  }
6374  GWEN_Buffer_AppendString(tbuf, "int ");
6375  s=Typemaker2_Type_GetPrefix(ty);
6376  GWEN_Buffer_AppendString(tbuf, s);
6377  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6378  s=Typemaker2_Signal_GetName(sig);
6379  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6380  GWEN_Buffer_AppendString(tbuf, s+1);
6381  GWEN_Buffer_AppendString(tbuf, "(");
6382  s=Typemaker2_Type_GetIdentifier(ty);
6383  GWEN_Buffer_AppendString(tbuf, s);
6384  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6385 
6386  /* GetSignal */
6387  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6388  if (s) {
6389  GWEN_Buffer_AppendString(tbuf, s);
6390  GWEN_Buffer_AppendString(tbuf, " ");
6391  }
6392  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6393  s=Typemaker2_Type_GetPrefix(ty);
6394  GWEN_Buffer_AppendString(tbuf, s);
6395  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6396  s=Typemaker2_Signal_GetName(sig);
6397  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6398  GWEN_Buffer_AppendString(tbuf, s+1);
6399  GWEN_Buffer_AppendString(tbuf, "(const ");
6400  s=Typemaker2_Type_GetIdentifier(ty);
6401  GWEN_Buffer_AppendString(tbuf, s);
6402  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6403 
6404 
6405  /* EmitSignal */
6406  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6407  if (s) {
6408  GWEN_Buffer_AppendString(tbuf, s);
6409  GWEN_Buffer_AppendString(tbuf, " ");
6410  }
6411  GWEN_Buffer_AppendString(tbuf, "int ");
6412  s=Typemaker2_Type_GetPrefix(ty);
6413  GWEN_Buffer_AppendString(tbuf, s);
6414  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6415  s=Typemaker2_Signal_GetName(sig);
6416  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6417  GWEN_Buffer_AppendString(tbuf, s+1);
6418  GWEN_Buffer_AppendString(tbuf, "(");
6419  s=Typemaker2_Type_GetIdentifier(ty);
6420  GWEN_Buffer_AppendString(tbuf, s);
6421  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6422  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6423  if (s && *s && strcasecmp(s, "none")) {
6424  GWEN_Buffer_AppendString(tbuf, ", ");
6425  GWEN_Buffer_AppendString(tbuf, s);
6426  GWEN_Buffer_AppendString(tbuf, " param1");
6427  }
6428  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6429  if (s && *s && strcasecmp(s, "none")) {
6430  GWEN_Buffer_AppendString(tbuf, ", ");
6431  GWEN_Buffer_AppendString(tbuf, s);
6432  GWEN_Buffer_AppendString(tbuf, " param2");
6433  }
6434  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6435  GWEN_Buffer_AppendString(tbuf, ", int param3");
6436  }
6437  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6438  GWEN_Buffer_AppendString(tbuf, ", int param4");
6439  }
6440  GWEN_Buffer_AppendString(tbuf, ");\n");
6441 
6442 
6443  sig=Typemaker2_Signal_List_Next(sig);
6444  }
6445  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6446  GWEN_Buffer_Reset(tbuf);
6447 
6448  /* implementation */
6449  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6450  sig=Typemaker2_Signal_List_First(sigList);
6451  while (sig) {
6452 
6453  /* SignalConnect */
6454  GWEN_Buffer_AppendString(tbuf, "int ");
6455  s=Typemaker2_Type_GetPrefix(ty);
6456  GWEN_Buffer_AppendString(tbuf, s);
6457  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6458  s=Typemaker2_Signal_GetName(sig);
6459  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6460  GWEN_Buffer_AppendString(tbuf, s+1);
6461  GWEN_Buffer_AppendString(tbuf, "(");
6462  s=Typemaker2_Type_GetIdentifier(ty);
6463  GWEN_Buffer_AppendString(tbuf, s);
6464  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6465 
6466  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6467  GWEN_Buffer_AppendString(tbuf, "\n");
6468  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6469  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6470  s=Typemaker2_Signal_GetName(sig); /* name */
6471  GWEN_Buffer_AppendString(tbuf, "\"");
6472  GWEN_Buffer_AppendString(tbuf, s);
6473  GWEN_Buffer_AppendString(tbuf, "\", ");
6474  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6475  GWEN_Buffer_AppendString(tbuf, "\"");
6476  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6477  GWEN_Buffer_AppendString(tbuf, "\", ");
6478  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6479  GWEN_Buffer_AppendString(tbuf, "\"");
6480  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6481  GWEN_Buffer_AppendString(tbuf, "\");\n");
6482  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6483  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Connect(sig, slot);\n");
6484  GWEN_Buffer_AppendString(tbuf, " else\n");
6485  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6486 
6487  GWEN_Buffer_AppendString(tbuf, "}\n");
6488  GWEN_Buffer_AppendString(tbuf, "\n");
6489 
6490  /* SignalDisconnect */
6491  GWEN_Buffer_AppendString(tbuf, "int ");
6492  s=Typemaker2_Type_GetPrefix(ty);
6493  GWEN_Buffer_AppendString(tbuf, s);
6494  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6495  s=Typemaker2_Signal_GetName(sig);
6496  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6497  GWEN_Buffer_AppendString(tbuf, s+1);
6498  GWEN_Buffer_AppendString(tbuf, "(");
6499  s=Typemaker2_Type_GetIdentifier(ty);
6500  GWEN_Buffer_AppendString(tbuf, s);
6501  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6502 
6503  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6504  GWEN_Buffer_AppendString(tbuf, "\n");
6505  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6506  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6507  s=Typemaker2_Signal_GetName(sig); /* name */
6508  GWEN_Buffer_AppendString(tbuf, "\"");
6509  GWEN_Buffer_AppendString(tbuf, s);
6510  GWEN_Buffer_AppendString(tbuf, "\", ");
6511  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6512  GWEN_Buffer_AppendString(tbuf, "\"");
6513  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6514  GWEN_Buffer_AppendString(tbuf, "\", ");
6515  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6516  GWEN_Buffer_AppendString(tbuf, "\"");
6517  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6518  GWEN_Buffer_AppendString(tbuf, "\");\n");
6519  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6520  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Disconnect(sig, slot);\n");
6521  GWEN_Buffer_AppendString(tbuf, " else\n");
6522  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6523 
6524  GWEN_Buffer_AppendString(tbuf, "}\n");
6525  GWEN_Buffer_AppendString(tbuf, "\n");
6526 
6527 
6528  /* GetSignal */
6529  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6530  s=Typemaker2_Type_GetPrefix(ty);
6531  GWEN_Buffer_AppendString(tbuf, s);
6532  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6533  s=Typemaker2_Signal_GetName(sig);
6534  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6535  GWEN_Buffer_AppendString(tbuf, s+1);
6536  GWEN_Buffer_AppendString(tbuf, "(const ");
6537  s=Typemaker2_Type_GetIdentifier(ty);
6538  GWEN_Buffer_AppendString(tbuf, s);
6539  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6540 
6541  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6542  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6543  s=Typemaker2_Signal_GetName(sig); /* name */
6544  GWEN_Buffer_AppendString(tbuf, "\"");
6545  GWEN_Buffer_AppendString(tbuf, s);
6546  GWEN_Buffer_AppendString(tbuf, "\", ");
6547  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6548  GWEN_Buffer_AppendString(tbuf, "\"");
6549  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6550  GWEN_Buffer_AppendString(tbuf, "\", ");
6551  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6552  GWEN_Buffer_AppendString(tbuf, "\"");
6553  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6554  GWEN_Buffer_AppendString(tbuf, "\");\n");
6555 
6556  GWEN_Buffer_AppendString(tbuf, "}\n");
6557  GWEN_Buffer_AppendString(tbuf, "\n");
6558 
6559 
6560  /* EmitSignal */
6561  GWEN_Buffer_AppendString(tbuf, "int ");
6562  s=Typemaker2_Type_GetPrefix(ty);
6563  GWEN_Buffer_AppendString(tbuf, s);
6564  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6565  s=Typemaker2_Signal_GetName(sig);
6566  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6567  GWEN_Buffer_AppendString(tbuf, s+1);
6568  GWEN_Buffer_AppendString(tbuf, "(");
6569  s=Typemaker2_Type_GetIdentifier(ty);
6570  GWEN_Buffer_AppendString(tbuf, s);
6571  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6572  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6573  if (s && *s && strcasecmp(s, "none")) {
6574  GWEN_Buffer_AppendString(tbuf, ", ");
6575  GWEN_Buffer_AppendString(tbuf, s);
6576  GWEN_Buffer_AppendString(tbuf, " param1");
6577  }
6578  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6579  if (s && *s && strcasecmp(s, "none")) {
6580  GWEN_Buffer_AppendString(tbuf, ", ");
6581  GWEN_Buffer_AppendString(tbuf, s);
6582  GWEN_Buffer_AppendString(tbuf, " param2");
6583  }
6584  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6585  GWEN_Buffer_AppendString(tbuf, ", int param3");
6586  }
6587  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6588  GWEN_Buffer_AppendString(tbuf, ", int param4");
6589  }
6590  GWEN_Buffer_AppendString(tbuf, "){\n");
6591 
6592  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6593  GWEN_Buffer_AppendString(tbuf, "\n");
6594  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6595  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6596  s=Typemaker2_Signal_GetName(sig); /* name */
6597  GWEN_Buffer_AppendString(tbuf, "\"");
6598  GWEN_Buffer_AppendString(tbuf, s);
6599  GWEN_Buffer_AppendString(tbuf, "\", ");
6600 
6601  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6602  GWEN_Buffer_AppendString(tbuf, "\"");
6603  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6604  GWEN_Buffer_AppendString(tbuf, "\", ");
6605  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6606  GWEN_Buffer_AppendString(tbuf, "\"");
6607  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6608  GWEN_Buffer_AppendString(tbuf, "\");\n");
6609 
6610  GWEN_Buffer_AppendString(tbuf, " if (sig) \n");
6611  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Emit(sig, ");
6612  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6613  if (s && *s && strcasecmp(s, "none")) {
6614  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6615  GWEN_Buffer_AppendString(tbuf, "param1, ");
6616  }
6617  else
6618  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6619  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6620  if (s && *s && strcasecmp(s, "none")) {
6621  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6622  GWEN_Buffer_AppendString(tbuf, " param2, ");
6623  }
6624  else
6625  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6626  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3)
6627  GWEN_Buffer_AppendString(tbuf, "param3, ");
6628  else
6629  GWEN_Buffer_AppendString(tbuf, "0, ");
6630  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4)
6631  GWEN_Buffer_AppendString(tbuf, "param4");
6632  else
6633  GWEN_Buffer_AppendString(tbuf, "0");
6634  GWEN_Buffer_AppendString(tbuf, ");\n");
6635 
6636 
6637  GWEN_Buffer_AppendString(tbuf, " else\n");
6638  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6639 
6640  GWEN_Buffer_AppendString(tbuf, "}\n");
6641  GWEN_Buffer_AppendString(tbuf, "\n");
6642 
6643 
6644  sig=Typemaker2_Signal_List_Next(sig);
6645  }
6646  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6647  GWEN_Buffer_Reset(tbuf);
6648 
6649  }
6650  GWEN_Buffer_free(tbuf);
6651 
6652  return 0;
6653 }
6654 
6655 
6656 
6657 static int _buildSlotFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6658 {
6659  GWEN_BUFFER *tbuf;
6660  const char *s;
6661  TYPEMAKER2_TYPEMANAGER *tym;
6662  TYPEMAKER2_SLOT_LIST *slotList;
6663 
6664  tym=Typemaker2_Builder_GetTypeManager(tb);
6665  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6666 
6667  slotList=Typemaker2_Type_GetSlots(ty);
6668  if (slotList) {
6669  TYPEMAKER2_SLOT *slot;
6670 
6671  /* private prototypes */
6672  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6673  slot=Typemaker2_Slot_List_First(slotList);
6674  while (slot) {
6675 
6676  /* callback function */
6677  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6678  s=Typemaker2_Type_GetPrefix(ty);
6679  GWEN_Buffer_AppendString(tbuf, s);
6680  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6681  s=Typemaker2_Slot_GetName(slot);
6682  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6683  GWEN_Buffer_AppendString(tbuf, s+1);
6684  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4);\n");
6685 
6686  slot=Typemaker2_Slot_List_Next(slot);
6687  }
6688 
6689  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6690  GWEN_Buffer_Reset(tbuf);
6691 
6692  /* public prototypes */
6693  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6694  slot=Typemaker2_Slot_List_First(slotList);
6695  while (slot) {
6696  /* GetSlot */
6697  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6698  if (s) {
6699  GWEN_Buffer_AppendString(tbuf, s);
6700  GWEN_Buffer_AppendString(tbuf, " ");
6701  }
6702  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6703  s=Typemaker2_Type_GetPrefix(ty);
6704  GWEN_Buffer_AppendString(tbuf, s);
6705  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6706  s=Typemaker2_Slot_GetName(slot);
6707  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6708  GWEN_Buffer_AppendString(tbuf, s+1);
6709  GWEN_Buffer_AppendString(tbuf, "(const ");
6710  s=Typemaker2_Type_GetIdentifier(ty);
6711  GWEN_Buffer_AppendString(tbuf, s);
6712  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6713 
6714 
6715  slot=Typemaker2_Slot_List_Next(slot);
6716  }
6717  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6718  GWEN_Buffer_Reset(tbuf);
6719 
6720  /* implementation */
6721  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6722  slot=Typemaker2_Slot_List_First(slotList);
6723  while (slot) {
6724 
6725  /* callback function */
6726  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6727  s=Typemaker2_Type_GetPrefix(ty);
6728  GWEN_Buffer_AppendString(tbuf, s);
6729  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6730  s=Typemaker2_Slot_GetName(slot);
6731  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6732  GWEN_Buffer_AppendString(tbuf, s+1);
6733  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4) {\n");
6734 
6735  GWEN_Buffer_AppendString(tbuf, " ");
6736  s=Typemaker2_Type_GetIdentifier(ty);
6737  GWEN_Buffer_AppendString(tbuf, s);
6738  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
6739 
6740  GWEN_Buffer_AppendString(tbuf, "\n");
6741  GWEN_Buffer_AppendString(tbuf, " p_struct=(");
6742  GWEN_Buffer_AppendString(tbuf, s);
6743  GWEN_Buffer_AppendString(tbuf, "*) userData;\n");
6744 
6745  GWEN_Buffer_AppendString(tbuf, " return ");
6746  s=Typemaker2_Type_GetPrefix(ty);
6747  GWEN_Buffer_AppendString(tbuf, s);
6748  GWEN_Buffer_AppendString(tbuf, "_");
6749  s=Typemaker2_Slot_GetName(slot);
6750  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6751  GWEN_Buffer_AppendString(tbuf, s+1);
6752  GWEN_Buffer_AppendString(tbuf, "(p_struct");
6753 
6754  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6755  if (s && *s && strcasecmp(s, "none")) {
6756  GWEN_Buffer_AppendString(tbuf, ", (");
6757  GWEN_Buffer_AppendString(tbuf, s);
6758  GWEN_Buffer_AppendString(tbuf, ") p1");
6759  }
6760  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6761  if (s && *s && strcasecmp(s, "none")) {
6762  GWEN_Buffer_AppendString(tbuf, ", (");
6763  GWEN_Buffer_AppendString(tbuf, s);
6764  GWEN_Buffer_AppendString(tbuf, ") p2");
6765  }
6766  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3)
6767  GWEN_Buffer_AppendString(tbuf, ", p3");
6768  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4)
6769  GWEN_Buffer_AppendString(tbuf, ", p4");
6770 
6771  GWEN_Buffer_AppendString(tbuf, ");\n");
6772 
6773  GWEN_Buffer_AppendString(tbuf, "}\n\n");
6774 
6775 
6776  /* GetSlot */
6777  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6778  s=Typemaker2_Type_GetPrefix(ty);
6779  GWEN_Buffer_AppendString(tbuf, s);
6780  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6781  s=Typemaker2_Slot_GetName(slot);
6782  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6783  GWEN_Buffer_AppendString(tbuf, s+1);
6784  GWEN_Buffer_AppendString(tbuf, "(const ");
6785  s=Typemaker2_Type_GetIdentifier(ty);
6786  GWEN_Buffer_AppendString(tbuf, s);
6787  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6788 
6789  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6790  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSlot(p_struct->_signalObject, ");
6791  s=Typemaker2_Slot_GetName(slot); /* name */
6792  GWEN_Buffer_AppendString(tbuf, "\"");
6793  GWEN_Buffer_AppendString(tbuf, s);
6794  GWEN_Buffer_AppendString(tbuf, "\", ");
6795  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6796  GWEN_Buffer_AppendString(tbuf, "\"");
6797  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6798  GWEN_Buffer_AppendString(tbuf, "\", ");
6799  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6800  GWEN_Buffer_AppendString(tbuf, "\"");
6801  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6802  GWEN_Buffer_AppendString(tbuf, "\");\n");
6803 
6804  GWEN_Buffer_AppendString(tbuf, "}\n");
6805  GWEN_Buffer_AppendString(tbuf, "\n");
6806 
6807  slot=Typemaker2_Slot_List_Next(slot);
6808  }
6809  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6810  GWEN_Buffer_Reset(tbuf);
6811 
6812  }
6813  GWEN_Buffer_free(tbuf);
6814 
6815  return 0;
6816 }
6817 
6818 
6819 
6820 static int _buildCacheFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6821 {
6822  GWEN_BUFFER *tbuf;
6823  const char *s;
6824  TYPEMAKER2_TYPEMANAGER *tym;
6825 
6826  tym=Typemaker2_Builder_GetTypeManager(tb);
6827  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6828 
6829  /* public prototypes */
6830  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
6831 
6832  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6833  if (s) {
6834  GWEN_Buffer_AppendString(tbuf, s);
6835  GWEN_Buffer_AppendString(tbuf, " ");
6836  }
6837  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6838  s=Typemaker2_Type_GetPrefix(ty);
6839  GWEN_Buffer_AppendString(tbuf, s);
6840  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr);\n");
6841  GWEN_Buffer_AppendString(tbuf, "\n");
6842 
6843  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6844  if (s) {
6845  GWEN_Buffer_AppendString(tbuf, s);
6846  GWEN_Buffer_AppendString(tbuf, " ");
6847  }
6848  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6849  s=Typemaker2_Type_GetPrefix(ty);
6850  GWEN_Buffer_AppendString(tbuf, s);
6851  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr);\n");
6852  GWEN_Buffer_AppendString(tbuf, "\n");
6853 
6854  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6855  GWEN_Buffer_Reset(tbuf);
6856 
6857 
6858  /* implementations */
6859  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
6860 
6861  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6862  s=Typemaker2_Type_GetPrefix(ty);
6863  GWEN_Buffer_AppendString(tbuf, s);
6864  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr) {\n");
6865  GWEN_Buffer_AppendString(tbuf, " ");
6866  s=Typemaker2_Type_GetPrefix(ty);
6867  GWEN_Buffer_AppendString(tbuf, s);
6868  GWEN_Buffer_AppendString(tbuf, "_Attach((");
6869  s=Typemaker2_Type_GetIdentifier(ty);
6870  GWEN_Buffer_AppendString(tbuf, s);
6871  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
6872  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6873  GWEN_Buffer_AppendString(tbuf, "}\n");
6874  GWEN_Buffer_AppendString(tbuf, "\n");
6875 
6876  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6877  s=Typemaker2_Type_GetPrefix(ty);
6878  GWEN_Buffer_AppendString(tbuf, s);
6879  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr){\n");
6880  GWEN_Buffer_AppendString(tbuf, " ");
6881  s=Typemaker2_Type_GetPrefix(ty);
6882  GWEN_Buffer_AppendString(tbuf, s);
6883  GWEN_Buffer_AppendString(tbuf, "_free((");
6884  s=Typemaker2_Type_GetIdentifier(ty);
6885  GWEN_Buffer_AppendString(tbuf, s);
6886  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
6887  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6888  GWEN_Buffer_AppendString(tbuf, "}\n");
6889  GWEN_Buffer_AppendString(tbuf, "\n");
6890 
6891 
6892  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6893  GWEN_Buffer_free(tbuf);
6894 
6895  return 0;
6896 }
6897 
6898 
6899 
6900 static int _buildGroupApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty,
6901  TYPEMAKER2_GROUP *grp, int depth, GWEN_BUFFER *buf)
6902 {
6903  char numbuf[32];
6904  const char *s;
6905  TYPEMAKER2_GROUP *childGrp;
6906  TYPEMAKER2_MEMBER_LIST *members;
6907  const char *sTypeIdentifier;
6908  const char *sTypePrefix;
6909 
6910  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
6911  sTypePrefix=Typemaker2_Type_GetPrefix(ty);
6912 
6913  /* write title */
6914  GWEN_Buffer_AppendString(buf, "\n\n");
6915  GWEN_Buffer_AppendString(buf, "<h");
6916  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth);
6917  numbuf[sizeof(numbuf)-1]=0;
6918  GWEN_Buffer_AppendString(buf, numbuf);
6919  GWEN_Buffer_AppendString(buf, ">");
6920  s=Typemaker2_Group_GetTitle(grp);
6921  if (s && *s)
6922  GWEN_Buffer_AppendString(buf, s);
6923  else
6924  GWEN_Buffer_AppendString(buf, "Unnamed Group");
6925  GWEN_Buffer_AppendString(buf, "</h");
6926  GWEN_Buffer_AppendString(buf, numbuf);
6927  GWEN_Buffer_AppendString(buf, ">\n");
6928  GWEN_Buffer_AppendString(buf, "\n");
6929 
6930  s=Typemaker2_Group_GetDescription(grp);
6931  if (s && *s) {
6932  GWEN_DB_NODE *dbCall;
6933  int rv;
6934 
6935  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
6936  assert(dbCall);
6937  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
6938  if (rv<0) {
6939  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6940  GWEN_DB_Group_free(dbCall);
6941  GWEN_Buffer_free(buf);
6942  return rv;
6943  }
6944  GWEN_DB_Group_free(dbCall);
6945  GWEN_Buffer_AppendString(buf, "\n");
6946  }
6947 
6948  /* write member docs */
6949  members=Typemaker2_Type_GetMembers(ty);
6950  if (members) {
6951  TYPEMAKER2_MEMBER *tm;
6952 
6953  tm=Typemaker2_Member_List_First(members);
6954  while (tm) {
6955 
6956  if (Typemaker2_Member_GetGroupPtr(tm)==grp) {
6957  const char *sMemberName;
6958 
6959  /* write APIDOC for member */
6960  sMemberName=Typemaker2_Member_GetName(tm);
6961 
6962  /* write anchor */
6963  GWEN_Buffer_AppendString(buf, "\n\n@anchor ");
6964  GWEN_Buffer_AppendString(buf, sTypeIdentifier);
6965  GWEN_Buffer_AppendString(buf, "_");
6966  GWEN_Buffer_AppendString(buf, sMemberName);
6967  GWEN_Buffer_AppendString(buf, "\n");
6968 
6969  /* write name */
6970  GWEN_Buffer_AppendString(buf, "<h");
6971  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth+1);
6972  numbuf[sizeof(numbuf)-1]=0;
6973  GWEN_Buffer_AppendString(buf, numbuf);
6974  GWEN_Buffer_AppendString(buf, ">");
6975  s=Typemaker2_Member_GetName(tm);
6976  GWEN_Buffer_AppendString(buf, s);
6977  GWEN_Buffer_AppendString(buf, "</h");
6978  GWEN_Buffer_AppendString(buf, numbuf);
6979  GWEN_Buffer_AppendString(buf, ">\n");
6980  GWEN_Buffer_AppendString(buf, "\n");
6981 
6982  /* add description, if any */
6983  s=Typemaker2_Member_GetDescription(tm);
6984  if (s && *s) {
6985  GWEN_DB_NODE *dbCall;
6986  int rv;
6987 
6988  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
6989  assert(dbCall);
6990  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
6991  if (rv<0) {
6992  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6993  GWEN_DB_Group_free(dbCall);
6994  GWEN_Buffer_free(buf);
6995  return rv;
6996  }
6997  GWEN_DB_Group_free(dbCall);
6998  GWEN_Buffer_AppendString(buf, "\n");
6999  }
7000 
7001  /* add setter/getter info */
7002  GWEN_Buffer_AppendString(buf, "<p>");
7003  GWEN_Buffer_AppendString(buf, "Set this property with @ref ");
7004  GWEN_Buffer_AppendString(buf, sTypePrefix);
7005  GWEN_Buffer_AppendString(buf, "_Set");
7006  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7007  GWEN_Buffer_AppendString(buf, sMemberName+1);
7008  GWEN_Buffer_AppendString(buf, "(), get it with @ref ");
7009  GWEN_Buffer_AppendString(buf, sTypePrefix);
7010  GWEN_Buffer_AppendString(buf, "_Get");
7011  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7012  GWEN_Buffer_AppendString(buf, sMemberName+1);
7013  GWEN_Buffer_AppendString(buf, "().");
7014  GWEN_Buffer_AppendString(buf, "</p>\n");
7015  }
7016  tm=Typemaker2_Member_List_Next(tm);
7017  }
7018  }
7019 
7020  /* write children groups */
7021  childGrp=Typemaker2_Group_Tree_GetFirstChild(grp);
7022  while (childGrp) {
7023  int rv;
7024 
7025  rv=_buildGroupApiDoc(tb, ty, childGrp, depth+1, buf);
7026  if (rv<0) {
7027  DBG_ERROR(0, "here (%d)", rv);
7028  return rv;
7029  }
7030  childGrp=Typemaker2_Group_Tree_GetNext(childGrp);
7031  }
7032 
7033  return 0;
7034 }
7035 
7036 
7037 
7038 
7039 static int _buildApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7040 {
7041  TYPEMAKER2_GROUP_TREE *groupTree;
7042  TYPEMAKER2_GROUP *grp;
7043  GWEN_BUFFER *tbuf;
7044  const char *sTypeIdentifier;
7045 
7046  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
7047 
7048  groupTree=Typemaker2_Type_GetGroupTree(ty);
7049 
7050  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7051 
7052  GWEN_Buffer_AppendString(tbuf, "/** @page P_");
7053  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7054  GWEN_Buffer_AppendString(tbuf, " Structure ");
7055  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7056 
7057  GWEN_Buffer_AppendString(tbuf, "\n");
7058 
7059  GWEN_Buffer_AppendString(tbuf, "<p>This page describes the properties of ");
7060  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7061  GWEN_Buffer_AppendString(tbuf, ".</p>\n");
7062 
7063  GWEN_Buffer_AppendString(tbuf, "\n");
7064 
7065 
7066  grp=Typemaker2_Group_Tree_GetFirst(groupTree);
7067  while (grp) {
7068  _buildGroupApiDoc(tb, ty, grp, 1, tbuf);
7069  grp=Typemaker2_Group_Tree_GetNext(grp);
7070  }
7071  GWEN_Buffer_AppendString(tbuf, "\n");
7072  GWEN_Buffer_AppendString(tbuf, "*/\n");
7073 
7074  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
7075 
7076  GWEN_Buffer_free(tbuf);
7077 
7078  return 0;
7079 }
7080 
7081 
7082 
7083 
7084 static int _addVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7085 {
7086  GWEN_BUFFER *tbuf;
7087  const char *s;
7088  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7089  TYPEMAKER2_SLOT_LIST *slotList;
7090 
7091  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7092  fnList=Typemaker2_Type_GetVirtualFns(ty);
7093 
7094  slotList=Typemaker2_Type_GetSlots(ty);
7095  if (slotList) {
7096  TYPEMAKER2_SLOT *slot;
7097 
7098  slot=Typemaker2_Slot_List_First(slotList);
7099  while (slot) {
7100  TYPEMAKER2_VIRTUALFN *fn;
7101  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
7102 
7103  /* callback function */
7104  s=Typemaker2_Slot_GetName(slot);
7105  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
7106  GWEN_Buffer_AppendString(tbuf, s+1);
7107 
7108  fn=Typemaker2_VirtualFn_new();
7109  plist=Typemaker2_VirtualFn_GetParamTypeList(fn);
7110 
7111  /* name */
7112  Typemaker2_VirtualFn_SetName(fn, GWEN_Buffer_GetStart(tbuf));
7113 
7114  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
7115  if (s && *s && strcasecmp(s, "none")) {
7116  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7117 
7118  prm=Typemaker2_VirtualFn_Param_new();
7119  Typemaker2_VirtualFn_Param_SetType(prm, s);
7120  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7121  }
7122  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
7123  if (s && *s && strcasecmp(s, "none")) {
7124  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7125 
7126  prm=Typemaker2_VirtualFn_Param_new();
7127  Typemaker2_VirtualFn_Param_SetType(prm, s);
7128  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7129  }
7130  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3) {
7131  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7132 
7133  prm=Typemaker2_VirtualFn_Param_new();
7134  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7135  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7136  }
7137  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4) {
7138  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7139 
7140  prm=Typemaker2_VirtualFn_Param_new();
7141  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7142  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7143  }
7144 
7145  Typemaker2_VirtualFn_SetAccess(fn, TypeMaker2_Access_Public);
7146  Typemaker2_VirtualFn_SetLocation(fn, "post");
7147  Typemaker2_VirtualFn_SetReturnType(fn, "int");
7148  Typemaker2_VirtualFn_SetDefaultReturnValue(fn, "GWEN_ERROR_NOT_IMPLEMENTED");
7149 
7150  Typemaker2_VirtualFn_AddFlags(fn, TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT);
7151 
7152  Typemaker2_VirtualFn_List_Add(fn, fnList);
7153 
7154  slot=Typemaker2_Slot_List_Next(slot);
7155  }
7156  }
7157  GWEN_Buffer_free(tbuf);
7158 
7159  return 0;
7160 }
7161 
7162 
7163 
7164 static void _delVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7165 {
7166  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7167 
7168  fnList=Typemaker2_Type_GetVirtualFns(ty);
7169  if (fnList) {
7170  TYPEMAKER2_VIRTUALFN *fn;
7171 
7172  fn=Typemaker2_VirtualFn_List_First(fnList);
7173  while (fn) {
7174  TYPEMAKER2_VIRTUALFN *fnNext;
7175 
7176  fnNext=Typemaker2_VirtualFn_List_Next(fn);
7177  if (Typemaker2_VirtualFn_GetFlags(fn) & TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT) {
7178  Typemaker2_VirtualFn_List_Del(fn);
7179  Typemaker2_VirtualFn_free(fn);
7180  }
7181  fn=fnNext;
7182  }
7183  }
7184 }
7185 
7186 
7187 
7188 
7189 static int Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7190 {
7191  int rv;
7192  uint32_t flags;
7193 
7194  flags=Typemaker2_Type_GetFlags(ty);
7195 
7196  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7197  _delVirtualFnsFromSlots(tb, ty);
7198  rv=_addVirtualFnsFromSlots(tb, ty);
7199  if (rv<0) {
7200  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7201  return rv;
7202  }
7203  }
7204 
7205 
7206  rv=_setEnumStringFns(tb, ty);
7207  if (rv<0) {
7208  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7209  return rv;
7210  }
7211 
7212  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7213  rv=_buildFieldIds(tb, ty);
7214  if (rv<0) {
7215  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7216  return rv;
7217  }
7218  }
7219 
7220  rv=_buildApiDoc(tb, ty);
7221  if (rv<0) {
7222  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7223  return rv;
7224  }
7225 
7226  rv=_buildDefineDefines(tb, ty);
7227  if (rv<0) {
7228  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7229  return rv;
7230  }
7231 
7232  rv=_buildTypedef(tb, ty);
7233  if (rv<0) {
7234  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7235  return rv;
7236  }
7237 
7238  rv=_buildDefineEnums(tb, ty);
7239  if (rv<0) {
7240  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7241  return rv;
7242  }
7243 
7244  rv=_buildDefineVirtualFns(tb, ty, "pre");
7245  if (rv<0) {
7246  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7247  return rv;
7248  }
7249 
7250  rv=_buildPostHeaders(tb, ty);
7251  if (rv<0) {
7252  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7253  return rv;
7254  }
7255 
7256  rv=_buildDefineVirtualFns(tb, ty, "post");
7257  if (rv<0) {
7258  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7259  return rv;
7260  }
7261 
7262  rv=_buildStruct(tb, ty);
7263  if (rv<0) {
7264  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7265  return rv;
7266  }
7267 
7268  rv=_buildMacroFunctions(tb, ty);
7269  if (rv<0) {
7270  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7271  return rv;
7272  }
7273 
7274  rv=_buildEnumFromString(tb, ty);
7275  if (rv<0) {
7276  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7277  return rv;
7278  }
7279 
7280  rv=_buildEnumToString(tb, ty);
7281  if (rv<0) {
7282  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7283  return rv;
7284  }
7285 
7286  rv=_buildConstructor(tb, ty);
7287  if (rv<0) {
7288  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7289  return rv;
7290  }
7291 
7292  rv=_buildDestructor(tb, ty);
7293  if (rv<0) {
7294  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7295  return rv;
7296  }
7297 
7298  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
7299  rv=_buildAttach(tb, ty);
7300  if (rv<0) {
7301  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7302  return rv;
7303  }
7304  }
7305 
7306  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7307  rv=_buildDup(tb, ty);
7308  if (rv<0) {
7309  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7310  return rv;
7311  }
7312  }
7313 
7314  if (!(flags & TYPEMAKER2_TYPEFLAGS_NOCOPY)) {
7315  rv=_buildCopy(tb, ty);
7316  if (rv<0) {
7317  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7318  return rv;
7319  }
7320  }
7321 
7322  rv=_buildGetter(tb, ty);
7323  if (rv<0) {
7324  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7325  return rv;
7326  }
7327 
7328  rv=_buildSetter(tb, ty);
7329  if (rv<0) {
7330  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7331  return rv;
7332  }
7333 
7334  rv=_buildProtoVirtualFns(tb, ty);
7335  if (rv<0) {
7336  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7337  return rv;
7338  }
7339 
7340  rv=_buildCodeVirtualFns(tb, ty);
7341  if (rv<0) {
7342  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7343  return rv;
7344  }
7345 
7346  rv=_buildProtoSetterVirtualFns(tb, ty);
7347  if (rv<0) {
7348  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7349  return rv;
7350  }
7351 
7352  rv=_buildSetterVirtualFns(tb, ty);
7353  if (rv<0) {
7354  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7355  return rv;
7356  }
7357 
7358  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
7359  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7360  rv=_buildList1Dup(tb, ty);
7361  if (rv<0) {
7362  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7363  return rv;
7364  }
7365  }
7366  }
7367 
7368  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_DB) {
7369  rv=_buildReadDb(tb, ty);
7370  if (rv<0) {
7371  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7372  return rv;
7373  }
7374 
7375  rv=_buildWriteDb(tb, ty);
7376  if (rv<0) {
7377  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7378  return rv;
7379  }
7380 
7381  rv=_buildFromDb(tb, ty);
7382  if (rv<0) {
7383  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7384  return rv;
7385  }
7386 
7387  rv=_buildToDb(tb, ty);
7388  if (rv<0) {
7389  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7390  return rv;
7391  }
7392 
7393  }
7394 
7395  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_XML) {
7396  rv=_buildReadXml(tb, ty);
7397  if (rv<0) {
7398  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7399  return rv;
7400  }
7401 
7402  rv=_buildWriteXml(tb, ty);
7403  if (rv<0) {
7404  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7405  return rv;
7406  }
7407 
7408  rv=_buildToXml(tb, ty);
7409  if (rv<0) {
7410  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7411  return rv;
7412  }
7413 
7414  rv=_buildFromXml(tb, ty);
7415  if (rv<0) {
7416  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7417  return rv;
7418  }
7419  }
7420 
7421  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7422  rv=_buildReadObject(tb, ty);
7423  if (rv<0) {
7424  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7425  return rv;
7426  }
7427 
7428  rv=_buildWriteObject(tb, ty);
7429  if (rv<0) {
7430  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7431  return rv;
7432  }
7433 
7434  rv=_buildToObject(tb, ty);
7435  if (rv<0) {
7436  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7437  return rv;
7438  }
7439 
7440  rv=_buildFromObject(tb, ty);
7441  if (rv<0) {
7442  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7443  return rv;
7444  }
7445 
7446  rv=_buildCreateColumnList(tb, ty);
7447  if (rv<0) {
7448  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7449  return rv;
7450  }
7451 
7452  rv=_buildCreateTable(tb, ty);
7453  if (rv<0) {
7454  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7455  return rv;
7456  }
7457 
7458  rv=_buildCreateObject(tb, ty);
7459  if (rv<0) {
7460  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7461  return rv;
7462  }
7463  }
7464 
7465  rv=_buildGetByMember(tb, ty);
7466  if (rv<0) {
7467  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7468  return rv;
7469  }
7470 
7471  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_HASH) {
7472  rv=_buildToHashString(tb, ty);
7473  if (rv<0) {
7474  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7475  return rv;
7476  }
7477  }
7478 
7479  rv=_buildMemberInlines(tb, ty);
7480  if (rv<0) {
7481  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7482  return rv;
7483  }
7484 
7485 
7486  rv=_buildSortByMember(tb, ty);
7487  if (rv<0) {
7488  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7489  return rv;
7490  }
7491 
7492 
7493  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) {
7494  rv=_buildSignalFunctions(tb, ty);
7495  if (rv<0) {
7496  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7497  return rv;
7498  }
7499  }
7500 
7501  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7502  rv=_buildSlotFunctions(tb, ty);
7503  if (rv<0) {
7504  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7505  return rv;
7506  }
7507  }
7508 
7509  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS) {
7510  rv=_buildCacheFunctions(tb, ty);
7511  if (rv<0) {
7512  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7513  return rv;
7514  }
7515  }
7516 
7517  rv=_buildInlines(tb, ty);
7518  if (rv<0) {
7519  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7520  return rv;
7521  }
7522 
7523  rv=_buildEndHeaders(tb, ty);
7524  if (rv<0) {
7525  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7526  return rv;
7527  }
7528 
7529  return 0;
7530 }
7531 
7532 
7533 
7534 TYPEMAKER2_BUILDER *Typemaker2_Builder_C_new()
7535 {
7536  TYPEMAKER2_BUILDER *tb;
7537 
7538  tb=Typemaker2_Builder_new();
7539  Typemaker2_Builder_SetBuildFn(tb, Typemaker2_Builder_C_Build);
7540 
7541  return tb;
7542 }
7543 
7544 
7545 
7546 
7547 
Typemaker2_Item_GetName
const char * Typemaker2_Item_GetName(const TYPEMAKER2_ITEM *p_struct)
Definition: tm_item.c:101
Typemaker2_Header_GetType
int Typemaker2_Header_GetType(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:90
Typemaker2_Builder_Invoke_CompareFn
int Typemaker2_Builder_Invoke_CompareFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2
#define TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2
Definition: tm_type.h:70
Typemaker2_VirtualFn_GetReturnTypeDescr
const char * Typemaker2_VirtualFn_GetReturnTypeDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:326
TYPEMAKER2_TYPEFLAGS_WITH_TREE2
#define TYPEMAKER2_TYPEFLAGS_WITH_TREE2
Definition: tm_type.h:71
Typemaker2_Builder_GetTypeManager
TYPEMAKER2_TYPEMANAGER * Typemaker2_Builder_GetTypeManager(const TYPEMAKER2_BUILDER *tb)
Definition: tm_builder.c:133
TYPEMAKER2_FLAGS_WITH_FLAGS
#define TYPEMAKER2_FLAGS_WITH_FLAGS
Definition: tm_type.h:49
TypeMaker2_Type_Pointer
Definition: tm_type.h:78
Typemaker2_Builder_SetBuildFn
void Typemaker2_Builder_SetBuildFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_BUILDER_BUILD_FN fn)
Definition: tm_builder.c:329
Typemaker2_Type_GetVirtualFns
TYPEMAKER2_VIRTUALFN_LIST * Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:695
Typemaker2_Member_GetTypePtr
TYPEMAKER2_TYPE * Typemaker2_Member_GetTypePtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:467
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:231
Typemaker2_Member_GetFlags
uint32_t Typemaker2_Member_GetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:237
TYPEMAKER2_SIGNAL
struct TYPEMAKER2_SIGNAL TYPEMAKER2_SIGNAL
Definition: tm_signal.h:27
Typemaker2_Enum_GetItems
TYPEMAKER2_ITEM_LIST * Typemaker2_Enum_GetItems(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:198
TypeMaker2_Access_Public
Definition: tm_type.h:86
TYPEMAKER2_TYPEFLAGS_WITH_HASH
#define TYPEMAKER2_TYPEFLAGS_WITH_HASH
Definition: tm_type.h:69
Typemaker2_Header_GetFileName
const char * Typemaker2_Header_GetFileName(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:68
Typemaker2_Builder_Invoke_DupFn
int Typemaker2_Builder_Invoke_DupFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_TYPEFLAGS_NODUP
#define TYPEMAKER2_TYPEFLAGS_NODUP
Definition: tm_type.h:66
Typemaker2_VirtualFn_Param_SetType
void Typemaker2_VirtualFn_Param_SetType(TYPEMAKER2_VIRTUALFN_PARAM *prm, const char *s)
Definition: tm_virtualfn.c:466
GWEN_DB_NODE
struct GWEN_DB_NODE GWEN_DB_NODE
Definition: db.h:228
_buildTree2GetByMember
static int _buildTree2GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5444
Typemaker2_Inline_GetTypeFlagsValue
int Typemaker2_Inline_GetTypeFlagsValue(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:136
_buildList1Dup
static int _buildList1Dup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3813
_buildCopy
static int _buildCopy(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3523
GWEN_DB_Group_free
void GWEN_DB_Group_free(GWEN_DB_NODE *n)
Definition: db.c:419
Typemaker2_VirtualFn_GetPreset
const char * Typemaker2_VirtualFn_GetPreset(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:380
_buildSlotFunctions
static int _buildSlotFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6657
Typemaker2_Type_GetSlots
TYPEMAKER2_SLOT_LIST * Typemaker2_Type_GetSlots(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:713
Typemaker2_VirtualFn_GetParamTypeList
TYPEMAKER2_VIRTUALFN_PARAM_LIST * Typemaker2_VirtualFn_GetParamTypeList(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:370
Typemaker2_Inline_GetContent
const char * Typemaker2_Inline_GetContent(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:69
Typemaker2_Type_GetHeaders
TYPEMAKER2_HEADER_LIST * Typemaker2_Type_GetHeaders(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:650
Typemaker2_Member_GetFieldId
const char * Typemaker2_Member_GetFieldId(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:171
Typemaker2_Type_GetAqDbType
const char * Typemaker2_Type_GetAqDbType(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:195
Typemaker2_Type_GetExtendsPtr
TYPEMAKER2_TYPE * Typemaker2_Type_GetExtendsPtr(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:587
TYPEMAKER2_TYPEFLAGS_NOCOPY
#define TYPEMAKER2_TYPEFLAGS_NOCOPY
Definition: tm_type.h:68
TYPEMAKER2_VIRTUALFN_PARAM
struct TYPEMAKER2_VIRTUALFN_PARAM TYPEMAKER2_VIRTUALFN_PARAM
Definition: tm_virtualfn.h:24
_buildCacheFunctions
static int _buildCacheFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6820
_buildDup
static int _buildDup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3265
_buildDestructor
static int _buildDestructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:951
Typemaker2_Member_GetEnumPtr
TYPEMAKER2_ENUM * Typemaker2_Member_GetEnumPtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:485
_buildCodeVirtualFns
int _buildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4457
TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT
#define TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT
Definition: tm_virtualfn.h:28
_buildGetter
static int _buildGetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1113
_buildFromXml
static int _buildFromXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2668
Typemaker2_Member_GetDescription
const char * Typemaker2_Member_GetDescription(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:149
NULL
#define NULL
Definition: binreloc.c:300
TYPEMAKER2_SLOT
struct TYPEMAKER2_SLOT TYPEMAKER2_SLOT
Definition: tm_slot.h:27
Typemaker2_Header_GetLocation
int Typemaker2_Header_GetLocation(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:108
Typemaker2_Group_GetTitle
const char * Typemaker2_Group_GetTitle(TYPEMAKER2_GROUP *gr)
Definition: tm_group.c:69
_buildList1GetByMember
static int _buildList1GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5140
TYPEMAKER2_TYPEFLAGS_WITH_XML
#define TYPEMAKER2_TYPEFLAGS_WITH_XML
Definition: tm_type.h:54
_buildToHashString
static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5998
TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
#define TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
Definition: tm_slot.h:17
TypeMaker2_Access_Protected
Definition: tm_type.h:87
TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4
#define TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4
Definition: tm_signal.h:18
_buildCreateColumnList
static int _buildCreateColumnList(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3149
Typemaker2_VirtualFn_Param_GetDescr
const char * Typemaker2_VirtualFn_Param_GetDescr(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:478
Typemaker2_Builder_Invoke_ToObjectFn
int Typemaker2_Builder_Invoke_ToObjectFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_GROUP
struct TYPEMAKER2_GROUP TYPEMAKER2_GROUP
Definition: tm_group.h:19
Typemaker2_Define_Mode_Sequence
Definition: tm_define.h:30
_buildToObject
static int _buildToObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3021
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition: logger.h:35
TYPEMAKER2_FLAGS_DUP
#define TYPEMAKER2_FLAGS_DUP
Definition: tm_type.h:35
Typemaker2_Signal_GetFlags
uint32_t Typemaker2_Signal_GetFlags(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:146
TYPEMAKER2_FLAGS_WITH_GETBYMEMBER
#define TYPEMAKER2_FLAGS_WITH_GETBYMEMBER
Definition: tm_type.h:46
_buildFieldIds
static int _buildFieldIds(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:26
TYPEMAKER2_TYPEFLAGS_WITH_SLOTS
#define TYPEMAKER2_TYPEFLAGS_WITH_SLOTS
Definition: tm_type.h:63
Typemaker2_Member_GetGetFlags
uint32_t Typemaker2_Member_GetGetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:281
TYPEMAKER2_DEFINE
struct TYPEMAKER2_DEFINE TYPEMAKER2_DEFINE
Definition: tm_define.h:24
TYPEMAKER2_HEADER
struct TYPEMAKER2_HEADER TYPEMAKER2_HEADER
Definition: tm_header.h:19
_buildEnumToString
static int _buildEnumToString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5008
TYPEMAKER2_ENUM
struct TYPEMAKER2_ENUM TYPEMAKER2_ENUM
Definition: tm_enum.h:24
Typemaker2_Enum_SetFromStringFn
void Typemaker2_Enum_SetFromStringFn(TYPEMAKER2_ENUM *p_struct, const char *p_src)
Definition: tm_enum.c:286
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:38
Typemaker2_VirtualFn_SetAccess
void Typemaker2_VirtualFn_SetAccess(TYPEMAKER2_VIRTUALFN *vf, int i)
Definition: tm_virtualfn.c:292
Typemaker2_Type_GetSignals
TYPEMAKER2_SIGNAL_LIST * Typemaker2_Type_GetSignals(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:704
Typemaker2_HeaderLocation_Pre
Definition: tm_header.h:31
Typemaker2_Builder_Invoke_DestructFn
int Typemaker2_Builder_Invoke_DestructFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_FLAGS_SORTBYMEMBER
#define TYPEMAKER2_FLAGS_SORTBYMEMBER
Definition: tm_type.h:44
TYPEMAKER2_ITEM
struct TYPEMAKER2_ITEM TYPEMAKER2_ITEM
Definition: tm_item.h:22
Typemaker2_Member_GetMaxLen
int Typemaker2_Member_GetMaxLen(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:369
TYPEMAKER2_FLAGS_OMIT
#define TYPEMAKER2_FLAGS_OMIT
Definition: tm_type.h:41
Typemaker2_Define_GetPrefix
const char * Typemaker2_Define_GetPrefix(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:190
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:646
TYPEMAKER2_FLAGS_ASSIGN
#define TYPEMAKER2_FLAGS_ASSIGN
Definition: tm_type.h:40
Typemaker2_Builder_AddPrivateDeclaration
void Typemaker2_Builder_AddPrivateDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:173
Typemaker2_Builder_ReplaceVars
int Typemaker2_Builder_ReplaceVars(const char *s, GWEN_DB_NODE *db, GWEN_BUFFER *dbuf)
Definition: tm_builder.c:525
_buildReadDb
static int _buildReadDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1883
Typemaker2_Item_GetValue
const char * Typemaker2_Item_GetValue(const TYPEMAKER2_ITEM *p_struct)
Definition: tm_item.c:107
_buildMemberInlines
static int _buildMemberInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6183
TYPEMAKER2_INLINE
struct TYPEMAKER2_INLINE TYPEMAKER2_INLINE
Definition: tm_inline.h:19
Typemaker2_Member_GetPresetValue
const char * Typemaker2_Member_GetPresetValue(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:414
TYPEMAKER2_VIRTUALFN
struct TYPEMAKER2_VIRTUALFN TYPEMAKER2_VIRTUALFN
Definition: tm_virtualfn.h:21
GWEN_ERROR_BAD_DATA
#define GWEN_ERROR_BAD_DATA
Definition: error.h:121
Typemaker2_VirtualFn_Param_GetType
const char * Typemaker2_VirtualFn_Param_GetType(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:458
Typemaker2_InlineLocation_Header
Definition: tm_inline.h:25
_buildGroupApiDoc
static int _buildGroupApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_GROUP *grp, int depth, GWEN_BUFFER *buf)
Definition: tm_builder_c.c:6900
_buildWriteObject
static int _buildWriteObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2905
Typemaker2_VirtualFn_Param_new
TYPEMAKER2_VIRTUALFN_PARAM * Typemaker2_VirtualFn_Param_new()
Definition: tm_virtualfn.c:413
Typemaker2_Builder_Invoke_FromXmlFn
int Typemaker2_Builder_Invoke_FromXmlFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
Typemaker2_Member_GetAccess
int Typemaker2_Member_GetAccess(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:347
TYPEMAKER2_FLAGS_GWEN_CB
#define TYPEMAKER2_FLAGS_GWEN_CB
Definition: tm_type.h:50
Typemaker2_Define_GetId
const char * Typemaker2_Define_GetId(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:184
Typemaker2_HeaderLocation_Post
Definition: tm_header.h:32
Typemaker2_Type_GetInlines
TYPEMAKER2_INLINE_LIST * Typemaker2_Type_GetInlines(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:686
_buildProtoVirtualFns
int _buildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4266
Typemaker2_VirtualFn_free
void Typemaker2_VirtualFn_free(TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:45
_buildPostHeaders
static int _buildPostHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:330
_buildTypedef
static int _buildTypedef(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:76
Typemaker2_VirtualFn_AddFlags
void Typemaker2_VirtualFn_AddFlags(TYPEMAKER2_VIRTUALFN *vf, uint32_t fl)
Definition: tm_virtualfn.c:262
Typemaker2_Group_GetDescription
const char * Typemaker2_Group_GetDescription(TYPEMAKER2_GROUP *gr)
Definition: tm_group.c:93
Typemaker2_Member_GetMemberPosition
int Typemaker2_Member_GetMemberPosition(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:539
Typemaker2_VirtualFn_GetReturnType
const char * Typemaker2_VirtualFn_GetReturnType(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:302
TYPEMAKER2_FLAGS_NOCOPY
#define TYPEMAKER2_FLAGS_NOCOPY
Definition: tm_type.h:43
Typemaker2_Define_GetStartValue
int Typemaker2_Define_GetStartValue(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:214
Typemaker2_Inline_GetTypeFlagsMask
int Typemaker2_Inline_GetTypeFlagsMask(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:127
_buildList1SortByMember
static int _buildList1SortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5656
Typemaker2_Signal_GetParamType1
const char * Typemaker2_Signal_GetParamType1(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:134
Typemaker2_VirtualFn_GetDescr
const char * Typemaker2_VirtualFn_GetDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:218
_buildSortByMember
static int _buildSortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5854
TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
#define TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
Definition: tm_type.h:62
Typemaker2_Slot_GetFlags
uint32_t Typemaker2_Slot_GetFlags(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:146
TYPEMAKER2_FLAGS_NOCONSTOBJECT
#define TYPEMAKER2_FLAGS_NOCONSTOBJECT
Definition: tm_type.h:45
TYPEMAKER2_FLAGS_WITH_HASH
#define TYPEMAKER2_FLAGS_WITH_HASH
Definition: tm_type.h:47
Typemaker2_Type_GetIdentifier
const char * Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:543
Typemaker2_Builder_AddProtectedDeclaration
void Typemaker2_Builder_AddProtectedDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:165
_buildDefineEnums
static int _buildDefineEnums(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4023
TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS
#define TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS
Definition: tm_type.h:64
TYPEMAKER2_TYPEFLAGS_WITH_TREE
#define TYPEMAKER2_TYPEFLAGS_WITH_TREE
Definition: tm_type.h:60
Typemaker2_Type_GetFreeHook
const char * Typemaker2_Type_GetFreeHook(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:244
Typemaker2_VirtualFn_GetLocation
const char * Typemaker2_VirtualFn_GetLocation(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:194
Typemaker2_Builder_C_Build
static int Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7189
Typemaker2_Enum_GetPrefix
const char * Typemaker2_Enum_GetPrefix(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:186
_buildWriteXml
static int _buildWriteXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2512
_buildReadXml
static int _buildReadXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2310
Typemaker2_HeaderLocation_HeaderEnd
Definition: tm_header.h:35
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:390
Typemaker2_VirtualFn_GetDefaultReturnValue
const char * Typemaker2_VirtualFn_GetDefaultReturnValue(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:346
Typemaker2_HeaderType_System
Definition: tm_header.h:25
Typemaker2_Slot_GetName
const char * Typemaker2_Slot_GetName(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:128
_buildApiDoc
static int _buildApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7039
TYPEMAKER2_FLAGS_CONST
#define TYPEMAKER2_FLAGS_CONST
Definition: tm_type.h:33
Typemaker2_VirtualFn_SetDefaultReturnValue
void Typemaker2_VirtualFn_SetDefaultReturnValue(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:356
Typemaker2_Define_GetItems
TYPEMAKER2_ITEM_LIST * Typemaker2_Define_GetItems(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:202
Typemaker2_Member_GetDupFlags
uint32_t Typemaker2_Member_GetDupFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:303
Typemaker2_Type_GetNonVolatileMemberCount
int Typemaker2_Type_GetNonVolatileMemberCount(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:731
_buildDefineDefines
static int _buildDefineDefines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5894
TYPEMAKER2_BUILDER
struct TYPEMAKER2_BUILDER TYPEMAKER2_BUILDER
Definition: tm_builder.h:26
TYPEMAKER2_FLAGS_OWN
#define TYPEMAKER2_FLAGS_OWN
Definition: tm_type.h:31
_buildConstructor
static int _buildConstructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:681
TYPEMAKER2_FLAGS_ENUM
#define TYPEMAKER2_FLAGS_ENUM
Definition: tm_type.h:38
Typemaker2_Type_GetMembers
TYPEMAKER2_MEMBER_LIST * Typemaker2_Type_GetMembers(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:641
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:85
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
Typemaker2_InlineLocation_Code
Definition: tm_inline.h:26
Typemaker2_VirtualFn_Param_GetName
const char * Typemaker2_VirtualFn_Param_GetName(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:438
Typemaker2_Builder_AddCode
void Typemaker2_Builder_AddCode(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:181
_buildAttach
static int _buildAttach(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6277
Typemaker2_Builder_Invoke_FromDbFn
int Typemaker2_Builder_Invoke_FromDbFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
Typemaker2_Signal_GetName
const char * Typemaker2_Signal_GetName(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:128
_buildSignalFunctions
static int _buildSignalFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6328
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
TYPEMAKER2_TYPE
struct TYPEMAKER2_TYPE TYPEMAKER2_TYPE
Definition: tm_type.h:21
TYPEMAKER2_SLOT_FLAGS_USE_PARAM4
#define TYPEMAKER2_SLOT_FLAGS_USE_PARAM4
Definition: tm_slot.h:18
_buildReadObject
static int _buildReadObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2732
Typemaker2_Builder_AddPublicDeclaration
void Typemaker2_Builder_AddPublicDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:149
_buildFromDb
static int _buildFromDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2246
Typemaker2_Member_GetCopyFlags
uint32_t Typemaker2_Member_GetCopyFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:325
TYPEMAKER2_TYPEFLAGS_WITH_IDMAP
#define TYPEMAKER2_TYPEFLAGS_WITH_IDMAP
Definition: tm_type.h:59
Typemaker2_Enum_SetToStringFn
void Typemaker2_Enum_SetToStringFn(TYPEMAKER2_ENUM *p_struct, const char *p_src)
Definition: tm_enum.c:272
TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3
#define TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3
Definition: tm_signal.h:17
Typemaker2_VirtualFn_SetReturnType
void Typemaker2_VirtualFn_SetReturnType(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:312
_buildTreeGetByMember
static int _buildTreeGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5292
TYPEMAKER2_TYPEMANAGER
struct TYPEMAKER2_TYPEMANAGER TYPEMAKER2_TYPEMANAGER
Definition: tm_typemanager.h:19
Typemaker2_Builder_C_new
TYPEMAKER2_BUILDER * Typemaker2_Builder_C_new()
Definition: tm_builder_c.c:7534
_buildSetter
static int _buildSetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1320
_buildSetterVirtualFns
int _buildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4712
_buildInlines
static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6109
Typemaker2_VirtualFn_new
TYPEMAKER2_VIRTUALFN * Typemaker2_VirtualFn_new()
Definition: tm_virtualfn.c:30
Typemaker2_Inline_GetLocation
int Typemaker2_Inline_GetLocation(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:91
Typemaker2_Type_GetEnums
TYPEMAKER2_ENUM_LIST * Typemaker2_Type_GetEnums(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:659
Typemaker2_VirtualFn_SetName
void Typemaker2_VirtualFn_SetName(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:180
Typemaker2_Slot_GetParamType2
const char * Typemaker2_Slot_GetParamType2(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:140
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:178
Typemaker2_Builder_AddLibraryDeclaration
void Typemaker2_Builder_AddLibraryDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:157
_buildGetByMember
static int _buildGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5596
TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
#define TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
Definition: tm_type.h:61
Typemaker2_Type_GetPrefix
const char * Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:565
Typemaker2_Inline_GetAccess
int Typemaker2_Inline_GetAccess(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:109
_buildToDb
static int _buildToDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2195
Typemaker2_VirtualFn_SetLocation
void Typemaker2_VirtualFn_SetLocation(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:204
Typemaker2_Member_GetGroupPtr
TYPEMAKER2_GROUP * Typemaker2_Member_GetGroupPtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:521
_buildStruct
static int _buildStruct(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:424
Typemaker2_Type_GetType
int Typemaker2_Type_GetType(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:171
Typemaker2_Slot_GetParamType1
const char * Typemaker2_Slot_GetParamType1(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:134
Typemaker2_Define_Mode_BitField
Definition: tm_define.h:31
TYPEMAKER2_FLAGS_NODUP
#define TYPEMAKER2_FLAGS_NODUP
Definition: tm_type.h:36
Typemaker2_Builder_new
TYPEMAKER2_BUILDER * Typemaker2_Builder_new()
Definition: tm_builder.c:53
Typemaker2_TypeManager_GetApiDeclaration
const char * Typemaker2_TypeManager_GetApiDeclaration(const TYPEMAKER2_TYPEMANAGER *tym)
Definition: tm_typemanager.c:82
Typemaker2_Type_GetUsePrivateConstructor
int Typemaker2_Type_GetUsePrivateConstructor(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:473
TYPEMAKER2_MEMBER
struct TYPEMAKER2_MEMBER TYPEMAKER2_MEMBER
Definition: tm_member.h:21
_buildProtoSetterVirtualFns
int _buildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4613
_buildToXml
static int _buildToXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2617
Typemaker2_Member_GetSetFlags
uint32_t Typemaker2_Member_GetSetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:259
Typemaker2_Builder_Invoke_FromObjectFn
int Typemaker2_Builder_Invoke_FromObjectFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
_buildWriteDb
static int _buildWriteDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2080
_buildEnumFromString
static int _buildEnumFromString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4875
Typemaker2_Builder_Invoke_AssignFn
int Typemaker2_Builder_Invoke_AssignFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_TYPEFLAGS_WITH_INHERIT
#define TYPEMAKER2_TYPEFLAGS_WITH_INHERIT
Definition: tm_type.h:58
Typemaker2_Type_GetGroupTree
TYPEMAKER2_GROUP_TREE * Typemaker2_Type_GetGroupTree(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:722
Typemaker2_Builder_Invoke_ToXmlFn
int Typemaker2_Builder_Invoke_ToXmlFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
_buildCreateObject
static int _buildCreateObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3971
_setEnumStringFns
static int _setEnumStringFns(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4822
_buildDefineVirtualFns
int _buildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
Definition: tm_builder_c.c:4128
TypeMaker2_Type_Array
Definition: tm_type.h:79
_buildFromObject
static int _buildFromObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3072
Typemaker2_Type_GetFlags
uint32_t Typemaker2_Type_GetFlags(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:341
TYPEMAKER2_TYPEFLAGS_WITH_LIST2
#define TYPEMAKER2_TYPEFLAGS_WITH_LIST2
Definition: tm_type.h:57
Typemaker2_Member_GetName
const char * Typemaker2_Member_GetName(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:83
Typemaker2_Enum_GetType
const char * Typemaker2_Enum_GetType(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:192
Typemaker2_VirtualFn_GetFlags
uint32_t Typemaker2_VirtualFn_GetFlags(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:242
_buildEndHeaders
static int _buildEndHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:377
TYPEMAKER2_FLAGS_VOLATILE
#define TYPEMAKER2_FLAGS_VOLATILE
Definition: tm_type.h:32
TYPEMAKER2_TYPEFLAGS_WITH_OBJECT
#define TYPEMAKER2_TYPEFLAGS_WITH_OBJECT
Definition: tm_type.h:55
Typemaker2_Signal_GetParamType2
const char * Typemaker2_Signal_GetParamType2(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:140
_buildCreateTable
static int _buildCreateTable(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3913
Typemaker2_Type_GetDefines
TYPEMAKER2_DEFINE_LIST * Typemaker2_Type_GetDefines(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:668
Typemaker2_Type_GetFieldCountId
const char * Typemaker2_Type_GetFieldCountId(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:749
TypeMaker2_Access_Library
Definition: tm_type.h:88
Typemaker2_VirtualFn_GetName
const char * Typemaker2_VirtualFn_GetName(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:170
_buildMacroFunctions
static int _buildMacroFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:592
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:145
tm_builder_c.h
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:985
Typemaker2_Builder_Invoke_ConstructFn
int Typemaker2_Builder_Invoke_ConstructFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
Typemaker2_Builder_Invoke_ToHashStringFn
int Typemaker2_Builder_Invoke_ToHashStringFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TypeMaker2_Access_Private
Definition: tm_type.h:89
TYPEMAKER2_TYPEFLAGS_WITH_DB
#define TYPEMAKER2_TYPEFLAGS_WITH_DB
Definition: tm_type.h:53
Typemaker2_Define_GetMode
int Typemaker2_Define_GetMode(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:208
_delVirtualFnsFromSlots
static void _delVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7164
Typemaker2_Builder_CreateDbForCall
GWEN_DB_NODE * Typemaker2_Builder_CreateDbForCall(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst)
Definition: tm_builder.c:348
_addVirtualFnsFromSlots
static int _addVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7084
Typemaker2_Builder_Invoke_ToDbFn
int Typemaker2_Builder_Invoke_ToDbFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm, const char *src, const char *dst, GWEN_BUFFER *dbuf)
TYPEMAKER2_TYPEFLAGS_WITH_LIST1
#define TYPEMAKER2_TYPEFLAGS_WITH_LIST1
Definition: tm_type.h:56
Typemaker2_VirtualFn_GetAccess
int Typemaker2_VirtualFn_GetAccess(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:282
Generated by   doxygen 1.8.14