gwenhywfar  4.99.25rc9
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  GWEN_Buffer_AppendString(tbuf, " (*");
4173  s=Typemaker2_Type_GetIdentifier(ty);
4174  GWEN_Buffer_AppendString(tbuf, s);
4175  GWEN_Buffer_AppendString(tbuf, "_");
4176 
4177  s=Typemaker2_VirtualFn_GetName(vf);
4178  if (!(s && *s)) {
4179  GWEN_Buffer_free(tbuf);
4180  return GWEN_ERROR_BAD_DATA;
4181  }
4182  while (*s) {
4183  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4184  s++;
4185  }
4186  GWEN_Buffer_AppendString(tbuf, "_FN)(");
4187 
4188  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4189  GWEN_Buffer_AppendString(tbuf, "const ");
4190 
4191  s=Typemaker2_Type_GetIdentifier(ty);
4192  GWEN_Buffer_AppendString(tbuf, s);
4193  /* created structs are always pointers */
4194  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4195 
4196  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4197  if (plist) {
4198  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4199 
4200  i=1;
4201  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4202  while (prm) {
4203  const char *paramName;
4204  const char *paramType;
4205 
4206  GWEN_Buffer_AppendString(tbuf, ", ");
4207 
4208  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4209  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4210 
4211  GWEN_Buffer_AppendString(tbuf, paramType);
4212  GWEN_Buffer_AppendString(tbuf, " ");
4213 
4214  if (paramName)
4215  GWEN_Buffer_AppendString(tbuf, paramName);
4216  else {
4217  char numbuf[64];
4218 
4219  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4220  numbuf[sizeof(numbuf)-1]=0;
4221  GWEN_Buffer_AppendString(tbuf, numbuf);
4222  }
4223 
4224  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4225  i++;
4226  }
4227  }
4228 
4229  GWEN_Buffer_AppendString(tbuf, ");\n");
4230 
4231  switch (access) {
4232  case TypeMaker2_Access_Public:
4233  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4234  break;
4235  case TypeMaker2_Access_Library:
4236  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4237  break;
4238  case TypeMaker2_Access_Protected:
4239  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4240  break;
4241  case TypeMaker2_Access_Private:
4242  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4243  break;
4244  default:
4245  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4246  GWEN_Buffer_free(tbuf);
4247  return GWEN_ERROR_BAD_DATA;
4248  }
4249  GWEN_Buffer_Reset(tbuf);
4250  }
4251 
4252  vf=Typemaker2_VirtualFn_List_Next(vf);
4253  }
4254  }
4255 
4256  return 0;
4257 }
4258 
4259 
4260 
4261 int _buildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4262 {
4263  TYPEMAKER2_VIRTUALFN_LIST *fns;
4264  TYPEMAKER2_TYPEMANAGER *tym;
4265  /* uint32_t flags; */
4266 
4267  tym=Typemaker2_Builder_GetTypeManager(tb);
4268  fns=Typemaker2_Type_GetVirtualFns(ty);
4269  /* flags=Typemaker2_Type_GetFlags(ty); */
4270 
4271  assert(fns);
4272  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4273  GWEN_BUFFER *tbuf;
4274  const char *s;
4275  TYPEMAKER2_VIRTUALFN *vf;
4276 
4277  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4278 
4279  GWEN_Buffer_AppendString(tbuf, "/* prototypes for virtual functions */\n");
4280  vf=Typemaker2_VirtualFn_List_First(fns);
4281  while (vf) {
4282  int access=Typemaker2_VirtualFn_GetAccess(vf);
4283  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
4284  int i;
4285 
4286  /* write APIDOC */
4287  GWEN_Buffer_AppendString(tbuf, "/**\n");
4288  s=Typemaker2_VirtualFn_GetDescr(vf);
4289  if (s && *s) {
4290  int len;
4291 
4292  GWEN_Buffer_AppendString(tbuf, " * ");
4293  GWEN_Buffer_AppendString(tbuf, s);
4294  len=strlen(s);
4295  if (s[len-1]!='\n')
4296  GWEN_Buffer_AppendString(tbuf, "\n");
4297  }
4298 
4299  s=Typemaker2_VirtualFn_GetReturnTypeDescr(vf);
4300  if (s && *s) {
4301  int len;
4302 
4303  GWEN_Buffer_AppendString(tbuf, " * @return ");
4304  GWEN_Buffer_AppendString(tbuf, s);
4305  len=strlen(s);
4306  if (s[len-1]!='\n')
4307  GWEN_Buffer_AppendString(tbuf, "\n");
4308  }
4309 
4310 
4311  i=1;
4312  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4313  if (plist) {
4314  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4315 
4316  i=1;
4317  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4318  while (prm) {
4319  const char *paramDescr;
4320 
4321  paramDescr=Typemaker2_VirtualFn_Param_GetDescr(prm);
4322  if (paramDescr && *paramDescr) {
4323  const char *paramName;
4324  int len;
4325 
4326  GWEN_Buffer_AppendString(tbuf, " * @param ");
4327  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4328  if (paramName)
4329  GWEN_Buffer_AppendString(tbuf, paramName);
4330  else {
4331  char numbuf[64];
4332 
4333  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4334  numbuf[sizeof(numbuf)-1]=0;
4335  GWEN_Buffer_AppendString(tbuf, numbuf);
4336  }
4337 
4338  GWEN_Buffer_AppendString(tbuf, " ");
4339  GWEN_Buffer_AppendString(tbuf, paramDescr);
4340  len=strlen(paramDescr);
4341  if (paramDescr[len-1]!='\n')
4342  GWEN_Buffer_AppendString(tbuf, "\n");
4343  }
4344 
4345  i++;
4346  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4347  }
4348  }
4349  GWEN_Buffer_AppendString(tbuf, " */\n");
4350 
4351 
4352  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4353  if (s && *s) {
4354  GWEN_Buffer_AppendString(tbuf, s);
4355  GWEN_Buffer_AppendString(tbuf, " ");
4356  }
4357 
4358  s=Typemaker2_VirtualFn_GetReturnType(vf);
4359  if (!(s && *s)) {
4360  GWEN_Buffer_free(tbuf);
4361  return GWEN_ERROR_BAD_DATA;
4362  }
4363  GWEN_Buffer_AppendString(tbuf, s);
4364  GWEN_Buffer_AppendString(tbuf, " ");
4365 
4366  s=Typemaker2_Type_GetPrefix(ty);
4367  GWEN_Buffer_AppendString(tbuf, s);
4368  GWEN_Buffer_AppendString(tbuf, "_");
4369  s=Typemaker2_VirtualFn_GetName(vf);
4370  if (!(s && *s)) {
4371  GWEN_Buffer_free(tbuf);
4372  return GWEN_ERROR_BAD_DATA;
4373  }
4374  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4375  GWEN_Buffer_AppendString(tbuf, s+1);
4376  GWEN_Buffer_AppendString(tbuf, "(");
4377 
4378  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4379  GWEN_Buffer_AppendString(tbuf, "const ");
4380 
4381  s=Typemaker2_Type_GetIdentifier(ty);
4382  GWEN_Buffer_AppendString(tbuf, s);
4383  /* created structs are always pointers */
4384  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4385 
4386 
4387  i=1;
4388  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4389  if (plist) {
4390  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4391 
4392  i=1;
4393  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4394  while (prm) {
4395  const char *paramName;
4396  const char *paramType;
4397 
4398  GWEN_Buffer_AppendString(tbuf, ", ");
4399 
4400  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4401  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4402 
4403  GWEN_Buffer_AppendString(tbuf, paramType);
4404  GWEN_Buffer_AppendString(tbuf, " ");
4405 
4406  if (paramName)
4407  GWEN_Buffer_AppendString(tbuf, paramName);
4408  else {
4409  char numbuf[64];
4410 
4411  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4412  numbuf[sizeof(numbuf)-1]=0;
4413  GWEN_Buffer_AppendString(tbuf, numbuf);
4414  }
4415 
4416  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4417  i++;
4418  }
4419  }
4420  GWEN_Buffer_AppendString(tbuf, ");\n");
4421 
4422 
4423  switch (access) {
4424  case TypeMaker2_Access_Public:
4425  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4426  break;
4427  case TypeMaker2_Access_Library:
4428  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4429  break;
4430  case TypeMaker2_Access_Protected:
4431  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4432  break;
4433  case TypeMaker2_Access_Private:
4434  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4435  break;
4436  default:
4437  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4438  GWEN_Buffer_free(tbuf);
4439  return GWEN_ERROR_BAD_DATA;
4440  }
4441  GWEN_Buffer_Reset(tbuf);
4442 
4443  vf=Typemaker2_VirtualFn_List_Next(vf);
4444  }
4445  }
4446 
4447  return 0;
4448 }
4449 
4450 
4451 
4452 int _buildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4453 {
4454  TYPEMAKER2_VIRTUALFN_LIST *fns;
4455  /* TYPEMAKER2_TYPEMANAGER *tym; */
4456  /* uint32_t flags; */
4457 
4458  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4459  fns=Typemaker2_Type_GetVirtualFns(ty);
4460  /* flags=Typemaker2_Type_GetFlags(ty); */
4461 
4462  assert(fns);
4463  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4464  GWEN_BUFFER *tbuf;
4465  const char *s;
4466  TYPEMAKER2_VIRTUALFN *vf;
4467 
4468  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4469 
4470  GWEN_Buffer_AppendString(tbuf, "/* code for virtual functions */\n");
4471  vf=Typemaker2_VirtualFn_List_First(fns);
4472  while (vf) {
4473  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
4474  int i;
4475 
4476  s=Typemaker2_VirtualFn_GetReturnType(vf);
4477  if (!(s && *s)) {
4478  GWEN_Buffer_free(tbuf);
4479  return GWEN_ERROR_BAD_DATA;
4480  }
4481  GWEN_Buffer_AppendString(tbuf, s);
4482  GWEN_Buffer_AppendString(tbuf, " ");
4483 
4484  s=Typemaker2_Type_GetPrefix(ty);
4485  GWEN_Buffer_AppendString(tbuf, s);
4486  GWEN_Buffer_AppendString(tbuf, "_");
4487  s=Typemaker2_VirtualFn_GetName(vf);
4488  if (!(s && *s)) {
4489  GWEN_Buffer_free(tbuf);
4490  return GWEN_ERROR_BAD_DATA;
4491  }
4492  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4493  GWEN_Buffer_AppendString(tbuf, s+1);
4494  GWEN_Buffer_AppendString(tbuf, "(");
4495 
4496  if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
4497  GWEN_Buffer_AppendString(tbuf, "const ");
4498 
4499  s=Typemaker2_Type_GetIdentifier(ty);
4500  GWEN_Buffer_AppendString(tbuf, s);
4501  /* created structs are always pointers */
4502  GWEN_Buffer_AppendString(tbuf, " *p_struct");
4503 
4504 
4505  i=1;
4506  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4507  if (plist) {
4508  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4509 
4510  i=1;
4511  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4512  while (prm) {
4513  const char *paramName;
4514  const char *paramType;
4515 
4516  GWEN_Buffer_AppendString(tbuf, ", ");
4517 
4518  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4519  paramType=Typemaker2_VirtualFn_Param_GetType(prm);
4520 
4521  GWEN_Buffer_AppendString(tbuf, paramType);
4522  GWEN_Buffer_AppendString(tbuf, " ");
4523 
4524  if (paramName)
4525  GWEN_Buffer_AppendString(tbuf, paramName);
4526  else {
4527  char numbuf[64];
4528 
4529  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4530  numbuf[sizeof(numbuf)-1]=0;
4531  GWEN_Buffer_AppendString(tbuf, numbuf);
4532  }
4533 
4534  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4535  i++;
4536  }
4537  }
4538  GWEN_Buffer_AppendString(tbuf, ") {\n");
4539 
4540  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
4541  GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
4542  s=Typemaker2_VirtualFn_GetName(vf);
4543  if (!(s && *s)) {
4544  DBG_ERROR(0, "Virtual functions has no name");
4545  GWEN_Buffer_free(tbuf);
4546  return GWEN_ERROR_BAD_DATA;
4547  }
4548  GWEN_Buffer_AppendString(tbuf, s);
4549  GWEN_Buffer_AppendString(tbuf, "Fn)\n");
4550  GWEN_Buffer_AppendString(tbuf, " return p_struct->");
4551  GWEN_Buffer_AppendString(tbuf, s);
4552  GWEN_Buffer_AppendString(tbuf, "Fn(p_struct");
4553 
4554  i=1;
4555  plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
4556  if (plist) {
4557  TYPEMAKER2_VIRTUALFN_PARAM *prm;
4558 
4559  i=1;
4560  prm=Typemaker2_VirtualFn_Param_List_First(plist);
4561  while (prm) {
4562  const char *paramName;
4563 
4564  GWEN_Buffer_AppendString(tbuf, ", ");
4565 
4566  paramName=Typemaker2_VirtualFn_Param_GetName(prm);
4567 
4568  if (paramName)
4569  GWEN_Buffer_AppendString(tbuf, paramName);
4570  else {
4571  char numbuf[64];
4572 
4573  snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
4574  numbuf[sizeof(numbuf)-1]=0;
4575  GWEN_Buffer_AppendString(tbuf, numbuf);
4576  }
4577 
4578  prm=Typemaker2_VirtualFn_Param_List_Next(prm);
4579  i++;
4580  }
4581  }
4582  GWEN_Buffer_AppendString(tbuf, ");\n");
4583 
4584  GWEN_Buffer_AppendString(tbuf, " else\n");
4585  GWEN_Buffer_AppendString(tbuf, " return ");
4586  s=Typemaker2_VirtualFn_GetDefaultReturnValue(vf);
4587  if (!(s && *s)) {
4588  DBG_ERROR(0, "No default return value");
4589  GWEN_Buffer_free(tbuf);
4590  return GWEN_ERROR_BAD_DATA;
4591  }
4592  GWEN_Buffer_AppendString(tbuf, s);
4593  GWEN_Buffer_AppendString(tbuf, ";\n");
4594  GWEN_Buffer_AppendString(tbuf, "}\n");
4595 
4596  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4597  GWEN_Buffer_Reset(tbuf);
4598 
4599  vf=Typemaker2_VirtualFn_List_Next(vf);
4600  }
4601  }
4602 
4603  return 0;
4604 }
4605 
4606 
4607 
4608 int _buildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4609 {
4610  TYPEMAKER2_VIRTUALFN_LIST *fns;
4611  TYPEMAKER2_TYPEMANAGER *tym;
4612  /* uint32_t flags; */
4613 
4614  tym=Typemaker2_Builder_GetTypeManager(tb);
4615  fns=Typemaker2_Type_GetVirtualFns(ty);
4616  /* flags=Typemaker2_Type_GetFlags(ty); */
4617 
4618  assert(fns);
4619  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4620  GWEN_BUFFER *tbuf;
4621  const char *s;
4622  TYPEMAKER2_VIRTUALFN *vf;
4623 
4624  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4625 
4626  GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
4627  vf=Typemaker2_VirtualFn_List_First(fns);
4628  while (vf) {
4629  int access=Typemaker2_VirtualFn_GetAccess(vf);
4630 
4631  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4632  if (s && *s) {
4633  GWEN_Buffer_AppendString(tbuf, s);
4634  GWEN_Buffer_AppendString(tbuf, " ");
4635  }
4636 
4637  s=Typemaker2_Type_GetIdentifier(ty);
4638  GWEN_Buffer_AppendString(tbuf, s);
4639  GWEN_Buffer_AppendString(tbuf, "_");
4640  s=Typemaker2_VirtualFn_GetName(vf);
4641  if (!(s && *s)) {
4642  GWEN_Buffer_free(tbuf);
4643  return GWEN_ERROR_BAD_DATA;
4644  }
4645  while (*s)
4646  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4647  GWEN_Buffer_AppendString(tbuf, "_FN ");
4648 
4649  s=Typemaker2_Type_GetPrefix(ty);
4650  GWEN_Buffer_AppendString(tbuf, s);
4651  GWEN_Buffer_AppendString(tbuf, "_Set");
4652  s=Typemaker2_VirtualFn_GetName(vf);
4653  if (!(s && *s)) {
4654  GWEN_Buffer_free(tbuf);
4655  return GWEN_ERROR_BAD_DATA;
4656  }
4657  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4658  GWEN_Buffer_AppendString(tbuf, s+1);
4659  GWEN_Buffer_AppendString(tbuf, "Fn(");
4660 
4661  s=Typemaker2_Type_GetIdentifier(ty);
4662  GWEN_Buffer_AppendString(tbuf, s);
4663  /* created structs are always pointers */
4664  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
4665 
4666  s=Typemaker2_Type_GetIdentifier(ty);
4667  GWEN_Buffer_AppendString(tbuf, s);
4668  GWEN_Buffer_AppendString(tbuf, "_");
4669  s=Typemaker2_VirtualFn_GetName(vf);
4670  if (!(s && *s)) {
4671  GWEN_Buffer_free(tbuf);
4672  return GWEN_ERROR_BAD_DATA;
4673  }
4674  while (*s)
4675  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4676  GWEN_Buffer_AppendString(tbuf, "_FN fn);\n");
4677 
4678  switch (access) {
4679  case TypeMaker2_Access_Public:
4680  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4681  break;
4682  case TypeMaker2_Access_Library:
4683  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4684  break;
4685  case TypeMaker2_Access_Protected:
4686  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4687  break;
4688  case TypeMaker2_Access_Private:
4689  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4690  break;
4691  default:
4692  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4693  GWEN_Buffer_free(tbuf);
4694  return GWEN_ERROR_BAD_DATA;
4695  }
4696  GWEN_Buffer_Reset(tbuf);
4697 
4698  vf=Typemaker2_VirtualFn_List_Next(vf);
4699  }
4700  }
4701 
4702  return 0;
4703 }
4704 
4705 
4706 
4707 int _buildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4708 {
4709  TYPEMAKER2_VIRTUALFN_LIST *fns;
4710  /* TYPEMAKER2_TYPEMANAGER *tym; */
4711  /* uint32_t flags; */
4712 
4713  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4714  fns=Typemaker2_Type_GetVirtualFns(ty);
4715  /* flags=Typemaker2_Type_GetFlags(ty); */
4716 
4717  assert(fns);
4718  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4719  GWEN_BUFFER *tbuf;
4720  const char *s;
4721  TYPEMAKER2_VIRTUALFN *vf;
4722 
4723  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4724 
4725  GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
4726  vf=Typemaker2_VirtualFn_List_First(fns);
4727  while (vf) {
4728 
4729  s=Typemaker2_Type_GetIdentifier(ty);
4730  GWEN_Buffer_AppendString(tbuf, s);
4731  GWEN_Buffer_AppendString(tbuf, "_");
4732 
4733  s=Typemaker2_VirtualFn_GetName(vf);
4734  if (!(s && *s)) {
4735  GWEN_Buffer_free(tbuf);
4736  return GWEN_ERROR_BAD_DATA;
4737  }
4738  while (*s)
4739  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4740  GWEN_Buffer_AppendString(tbuf, "_FN ");
4741 
4742  s=Typemaker2_Type_GetPrefix(ty);
4743  GWEN_Buffer_AppendString(tbuf, s);
4744  GWEN_Buffer_AppendString(tbuf, "_Set");
4745  s=Typemaker2_VirtualFn_GetName(vf);
4746  if (!(s && *s)) {
4747  GWEN_Buffer_free(tbuf);
4748  return GWEN_ERROR_BAD_DATA;
4749  }
4750  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4751  GWEN_Buffer_AppendString(tbuf, s+1);
4752  GWEN_Buffer_AppendString(tbuf, "Fn(");
4753 
4754  s=Typemaker2_Type_GetIdentifier(ty);
4755  GWEN_Buffer_AppendString(tbuf, s);
4756  /* created structs are always pointers */
4757  GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
4758 
4759  s=Typemaker2_Type_GetIdentifier(ty);
4760  GWEN_Buffer_AppendString(tbuf, s);
4761  GWEN_Buffer_AppendString(tbuf, "_");
4762  s=Typemaker2_VirtualFn_GetName(vf);
4763  if (!(s && *s)) {
4764  GWEN_Buffer_free(tbuf);
4765  return GWEN_ERROR_BAD_DATA;
4766  }
4767  while (*s)
4768  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4769  GWEN_Buffer_AppendString(tbuf, "_FN fn){\n");
4770 
4771  GWEN_Buffer_AppendString(tbuf, " ");
4772  s=Typemaker2_Type_GetIdentifier(ty);
4773  GWEN_Buffer_AppendString(tbuf, s);
4774  GWEN_Buffer_AppendString(tbuf, "_");
4775  s=Typemaker2_VirtualFn_GetName(vf);
4776  if (!(s && *s)) {
4777  GWEN_Buffer_free(tbuf);
4778  return GWEN_ERROR_BAD_DATA;
4779  }
4780  while (*s)
4781  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4782  GWEN_Buffer_AppendString(tbuf, "_FN oldFn;\n\n");
4783 
4784  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
4785  GWEN_Buffer_AppendString(tbuf, " oldFn=p_struct->");
4786  s=Typemaker2_VirtualFn_GetName(vf);
4787  if (!(s && *s)) {
4788  GWEN_Buffer_free(tbuf);
4789  return GWEN_ERROR_BAD_DATA;
4790  }
4791  GWEN_Buffer_AppendString(tbuf, s);
4792  GWEN_Buffer_AppendString(tbuf, "Fn;\n");
4793 
4794  GWEN_Buffer_AppendString(tbuf, " p_struct->");
4795  s=Typemaker2_VirtualFn_GetName(vf);
4796  if (!(s && *s)) {
4797  GWEN_Buffer_free(tbuf);
4798  return GWEN_ERROR_BAD_DATA;
4799  }
4800  GWEN_Buffer_AppendString(tbuf, s);
4801  GWEN_Buffer_AppendString(tbuf, "Fn=fn;\n");
4802  GWEN_Buffer_AppendString(tbuf, " return oldFn;\n");
4803  GWEN_Buffer_AppendString(tbuf, "}\n");
4804 
4805  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4806  GWEN_Buffer_Reset(tbuf);
4807 
4808  vf=Typemaker2_VirtualFn_List_Next(vf);
4809  }
4810  }
4811 
4812  return 0;
4813 }
4814 
4815 
4816 
4817 static int _setEnumStringFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4818 {
4819  TYPEMAKER2_ENUM_LIST *enums;
4820  /* TYPEMAKER2_TYPEMANAGER *tym; */
4821  /* uint32_t flags; */
4822 
4823  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4824  enums=Typemaker2_Type_GetEnums(ty);
4825  /* flags=Typemaker2_Type_GetFlags(ty); */
4826 
4827  assert(enums);
4828  if (Typemaker2_Enum_List_GetCount(enums)) {
4829  TYPEMAKER2_ENUM *te;
4830 
4831  te=Typemaker2_Enum_List_First(enums);
4832  while (te) {
4833  const char *prefix;
4834  GWEN_BUFFER *tbuf;
4835 
4836  prefix=Typemaker2_Enum_GetPrefix(te);
4837  if (prefix==NULL || *prefix==0) {
4838  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
4839  return GWEN_ERROR_BAD_DATA;
4840  }
4841 
4842  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4843  if (prefix && *prefix) {
4844  GWEN_Buffer_AppendString(tbuf, prefix);
4845  if (prefix[strlen(prefix)-1]!='_')
4846  GWEN_Buffer_AppendString(tbuf, "_");
4847  }
4848  GWEN_Buffer_AppendString(tbuf, "fromString");
4849  Typemaker2_Enum_SetFromStringFn(te, GWEN_Buffer_GetStart(tbuf));
4850  GWEN_Buffer_Reset(tbuf);
4851 
4852  if (prefix && *prefix) {
4853  GWEN_Buffer_AppendString(tbuf, prefix);
4854  if (prefix[strlen(prefix)-1]!='_')
4855  GWEN_Buffer_AppendString(tbuf, "_");
4856  }
4857  GWEN_Buffer_AppendString(tbuf, "toString");
4858  Typemaker2_Enum_SetToStringFn(te, GWEN_Buffer_GetStart(tbuf));
4859  GWEN_Buffer_free(tbuf);
4860 
4861  te=Typemaker2_Enum_List_Next(te);
4862  }
4863  }
4864 
4865  return 0;
4866 }
4867 
4868 
4869 
4870 static int _buildEnumFromString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4871 {
4872  TYPEMAKER2_ENUM_LIST *enums;
4873  TYPEMAKER2_TYPEMANAGER *tym;
4874  /* uint32_t flags; */
4875 
4876  tym=Typemaker2_Builder_GetTypeManager(tb);
4877  enums=Typemaker2_Type_GetEnums(ty);
4878  /* flags=Typemaker2_Type_GetFlags(ty); */
4879 
4880  assert(enums);
4881  if (Typemaker2_Enum_List_GetCount(enums)) {
4882  GWEN_BUFFER *tbuf;
4883  const char *s;
4884  TYPEMAKER2_ENUM *te;
4885 
4886  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4887 
4888  te=Typemaker2_Enum_List_First(enums);
4889  while (te) {
4890  const char *prefix;
4891  const char *etype;
4892  TYPEMAKER2_ITEM *ti;
4893  int acc=TypeMaker2_Access_Public;
4894  int i;
4895 
4896  prefix=Typemaker2_Enum_GetPrefix(te);
4897  if (prefix==NULL || *prefix==0) {
4898  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
4899  GWEN_Buffer_free(tbuf);
4900  return GWEN_ERROR_BAD_DATA;
4901  }
4902 
4903  etype=Typemaker2_Enum_GetType(te);
4904 
4905  /* prototype */
4906  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4907  if (s) {
4908  GWEN_Buffer_AppendString(tbuf, s);
4909  GWEN_Buffer_AppendString(tbuf, " ");
4910  }
4911  if (etype && *etype) {
4912  GWEN_Buffer_AppendString(tbuf, etype);
4913  GWEN_Buffer_AppendString(tbuf, " ");
4914  }
4915  else
4916  GWEN_Buffer_AppendString(tbuf, "int ");
4917  if (prefix && *prefix) {
4918  GWEN_Buffer_AppendString(tbuf, prefix);
4919  if (prefix[strlen(prefix)-1]!='_')
4920  GWEN_Buffer_AppendString(tbuf, "_");
4921  }
4922  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s);\n");
4923  switch (acc) {
4924  case TypeMaker2_Access_Public:
4925  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4926  break;
4927  case TypeMaker2_Access_Library:
4928  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4929  break;
4930  case TypeMaker2_Access_Protected:
4931  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4932  break;
4933  case TypeMaker2_Access_Private:
4934  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4935  break;
4936  default:
4937  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4938  GWEN_Buffer_free(tbuf);
4939  return GWEN_ERROR_BAD_DATA;
4940  }
4941  GWEN_Buffer_Reset(tbuf);
4942 
4943  /* implementation */
4944  if (etype && *etype) {
4945  GWEN_Buffer_AppendString(tbuf, etype);
4946  GWEN_Buffer_AppendString(tbuf, " ");
4947  }
4948  else
4949  GWEN_Buffer_AppendString(tbuf, "int ");
4950  if (prefix && *prefix) {
4951  GWEN_Buffer_AppendString(tbuf, prefix);
4952  if (prefix[strlen(prefix)-1]!='_')
4953  GWEN_Buffer_AppendString(tbuf, "_");
4954  }
4955  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s) {\n");
4956 
4957  GWEN_Buffer_AppendString(tbuf, " if (p_s && *p_s) {\n");
4958 
4959  i=0;
4960  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
4961  while (ti) {
4962  GWEN_Buffer_AppendString(tbuf, " ");
4963  if (i++)
4964  GWEN_Buffer_AppendString(tbuf, "else ");
4965  GWEN_Buffer_AppendString(tbuf, "if (strcasecmp(p_s, \"");
4966  s=Typemaker2_Item_GetName(ti);
4967  if (s && *s) {
4968  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
4969  GWEN_Buffer_AppendString(tbuf, s+1);
4970  }
4971  GWEN_Buffer_AppendString(tbuf, "\")==0)\n");
4972  GWEN_Buffer_AppendString(tbuf, " return ");
4973  if (prefix)
4974  GWEN_Buffer_AppendString(tbuf, prefix);
4975  s=Typemaker2_Item_GetName(ti);
4976  if (s && *s) {
4977  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4978  GWEN_Buffer_AppendString(tbuf, s+1);
4979  }
4980  GWEN_Buffer_AppendString(tbuf, ";\n");
4981 
4982  ti=Typemaker2_Item_List_Next(ti);
4983  }
4984  GWEN_Buffer_AppendString(tbuf, " }\n");
4985  GWEN_Buffer_AppendString(tbuf, " return ");
4986  if (prefix)
4987  GWEN_Buffer_AppendString(tbuf, prefix);
4988  GWEN_Buffer_AppendString(tbuf, "Unknown;\n");
4989  GWEN_Buffer_AppendString(tbuf, "}\n");
4990 
4991  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4992  GWEN_Buffer_Reset(tbuf);
4993  te=Typemaker2_Enum_List_Next(te);
4994  }
4995  GWEN_Buffer_free(tbuf);
4996  } /* if enums */
4997 
4998  return 0;
4999 }
5000 
5001 
5002 
5003 static int _buildEnumToString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5004 {
5005  TYPEMAKER2_ENUM_LIST *enums;
5006  TYPEMAKER2_TYPEMANAGER *tym;
5007  /* uint32_t flags; */
5008 
5009  tym=Typemaker2_Builder_GetTypeManager(tb);
5010  enums=Typemaker2_Type_GetEnums(ty);
5011  /* flags=Typemaker2_Type_GetFlags(ty); */
5012 
5013  assert(enums);
5014  if (Typemaker2_Enum_List_GetCount(enums)) {
5015  GWEN_BUFFER *tbuf;
5016  const char *s;
5017  TYPEMAKER2_ENUM *te;
5018 
5019  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5020 
5021  te=Typemaker2_Enum_List_First(enums);
5022  while (te) {
5023  const char *prefix;
5024  const char *etype;
5025  TYPEMAKER2_ITEM *ti;
5026  int acc=TypeMaker2_Access_Public;
5027 
5028  prefix=Typemaker2_Enum_GetPrefix(te);
5029  if (prefix==NULL || *prefix==0) {
5030  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
5031  GWEN_Buffer_free(tbuf);
5032  return GWEN_ERROR_BAD_DATA;
5033  }
5034 
5035  etype=Typemaker2_Enum_GetType(te);
5036 
5037  /* prototype */
5038  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5039  if (s) {
5040  GWEN_Buffer_AppendString(tbuf, s);
5041  GWEN_Buffer_AppendString(tbuf, " ");
5042  }
5043  GWEN_Buffer_AppendString(tbuf, "const char *");
5044  if (prefix && *prefix) {
5045  GWEN_Buffer_AppendString(tbuf, prefix);
5046  if (prefix[strlen(prefix)-1]!='_')
5047  GWEN_Buffer_AppendString(tbuf, "_");
5048  }
5049  GWEN_Buffer_AppendString(tbuf, "toString(");
5050  if (etype && *etype)
5051  GWEN_Buffer_AppendString(tbuf, etype);
5052  else
5053  GWEN_Buffer_AppendString(tbuf, "int");
5054  GWEN_Buffer_AppendString(tbuf, " p_i);\n");
5055 
5056  switch (acc) {
5057  case TypeMaker2_Access_Public:
5058  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5059  break;
5060  case TypeMaker2_Access_Library:
5061  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5062  break;
5063  case TypeMaker2_Access_Protected:
5064  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5065  break;
5066  case TypeMaker2_Access_Private:
5067  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5068  break;
5069  default:
5070  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5071  GWEN_Buffer_free(tbuf);
5072  return GWEN_ERROR_BAD_DATA;
5073  }
5074  GWEN_Buffer_Reset(tbuf);
5075 
5076  /* implementation */
5077  GWEN_Buffer_AppendString(tbuf, "const char *");
5078  if (prefix && *prefix) {
5079  GWEN_Buffer_AppendString(tbuf, prefix);
5080  if (prefix[strlen(prefix)-1]!='_')
5081  GWEN_Buffer_AppendString(tbuf, "_");
5082  }
5083  GWEN_Buffer_AppendString(tbuf, "toString(");
5084  if (etype && *etype)
5085  GWEN_Buffer_AppendString(tbuf, etype);
5086  else
5087  GWEN_Buffer_AppendString(tbuf, "int");
5088  GWEN_Buffer_AppendString(tbuf, " p_i) {\n");
5089 
5090  GWEN_Buffer_AppendString(tbuf, " switch(p_i) {\n");
5091  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
5092  while (ti) {
5093  GWEN_Buffer_AppendString(tbuf, " case ");
5094  if (prefix)
5095  GWEN_Buffer_AppendString(tbuf, prefix);
5096  s=Typemaker2_Item_GetName(ti);
5097  if (s && *s) {
5098  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5099  GWEN_Buffer_AppendString(tbuf, s+1);
5100  }
5101  GWEN_Buffer_AppendString(tbuf, ": return \"");
5102  s=Typemaker2_Item_GetName(ti);
5103  if (s && *s) {
5104  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
5105  GWEN_Buffer_AppendString(tbuf, s+1);
5106  }
5107  GWEN_Buffer_AppendString(tbuf, "\";\n");
5108 
5109  ti=Typemaker2_Item_List_Next(ti);
5110  }
5111 
5112  /* handle "unknown" */
5113  GWEN_Buffer_AppendString(tbuf, " case ");
5114  if (prefix)
5115  GWEN_Buffer_AppendString(tbuf, prefix);
5116  GWEN_Buffer_AppendString(tbuf, "Unknown:\n");
5117 
5118  /* handle default */
5119  GWEN_Buffer_AppendString(tbuf, " default: return \"unknown\";\n");
5120  GWEN_Buffer_AppendString(tbuf, " }\n");
5121  GWEN_Buffer_AppendString(tbuf, "}\n");
5122 
5123  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5124  GWEN_Buffer_Reset(tbuf);
5125  te=Typemaker2_Enum_List_Next(te);
5126  }
5127  GWEN_Buffer_free(tbuf);
5128  } /* if enums */
5129 
5130  return 0;
5131 }
5132 
5133 
5134 
5135 static int _buildList1GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5136 {
5137  GWEN_BUFFER *tbuf;
5138  const char *s;
5139  /* uint32_t flags; */
5140  TYPEMAKER2_TYPEMANAGER *tym;
5141  TYPEMAKER2_TYPE *mty;
5142 
5143  tym=Typemaker2_Builder_GetTypeManager(tb);
5144  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5145 
5146  /* flags=Typemaker2_Type_GetFlags(ty); */
5147 
5148  mty=Typemaker2_Member_GetTypePtr(tm);
5149  assert(mty);
5150 
5151  /* prototype */
5152  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5153  if (s) {
5154  GWEN_Buffer_AppendString(tbuf, s);
5155  GWEN_Buffer_AppendString(tbuf, " ");
5156  }
5157 
5158  s=Typemaker2_Type_GetIdentifier(ty);
5159  GWEN_Buffer_AppendString(tbuf, s);
5160  GWEN_Buffer_AppendString(tbuf, " *");
5161 
5162  s=Typemaker2_Type_GetPrefix(ty);
5163  GWEN_Buffer_AppendString(tbuf, s);
5164  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5165  GWEN_Buffer_AppendString(tbuf, "By");
5166  s=Typemaker2_Member_GetName(tm);
5167  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5168  GWEN_Buffer_AppendString(tbuf, s+1);
5169  GWEN_Buffer_AppendString(tbuf, "(const ");
5170  s=Typemaker2_Type_GetIdentifier(ty);
5171  GWEN_Buffer_AppendString(tbuf, s);
5172  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5173  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5174  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5175  GWEN_Buffer_AppendString(tbuf, " const ");
5176  s=Typemaker2_Type_GetIdentifier(mty);
5177  GWEN_Buffer_AppendString(tbuf, s);
5178  GWEN_Buffer_AppendString(tbuf, " *");
5179  }
5180  else {
5181  s=Typemaker2_Type_GetIdentifier(mty);
5182  GWEN_Buffer_AppendString(tbuf, s);
5183  GWEN_Buffer_AppendString(tbuf, " ");
5184  }
5185  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5186 
5187  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5188  GWEN_Buffer_Reset(tbuf);
5189 
5190  /* implementation */
5191  s=Typemaker2_Type_GetIdentifier(ty);
5192  GWEN_Buffer_AppendString(tbuf, s);
5193  GWEN_Buffer_AppendString(tbuf, " *");
5194 
5195  s=Typemaker2_Type_GetPrefix(ty);
5196  GWEN_Buffer_AppendString(tbuf, s);
5197  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5198  GWEN_Buffer_AppendString(tbuf, "By");
5199  s=Typemaker2_Member_GetName(tm);
5200  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5201  GWEN_Buffer_AppendString(tbuf, s+1);
5202  GWEN_Buffer_AppendString(tbuf, "(const ");
5203  s=Typemaker2_Type_GetIdentifier(ty);
5204  GWEN_Buffer_AppendString(tbuf, s);
5205  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5206  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5207  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5208  GWEN_Buffer_AppendString(tbuf, " const ");
5209  s=Typemaker2_Type_GetIdentifier(mty);
5210  GWEN_Buffer_AppendString(tbuf, s);
5211  GWEN_Buffer_AppendString(tbuf, " *");
5212  }
5213  else {
5214  s=Typemaker2_Type_GetIdentifier(mty);
5215  GWEN_Buffer_AppendString(tbuf, s);
5216  GWEN_Buffer_AppendString(tbuf, " ");
5217  }
5218  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5219 
5220  GWEN_Buffer_AppendString(tbuf, " ");
5221  s=Typemaker2_Type_GetIdentifier(ty);
5222  GWEN_Buffer_AppendString(tbuf, s);
5223  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5224  GWEN_Buffer_AppendString(tbuf, "\n");
5225 
5226  GWEN_Buffer_AppendString(tbuf, " assert(p_list);\n");
5227  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5228  s=Typemaker2_Type_GetPrefix(ty);
5229  GWEN_Buffer_AppendString(tbuf, s);
5230  GWEN_Buffer_AppendString(tbuf, "_List_First(p_list);\n");
5231  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5232  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5233  GWEN_Buffer_AppendString(tbuf, "\n");
5234 
5235  GWEN_Buffer_AppendString(tbuf, " ");
5236  if (1) {
5237  GWEN_BUFFER *dstbuf;
5238  GWEN_BUFFER *srcbuf;
5239  int rv;
5240 
5241  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5242  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5243 
5244  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5245  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5246  s=Typemaker2_Member_GetName(tm);
5247  GWEN_Buffer_AppendString(dstbuf, s);
5248 
5249  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5250  GWEN_Buffer_GetStart(srcbuf),
5251  GWEN_Buffer_GetStart(dstbuf),
5252  tbuf);
5253  if (rv<0) {
5254  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5255  GWEN_Buffer_free(srcbuf);
5256  GWEN_Buffer_free(dstbuf);
5257  GWEN_Buffer_free(tbuf);
5258  return rv;
5259  }
5260  GWEN_Buffer_AppendString(tbuf, "\n");
5261  GWEN_Buffer_free(srcbuf);
5262  GWEN_Buffer_free(dstbuf);
5263  }
5264 
5265 
5266  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5267  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5268 
5269  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5270  s=Typemaker2_Type_GetPrefix(ty);
5271  GWEN_Buffer_AppendString(tbuf, s);
5272  GWEN_Buffer_AppendString(tbuf, "_List_Next(p_struct);\n");
5273 
5274  GWEN_Buffer_AppendString(tbuf, " }\n");
5275 
5276  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5277  GWEN_Buffer_AppendString(tbuf, "}\n");
5278 
5279  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5280  GWEN_Buffer_free(tbuf);
5281 
5282  return 0;
5283 }
5284 
5285 
5286 
5287 static int _buildTreeGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5288 {
5289  GWEN_BUFFER *tbuf;
5290  const char *s;
5291  /* uint32_t flags; */
5292  TYPEMAKER2_TYPEMANAGER *tym;
5293  TYPEMAKER2_TYPE *mty;
5294 
5295  tym=Typemaker2_Builder_GetTypeManager(tb);
5296  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5297 
5298  /* flags=Typemaker2_Type_GetFlags(ty); */
5299 
5300  mty=Typemaker2_Member_GetTypePtr(tm);
5301  assert(mty);
5302 
5303  /* prototype */
5304  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5305  if (s) {
5306  GWEN_Buffer_AppendString(tbuf, s);
5307  GWEN_Buffer_AppendString(tbuf, " ");
5308  }
5309 
5310  s=Typemaker2_Type_GetIdentifier(ty);
5311  GWEN_Buffer_AppendString(tbuf, s);
5312  GWEN_Buffer_AppendString(tbuf, " *");
5313 
5314  s=Typemaker2_Type_GetPrefix(ty);
5315  GWEN_Buffer_AppendString(tbuf, s);
5316  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5317  GWEN_Buffer_AppendString(tbuf, "By");
5318  s=Typemaker2_Member_GetName(tm);
5319  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5320  GWEN_Buffer_AppendString(tbuf, s+1);
5321  GWEN_Buffer_AppendString(tbuf, "(const ");
5322  s=Typemaker2_Type_GetIdentifier(ty);
5323  GWEN_Buffer_AppendString(tbuf, s);
5324  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5325  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5326  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5327  GWEN_Buffer_AppendString(tbuf, " const ");
5328  s=Typemaker2_Type_GetIdentifier(mty);
5329  GWEN_Buffer_AppendString(tbuf, s);
5330  GWEN_Buffer_AppendString(tbuf, " *");
5331  }
5332  else {
5333  s=Typemaker2_Type_GetIdentifier(mty);
5334  GWEN_Buffer_AppendString(tbuf, s);
5335  GWEN_Buffer_AppendString(tbuf, " ");
5336  }
5337  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5338 
5339  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5340  GWEN_Buffer_Reset(tbuf);
5341 
5342  /* implementation */
5343  s=Typemaker2_Type_GetIdentifier(ty);
5344  GWEN_Buffer_AppendString(tbuf, s);
5345  GWEN_Buffer_AppendString(tbuf, " *");
5346 
5347  s=Typemaker2_Type_GetPrefix(ty);
5348  GWEN_Buffer_AppendString(tbuf, s);
5349  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5350  GWEN_Buffer_AppendString(tbuf, "By");
5351  s=Typemaker2_Member_GetName(tm);
5352  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5353  GWEN_Buffer_AppendString(tbuf, s+1);
5354  GWEN_Buffer_AppendString(tbuf, "(const ");
5355  s=Typemaker2_Type_GetIdentifier(ty);
5356  GWEN_Buffer_AppendString(tbuf, s);
5357  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5358  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5359  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5360  GWEN_Buffer_AppendString(tbuf, " const ");
5361  s=Typemaker2_Type_GetIdentifier(mty);
5362  GWEN_Buffer_AppendString(tbuf, s);
5363  GWEN_Buffer_AppendString(tbuf, " *");
5364  }
5365  else {
5366  s=Typemaker2_Type_GetIdentifier(mty);
5367  GWEN_Buffer_AppendString(tbuf, s);
5368  GWEN_Buffer_AppendString(tbuf, " ");
5369  }
5370  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5371 
5372  GWEN_Buffer_AppendString(tbuf, " ");
5373  s=Typemaker2_Type_GetIdentifier(ty);
5374  GWEN_Buffer_AppendString(tbuf, s);
5375  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5376  GWEN_Buffer_AppendString(tbuf, "\n");
5377 
5378  GWEN_Buffer_AppendString(tbuf, " assert(p_tree);\n");
5379  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5380  s=Typemaker2_Type_GetPrefix(ty);
5381  GWEN_Buffer_AppendString(tbuf, s);
5382  GWEN_Buffer_AppendString(tbuf, "_Tree_GetFirst(p_tree);\n");
5383  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5384  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5385  GWEN_Buffer_AppendString(tbuf, "\n");
5386 
5387  GWEN_Buffer_AppendString(tbuf, " ");
5388  if (1) {
5389  GWEN_BUFFER *dstbuf;
5390  GWEN_BUFFER *srcbuf;
5391  int rv;
5392 
5393  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5394  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5395 
5396  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5397  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5398  s=Typemaker2_Member_GetName(tm);
5399  GWEN_Buffer_AppendString(dstbuf, s);
5400 
5401  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5402  GWEN_Buffer_GetStart(srcbuf),
5403  GWEN_Buffer_GetStart(dstbuf),
5404  tbuf);
5405  if (rv<0) {
5406  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5407  GWEN_Buffer_free(srcbuf);
5408  GWEN_Buffer_free(dstbuf);
5409  GWEN_Buffer_free(tbuf);
5410  return rv;
5411  }
5412  GWEN_Buffer_AppendString(tbuf, "\n");
5413  GWEN_Buffer_free(srcbuf);
5414  GWEN_Buffer_free(dstbuf);
5415  }
5416 
5417 
5418  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5419  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5420 
5421  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5422  s=Typemaker2_Type_GetPrefix(ty);
5423  GWEN_Buffer_AppendString(tbuf, s);
5424  GWEN_Buffer_AppendString(tbuf, "_Tree_GetBelow(p_struct);\n");
5425 
5426  GWEN_Buffer_AppendString(tbuf, " }\n");
5427 
5428  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5429  GWEN_Buffer_AppendString(tbuf, "}\n");
5430 
5431  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5432  GWEN_Buffer_free(tbuf);
5433 
5434  return 0;
5435 }
5436 
5437 
5438 
5439 static int _buildTree2GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5440 {
5441  GWEN_BUFFER *tbuf;
5442  const char *s;
5443  /* uint32_t flags; */
5444  TYPEMAKER2_TYPEMANAGER *tym;
5445  TYPEMAKER2_TYPE *mty;
5446 
5447  tym=Typemaker2_Builder_GetTypeManager(tb);
5448  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5449 
5450  /* flags=Typemaker2_Type_GetFlags(ty); */
5451 
5452  mty=Typemaker2_Member_GetTypePtr(tm);
5453  assert(mty);
5454 
5455  /* prototype */
5456  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5457  if (s) {
5458  GWEN_Buffer_AppendString(tbuf, s);
5459  GWEN_Buffer_AppendString(tbuf, " ");
5460  }
5461 
5462  s=Typemaker2_Type_GetIdentifier(ty);
5463  GWEN_Buffer_AppendString(tbuf, s);
5464  GWEN_Buffer_AppendString(tbuf, " *");
5465 
5466  s=Typemaker2_Type_GetPrefix(ty);
5467  GWEN_Buffer_AppendString(tbuf, s);
5468  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5469  GWEN_Buffer_AppendString(tbuf, "By");
5470  s=Typemaker2_Member_GetName(tm);
5471  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5472  GWEN_Buffer_AppendString(tbuf, s+1);
5473  GWEN_Buffer_AppendString(tbuf, "(const ");
5474  s=Typemaker2_Type_GetIdentifier(ty);
5475  GWEN_Buffer_AppendString(tbuf, s);
5476  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5477  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5478  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5479  GWEN_Buffer_AppendString(tbuf, " const ");
5480  s=Typemaker2_Type_GetIdentifier(mty);
5481  GWEN_Buffer_AppendString(tbuf, s);
5482  GWEN_Buffer_AppendString(tbuf, " *");
5483  }
5484  else {
5485  s=Typemaker2_Type_GetIdentifier(mty);
5486  GWEN_Buffer_AppendString(tbuf, s);
5487  GWEN_Buffer_AppendString(tbuf, " ");
5488  }
5489  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5490 
5491  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5492  GWEN_Buffer_Reset(tbuf);
5493 
5494  /* implementation */
5495  s=Typemaker2_Type_GetIdentifier(ty);
5496  GWEN_Buffer_AppendString(tbuf, s);
5497  GWEN_Buffer_AppendString(tbuf, " *");
5498 
5499  s=Typemaker2_Type_GetPrefix(ty);
5500  GWEN_Buffer_AppendString(tbuf, s);
5501  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5502  GWEN_Buffer_AppendString(tbuf, "By");
5503  s=Typemaker2_Member_GetName(tm);
5504  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5505  GWEN_Buffer_AppendString(tbuf, s+1);
5506  GWEN_Buffer_AppendString(tbuf, "(const ");
5507  s=Typemaker2_Type_GetIdentifier(ty);
5508  GWEN_Buffer_AppendString(tbuf, s);
5509  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5510  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5511  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5512  GWEN_Buffer_AppendString(tbuf, " const ");
5513  s=Typemaker2_Type_GetIdentifier(mty);
5514  GWEN_Buffer_AppendString(tbuf, s);
5515  GWEN_Buffer_AppendString(tbuf, " *");
5516  }
5517  else {
5518  s=Typemaker2_Type_GetIdentifier(mty);
5519  GWEN_Buffer_AppendString(tbuf, s);
5520  GWEN_Buffer_AppendString(tbuf, " ");
5521  }
5522  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5523 
5524  GWEN_Buffer_AppendString(tbuf, " ");
5525  s=Typemaker2_Type_GetIdentifier(ty);
5526  GWEN_Buffer_AppendString(tbuf, s);
5527  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5528  GWEN_Buffer_AppendString(tbuf, "\n");
5529 
5530  GWEN_Buffer_AppendString(tbuf, " assert(p_object);\n");
5531  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5532  s=Typemaker2_Type_GetPrefix(ty);
5533  GWEN_Buffer_AppendString(tbuf, s);
5534  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetFirstChild(p_object);\n");
5535  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5536  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5537  GWEN_Buffer_AppendString(tbuf, "\n");
5538 
5539  GWEN_Buffer_AppendString(tbuf, " ");
5540  if (1) {
5541  GWEN_BUFFER *dstbuf;
5542  GWEN_BUFFER *srcbuf;
5543  int rv;
5544 
5545  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5546  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5547 
5548  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5549  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5550  s=Typemaker2_Member_GetName(tm);
5551  GWEN_Buffer_AppendString(dstbuf, s);
5552 
5553  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5554  GWEN_Buffer_GetStart(srcbuf),
5555  GWEN_Buffer_GetStart(dstbuf),
5556  tbuf);
5557  if (rv<0) {
5558  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5559  GWEN_Buffer_free(srcbuf);
5560  GWEN_Buffer_free(dstbuf);
5561  GWEN_Buffer_free(tbuf);
5562  return rv;
5563  }
5564  GWEN_Buffer_AppendString(tbuf, "\n");
5565  GWEN_Buffer_free(srcbuf);
5566  GWEN_Buffer_free(dstbuf);
5567  }
5568 
5569 
5570  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5571  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5572 
5573  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5574  s=Typemaker2_Type_GetPrefix(ty);
5575  GWEN_Buffer_AppendString(tbuf, s);
5576  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetBelow(p_struct);\n");
5577 
5578  GWEN_Buffer_AppendString(tbuf, " }\n");
5579 
5580  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5581  GWEN_Buffer_AppendString(tbuf, "}\n");
5582 
5583  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5584  GWEN_Buffer_free(tbuf);
5585 
5586  return 0;
5587 }
5588 
5589 
5590 
5591 static int _buildGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5592 {
5593  GWEN_BUFFER *tbuf;
5594  TYPEMAKER2_MEMBER_LIST *tml;
5595  uint32_t flags;
5596  /* TYPEMAKER2_TYPEMANAGER *tym; */
5597 
5598  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5599  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5600 
5601  flags=Typemaker2_Type_GetFlags(ty);
5602 
5603  tml=Typemaker2_Type_GetMembers(ty);
5604  if (tml) {
5605  TYPEMAKER2_MEMBER *tm;
5606 
5607  tm=Typemaker2_Member_List_First(tml);
5608  while (tm) {
5609  TYPEMAKER2_TYPE *mty;
5610  int rv;
5611 
5612  mty=Typemaker2_Member_GetTypePtr(tm);
5613  assert(mty);
5614 
5615  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_GETBYMEMBER) {
5616  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
5617  rv=_buildList1GetByMember(tb, ty, tm);
5618  if (rv<0) {
5619  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5620  return rv;
5621  }
5622  }
5623 
5624  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
5625  rv=_buildTreeGetByMember(tb, ty, tm);
5626  if (rv<0) {
5627  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5628  return rv;
5629  }
5630  }
5631 
5632  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
5633  rv=_buildTree2GetByMember(tb, ty, tm);
5634  if (rv<0) {
5635  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5636  return rv;
5637  }
5638  }
5639 
5640  }
5641  tm=Typemaker2_Member_List_Next(tm);
5642  }
5643  GWEN_Buffer_AppendString(tbuf, " return p_cl;\n");
5644  }
5645 
5646  return 0;
5647 }
5648 
5649 
5650 
5651 static int _buildList1SortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5652 {
5653  GWEN_BUFFER *tbuf;
5654  const char *s;
5655  /* uint32_t flags; */
5656  TYPEMAKER2_TYPEMANAGER *tym;
5657  TYPEMAKER2_TYPE *mty;
5658 
5659  tym=Typemaker2_Builder_GetTypeManager(tb);
5660  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5661 
5662  /* flags=Typemaker2_Type_GetFlags(ty); */
5663 
5664  mty=Typemaker2_Member_GetTypePtr(tm);
5665  assert(mty);
5666 
5667  /* ==== prototypes ========================================================*/
5668  /* ---- _List_SortByMember ----------------------------------------------- */
5669  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5670  if (s) {
5671  GWEN_Buffer_AppendString(tbuf, s);
5672  GWEN_Buffer_AppendString(tbuf, " ");
5673  }
5674 
5675  /* return type */
5676  GWEN_Buffer_AppendString(tbuf, "void ");
5677 
5678  /* function name */
5679  s=Typemaker2_Type_GetPrefix(ty);
5680  GWEN_Buffer_AppendString(tbuf, s);
5681  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5682  s=Typemaker2_Member_GetName(tm);
5683  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5684  GWEN_Buffer_AppendString(tbuf, s+1);
5685 
5686  /* argument list */
5687  GWEN_Buffer_AppendString(tbuf, "(");
5688  s=Typemaker2_Type_GetIdentifier(ty);
5689  GWEN_Buffer_AppendString(tbuf, s);
5690  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending);\n");
5691 
5692  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5693  GWEN_Buffer_Reset(tbuf);
5694 
5695 
5696  /* ---- _List_Compare_Member --------------------------------------------- */
5697  /* return type */
5698  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5699 
5700  /* function name */
5701  s=Typemaker2_Type_GetPrefix(ty);
5702  GWEN_Buffer_AppendString(tbuf, s);
5703  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5704  s=Typemaker2_Member_GetName(tm);
5705  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5706  GWEN_Buffer_AppendString(tbuf, s+1);
5707 
5708  /* argument list */
5709  GWEN_Buffer_AppendString(tbuf, "(const ");
5710  s=Typemaker2_Type_GetIdentifier(ty);
5711  GWEN_Buffer_AppendString(tbuf, s);
5712  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5713  GWEN_Buffer_AppendString(tbuf, "const ");
5714  GWEN_Buffer_AppendString(tbuf, s);
5715  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5716  GWEN_Buffer_AppendString(tbuf, "int p_ascending);\n");
5717 
5718  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5719  GWEN_Buffer_Reset(tbuf);
5720 
5721 
5722  /* ==== implementations =================================================== */
5723  /* ---- _List_SortByMember ----------------------------------------------- */
5724  /* return type */
5725  GWEN_Buffer_AppendString(tbuf, "void ");
5726 
5727  /* function name */
5728  s=Typemaker2_Type_GetPrefix(ty);
5729  GWEN_Buffer_AppendString(tbuf, s);
5730  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5731  s=Typemaker2_Member_GetName(tm);
5732  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5733  GWEN_Buffer_AppendString(tbuf, s+1);
5734 
5735  /* argument list */
5736  GWEN_Buffer_AppendString(tbuf, "(");
5737  s=Typemaker2_Type_GetIdentifier(ty);
5738  GWEN_Buffer_AppendString(tbuf, s);
5739  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending) {\n");
5740 
5741 
5742  GWEN_Buffer_AppendString(tbuf, " ");
5743 
5744  s=Typemaker2_Type_GetIdentifier(ty);
5745  GWEN_Buffer_AppendString(tbuf, s);
5746  GWEN_Buffer_AppendString(tbuf, "_LIST_SORT_FN oldSortFn;\n");
5747 
5748  GWEN_Buffer_AppendString(tbuf, "\n");
5749  GWEN_Buffer_AppendString(tbuf, " oldSortFn=");
5750  s=Typemaker2_Type_GetPrefix(ty);
5751  GWEN_Buffer_AppendString(tbuf, s);
5752  GWEN_Buffer_AppendString(tbuf, "_List_SetSortFn(p_list, ");
5753 
5754  s=Typemaker2_Type_GetPrefix(ty);
5755  GWEN_Buffer_AppendString(tbuf, s);
5756  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5757  s=Typemaker2_Member_GetName(tm);
5758  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5759  GWEN_Buffer_AppendString(tbuf, s+1);
5760  GWEN_Buffer_AppendString(tbuf, ");\n");
5761 
5762  GWEN_Buffer_AppendString(tbuf, " ");
5763  s=Typemaker2_Type_GetPrefix(ty);
5764  GWEN_Buffer_AppendString(tbuf, s);
5765  GWEN_Buffer_AppendString(tbuf, "_List_Sort(p_list, p_ascending);\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_SetSortFn(p_list, oldSortFn);\n");
5771 
5772  GWEN_Buffer_AppendString(tbuf, "}\n");
5773 
5774  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5775  GWEN_Buffer_Reset(tbuf);
5776 
5777 
5778  /* ---- _List_Compare_Member --------------------------------------------- */
5779  /* return type */
5780  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5781 
5782  /* function name */
5783  s=Typemaker2_Type_GetPrefix(ty);
5784  GWEN_Buffer_AppendString(tbuf, s);
5785  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5786  s=Typemaker2_Member_GetName(tm);
5787  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5788  GWEN_Buffer_AppendString(tbuf, s+1);
5789 
5790  /* argument list */
5791  GWEN_Buffer_AppendString(tbuf, "(const ");
5792  s=Typemaker2_Type_GetIdentifier(ty);
5793  GWEN_Buffer_AppendString(tbuf, s);
5794  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5795  GWEN_Buffer_AppendString(tbuf, "const ");
5796  GWEN_Buffer_AppendString(tbuf, s);
5797  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5798  GWEN_Buffer_AppendString(tbuf, "int p_ascending) {\n");
5799 
5800  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5801  GWEN_Buffer_AppendString(tbuf, "\n");
5802 
5803  if (1) {
5804  GWEN_BUFFER *dstbuf;
5805  GWEN_BUFFER *srcbuf;
5806  int rv;
5807 
5808  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5809  GWEN_Buffer_AppendString(srcbuf, "p_a->");
5810  s=Typemaker2_Member_GetName(tm);
5811  GWEN_Buffer_AppendString(srcbuf, s);
5812 
5813 
5814  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5815  GWEN_Buffer_AppendString(dstbuf, "p_b->");
5816  s=Typemaker2_Member_GetName(tm);
5817  GWEN_Buffer_AppendString(dstbuf, s);
5818 
5819  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5820  GWEN_Buffer_GetStart(srcbuf),
5821  GWEN_Buffer_GetStart(dstbuf),
5822  tbuf);
5823  if (rv<0) {
5824  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5825  GWEN_Buffer_free(srcbuf);
5826  GWEN_Buffer_free(dstbuf);
5827  GWEN_Buffer_free(tbuf);
5828  return rv;
5829  }
5830  GWEN_Buffer_AppendString(tbuf, "\n");
5831  GWEN_Buffer_free(srcbuf);
5832  GWEN_Buffer_free(dstbuf);
5833  }
5834 
5835  GWEN_Buffer_AppendString(tbuf, " if (p_ascending)\n");
5836  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
5837  GWEN_Buffer_AppendString(tbuf, " else\n");
5838  GWEN_Buffer_AppendString(tbuf, " return -p_rv;\n");
5839  GWEN_Buffer_AppendString(tbuf, "}\n");
5840 
5841  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5842  GWEN_Buffer_free(tbuf);
5843 
5844  return 0;
5845 }
5846 
5847 
5848 
5849 static int _buildSortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5850 {
5851  TYPEMAKER2_MEMBER_LIST *tml;
5852  uint32_t flags;
5853  /* TYPEMAKER2_TYPEMANAGER *tym; */
5854 
5855  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5856 
5857  flags=Typemaker2_Type_GetFlags(ty);
5858 
5859  tml=Typemaker2_Type_GetMembers(ty);
5860  if (tml) {
5861  TYPEMAKER2_MEMBER *tm;
5862 
5863  tm=Typemaker2_Member_List_First(tml);
5864  while (tm) {
5865  TYPEMAKER2_TYPE *mty;
5866  int rv;
5867 
5868  mty=Typemaker2_Member_GetTypePtr(tm);
5869  assert(mty);
5870 
5871  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_SORTBYMEMBER) {
5872  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
5873  rv=_buildList1SortByMember(tb, ty, tm);
5874  if (rv<0) {
5875  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5876  return rv;
5877  }
5878  }
5879  }
5880  tm=Typemaker2_Member_List_Next(tm);
5881  }
5882  }
5883 
5884  return 0;
5885 }
5886 
5887 
5888 
5889 static int _buildDefineDefines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5890 {
5891  TYPEMAKER2_DEFINE_LIST *defines;
5892  /* TYPEMAKER2_TYPEMANAGER *tym; */
5893  /* uint32_t flags; */
5894 
5895  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5896  defines=Typemaker2_Type_GetDefines(ty);
5897  /* flags=Typemaker2_Type_GetFlags(ty); */
5898 
5899  assert(defines);
5900  if (Typemaker2_Define_List_GetCount(defines)) {
5901  GWEN_BUFFER *tbuf;
5902  const char *s;
5903  TYPEMAKER2_DEFINE *td;
5904 
5905  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5906 
5907  td=Typemaker2_Define_List_First(defines);
5908  while (td) {
5909  const char *prefix;
5910  TYPEMAKER2_ITEM *ti;
5911  int access=TypeMaker2_Access_Public;
5912  int j=Typemaker2_Define_GetStartValue(td);
5913 
5914  GWEN_Buffer_AppendString(tbuf, "/* define ");
5915  s=Typemaker2_Define_GetId(td);
5916  if (s && *s)
5917  GWEN_Buffer_AppendString(tbuf, s);
5918  GWEN_Buffer_AppendString(tbuf, " */\n");
5919 
5920  prefix=Typemaker2_Define_GetPrefix(td);
5921  if (prefix==NULL || *prefix==0) {
5922  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in define definition");
5923  GWEN_Buffer_free(tbuf);
5924  return GWEN_ERROR_BAD_DATA;
5925  }
5926 
5927  ti=Typemaker2_Item_List_First(Typemaker2_Define_GetItems(td));
5928  while (ti) {
5929  GWEN_Buffer_AppendString(tbuf, "#define ");
5930  if (prefix)
5931  GWEN_Buffer_AppendString(tbuf, prefix);
5932  s=Typemaker2_Item_GetName(ti);
5933  if (s && *s) {
5934  GWEN_Buffer_AppendString(tbuf, s);
5935  }
5936  s=Typemaker2_Item_GetValue(ti);
5937  if (s) {
5938  GWEN_Buffer_AppendString(tbuf, " ");
5939  GWEN_Buffer_AppendString(tbuf, s);
5940  }
5941  else {
5942  char numbuf[32];
5943  int k=0;
5944 
5945  switch (Typemaker2_Define_GetMode(td)) {
5946  case Typemaker2_Define_Mode_BitField:
5947  k=1<<j;
5948  break;
5949  case Typemaker2_Define_Mode_Sequence:
5950  default:
5951  k=j;
5952  }
5953  snprintf(numbuf, sizeof(numbuf)-1, "%d", k);
5954  numbuf[sizeof(numbuf)-1]=0;
5955  GWEN_Buffer_AppendString(tbuf, " ");
5956  GWEN_Buffer_AppendString(tbuf, numbuf);
5957  j++;
5958  }
5959 
5960  GWEN_Buffer_AppendString(tbuf, "\n");
5961  ti=Typemaker2_Item_List_Next(ti);
5962  }
5963  GWEN_Buffer_AppendString(tbuf, "\n");
5964 
5965  switch (access) {
5966  case TypeMaker2_Access_Public:
5967  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5968  break;
5969  case TypeMaker2_Access_Library:
5970  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5971  break;
5972  case TypeMaker2_Access_Protected:
5973  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5974  break;
5975  case TypeMaker2_Access_Private:
5976  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5977  break;
5978  default:
5979  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5980  GWEN_Buffer_free(tbuf);
5981  return GWEN_ERROR_BAD_DATA;
5982  }
5983  GWEN_Buffer_Reset(tbuf);
5984 
5985  td=Typemaker2_Define_List_Next(td);
5986  }
5987  }
5988  return 0;
5989 }
5990 
5991 
5992 
5993 static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5994 {
5995  GWEN_BUFFER *tbuf;
5996  const char *s;
5997  /* uint32_t flags; */
5998  TYPEMAKER2_TYPEMANAGER *tym;
5999  TYPEMAKER2_MEMBER_LIST *tml;
6000 
6001  tym=Typemaker2_Builder_GetTypeManager(tb);
6002  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6003 
6004  /* flags=Typemaker2_Type_GetFlags(ty); */
6005 
6006  /* prototype */
6007  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6008  if (s) {
6009  GWEN_Buffer_AppendString(tbuf, s);
6010  GWEN_Buffer_AppendString(tbuf, " ");
6011  }
6012 
6013  GWEN_Buffer_AppendString(tbuf, "void ");
6014  s=Typemaker2_Type_GetPrefix(ty);
6015  GWEN_Buffer_AppendString(tbuf, s);
6016  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6017  GWEN_Buffer_AppendString(tbuf, "(const ");
6018  s=Typemaker2_Type_GetIdentifier(ty);
6019  GWEN_Buffer_AppendString(tbuf, s);
6020  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer);\n");
6021 
6022  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6023  GWEN_Buffer_Reset(tbuf);
6024 
6025  /* implementation */
6026  GWEN_Buffer_AppendString(tbuf, "void ");
6027  s=Typemaker2_Type_GetPrefix(ty);
6028  GWEN_Buffer_AppendString(tbuf, s);
6029  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6030  GWEN_Buffer_AppendString(tbuf, "(const ");
6031  s=Typemaker2_Type_GetIdentifier(ty);
6032  GWEN_Buffer_AppendString(tbuf, s);
6033  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer) {\n");
6034 
6035  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6036 
6037 
6038  tml=Typemaker2_Type_GetMembers(ty);
6039  if (tml) {
6040  TYPEMAKER2_MEMBER *tm;
6041 
6042  tm=Typemaker2_Member_List_First(tml);
6043  while (tm) {
6044  TYPEMAKER2_TYPE *mty;
6045 
6046  mty=Typemaker2_Member_GetTypePtr(tm);
6047  assert(mty);
6048 
6049  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_HASH) {
6050  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6051  s=Typemaker2_Member_GetName(tm);
6052  GWEN_Buffer_AppendString(tbuf, s);
6053  GWEN_Buffer_AppendString(tbuf, "\" */\n");
6054 
6055  /* toHashString */
6056  if (1) {
6057  GWEN_BUFFER *srcbuf;
6058  int rv;
6059 
6060  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
6061  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
6062  s=Typemaker2_Member_GetName(tm);
6063  GWEN_Buffer_AppendString(srcbuf, s);
6064 
6065  GWEN_Buffer_AppendString(tbuf, " ");
6066  rv=Typemaker2_Builder_Invoke_ToHashStringFn(tb, ty, tm,
6067  GWEN_Buffer_GetStart(srcbuf),
6068  NULL, /* no dest */
6069  tbuf);
6070  if (rv<0) {
6071  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6072  GWEN_Buffer_free(srcbuf);
6073  GWEN_Buffer_free(tbuf);
6074  return rv;
6075  }
6076  GWEN_Buffer_AppendString(tbuf, "\n");
6077  GWEN_Buffer_free(srcbuf);
6078  }
6079 
6080  GWEN_Buffer_AppendString(tbuf, " GWEN_Buffer_AppendByte(p_buffer, \':\');\n");
6081  }
6082  else {
6083  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6084  s=Typemaker2_Member_GetName(tm);
6085  GWEN_Buffer_AppendString(tbuf, s);
6086  GWEN_Buffer_AppendString(tbuf, "\" does not have the with_hash flag, ignoring */\n");
6087  }
6088 
6089  tm=Typemaker2_Member_List_Next(tm);
6090  }
6091  }
6092 
6093 
6094  GWEN_Buffer_AppendString(tbuf, "}\n");
6095 
6096  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6097  GWEN_Buffer_free(tbuf);
6098 
6099  return 0;
6100 }
6101 
6102 
6103 
6104 static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6105 {
6106  GWEN_BUFFER *tbuf;
6107  uint32_t flags;
6108  /* TYPEMAKER2_TYPEMANAGER *tym; */
6109 
6110  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6111  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6112 
6113  flags=Typemaker2_Type_GetFlags(ty);
6114 
6115  while (ty) {
6116  TYPEMAKER2_INLINE *ti;
6117 
6118  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(ty));
6119  while (ti) {
6120  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6121  const char *content;
6122 
6123  content=Typemaker2_Inline_GetContent(ti);
6124  if (content && *content) {
6125  GWEN_DB_NODE *db;
6126  int rv;
6127 
6128  db=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
6129  assert(db);
6130  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6131  if (rv<0) {
6132  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6133  GWEN_Buffer_free(tbuf);
6134  return rv;
6135  }
6136 
6137  /* include code */
6138  switch (Typemaker2_Inline_GetLocation(ti)) {
6139  case Typemaker2_InlineLocation_Header:
6140  switch (Typemaker2_Inline_GetAccess(ti)) {
6141  case TypeMaker2_Access_Public:
6142  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6143  break;
6144  case TypeMaker2_Access_Library:
6145  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6146  break;
6147  case TypeMaker2_Access_Protected:
6148  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6149  break;
6150  case TypeMaker2_Access_Private:
6151  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6152  break;
6153  default:
6154  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6155  GWEN_Buffer_free(tbuf);
6156  return GWEN_ERROR_BAD_DATA;
6157  }
6158  break;
6159 
6160  case Typemaker2_InlineLocation_Code:
6161  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6162  break;
6163  }
6164  }
6165  GWEN_Buffer_Reset(tbuf);
6166  }
6167 
6168  ti=Typemaker2_Inline_List_Next(ti);
6169  }
6170  ty=Typemaker2_Type_GetExtendsPtr(ty);
6171  }
6172 
6173  return 0;
6174 }
6175 
6176 
6177 
6178 static int _buildMemberInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6179 {
6180  GWEN_BUFFER *tbuf;
6181  uint32_t flags;
6182  /* TYPEMAKER2_TYPEMANAGER *tym; */
6183 
6184  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6185  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6186 
6187  flags=Typemaker2_Type_GetFlags(ty);
6188 
6189  while (ty) {
6190  TYPEMAKER2_MEMBER_LIST *tml;
6191 
6192  tml=Typemaker2_Type_GetMembers(ty);
6193  if (tml) {
6194  TYPEMAKER2_MEMBER *tm;
6195 
6196  tm=Typemaker2_Member_List_First(tml);
6197  while (tm) {
6198  TYPEMAKER2_TYPE *mty;
6199 
6200  mty=Typemaker2_Member_GetTypePtr(tm);
6201  if (mty) {
6202  TYPEMAKER2_INLINE *ti;
6203 
6204  /* get inlines from member type */
6205  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(mty));
6206  while (ti) {
6207  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6208  const char *content;
6209 
6210  content=Typemaker2_Inline_GetContent(ti);
6211  if (content && *content) {
6212  GWEN_DB_NODE *db;
6213  int rv;
6214 
6215  /* replace vars in context of the struct type, not the particular member type */
6216  db=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
6217  assert(db);
6218  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6219  if (rv<0) {
6220  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6221  GWEN_Buffer_free(tbuf);
6222  return rv;
6223  }
6224 
6225  /* include code */
6226  switch (Typemaker2_Inline_GetLocation(ti)) {
6227  case Typemaker2_InlineLocation_Header:
6228  switch (Typemaker2_Inline_GetAccess(ti)) {
6229  case TypeMaker2_Access_Public:
6230  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6231  break;
6232  case TypeMaker2_Access_Library:
6233  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6234  break;
6235  case TypeMaker2_Access_Protected:
6236  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6237  break;
6238  case TypeMaker2_Access_Private:
6239  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6240  break;
6241  default:
6242  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6243  GWEN_Buffer_free(tbuf);
6244  return GWEN_ERROR_BAD_DATA;
6245  }
6246  break;
6247 
6248  case Typemaker2_InlineLocation_Code:
6249  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6250  break;
6251  }
6252  }
6253  GWEN_Buffer_Reset(tbuf);
6254  }
6255 
6256  ti=Typemaker2_Inline_List_Next(ti);
6257  }
6258  } /* if mty */
6259 
6260  tm=Typemaker2_Member_List_Next(tm);
6261  } /* while tm */
6262  } /* if tml */
6263 
6264  ty=Typemaker2_Type_GetExtendsPtr(ty);
6265  }
6266 
6267  return 0;
6268 }
6269 
6270 
6271 
6272 static int _buildAttach(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6273 {
6274  GWEN_BUFFER *tbuf;
6275  const char *s;
6276  /* uint32_t flags; */
6277  TYPEMAKER2_TYPEMANAGER *tym;
6278 
6279  tym=Typemaker2_Builder_GetTypeManager(tb);
6280  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6281 
6282  /* flags=Typemaker2_Type_GetFlags(ty); */
6283 
6284  /* prototype */
6285  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6286  if (s) {
6287  GWEN_Buffer_AppendString(tbuf, s);
6288  GWEN_Buffer_AppendString(tbuf, " ");
6289  }
6290  GWEN_Buffer_AppendString(tbuf, "void ");
6291  s=Typemaker2_Type_GetPrefix(ty);
6292  GWEN_Buffer_AppendString(tbuf, s);
6293  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6294  s=Typemaker2_Type_GetIdentifier(ty);
6295  GWEN_Buffer_AppendString(tbuf, s);
6296  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6297 
6298  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6299  GWEN_Buffer_Reset(tbuf);
6300 
6301  /* implementation */
6302  GWEN_Buffer_AppendString(tbuf, "void ");
6303  s=Typemaker2_Type_GetPrefix(ty);
6304  GWEN_Buffer_AppendString(tbuf, s);
6305  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6306  s=Typemaker2_Type_GetIdentifier(ty);
6307  GWEN_Buffer_AppendString(tbuf, s);
6308  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6309 
6310  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6311  GWEN_Buffer_AppendString(tbuf, " assert(p_struct->_refCount);\n");
6312  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount++;\n");
6313  GWEN_Buffer_AppendString(tbuf, "}\n");
6314 
6315  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6316  GWEN_Buffer_free(tbuf);
6317 
6318  return 0;
6319 }
6320 
6321 
6322 
6323 static int _buildSignalFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6324 {
6325  GWEN_BUFFER *tbuf;
6326  const char *s;
6327  /* uint32_t flags; */
6328  TYPEMAKER2_TYPEMANAGER *tym;
6329  TYPEMAKER2_SIGNAL_LIST *sigList;
6330 
6331  tym=Typemaker2_Builder_GetTypeManager(tb);
6332  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6333 
6334  /* flags=Typemaker2_Type_GetFlags(ty); */
6335 
6336  sigList=Typemaker2_Type_GetSignals(ty);
6337  if (sigList) {
6338  TYPEMAKER2_SIGNAL *sig;
6339 
6340  /* prototype */
6341  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6342  sig=Typemaker2_Signal_List_First(sigList);
6343  while (sig) {
6344 
6345  /* SignalConnect */
6346  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6347  if (s) {
6348  GWEN_Buffer_AppendString(tbuf, s);
6349  GWEN_Buffer_AppendString(tbuf, " ");
6350  }
6351  GWEN_Buffer_AppendString(tbuf, "int ");
6352  s=Typemaker2_Type_GetPrefix(ty);
6353  GWEN_Buffer_AppendString(tbuf, s);
6354  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6355  s=Typemaker2_Signal_GetName(sig);
6356  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6357  GWEN_Buffer_AppendString(tbuf, s+1);
6358  GWEN_Buffer_AppendString(tbuf, "(");
6359  s=Typemaker2_Type_GetIdentifier(ty);
6360  GWEN_Buffer_AppendString(tbuf, s);
6361  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6362 
6363  /* SignalDisconnect */
6364  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6365  if (s) {
6366  GWEN_Buffer_AppendString(tbuf, s);
6367  GWEN_Buffer_AppendString(tbuf, " ");
6368  }
6369  GWEN_Buffer_AppendString(tbuf, "int ");
6370  s=Typemaker2_Type_GetPrefix(ty);
6371  GWEN_Buffer_AppendString(tbuf, s);
6372  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6373  s=Typemaker2_Signal_GetName(sig);
6374  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6375  GWEN_Buffer_AppendString(tbuf, s+1);
6376  GWEN_Buffer_AppendString(tbuf, "(");
6377  s=Typemaker2_Type_GetIdentifier(ty);
6378  GWEN_Buffer_AppendString(tbuf, s);
6379  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6380 
6381  /* GetSignal */
6382  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6383  if (s) {
6384  GWEN_Buffer_AppendString(tbuf, s);
6385  GWEN_Buffer_AppendString(tbuf, " ");
6386  }
6387  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6388  s=Typemaker2_Type_GetPrefix(ty);
6389  GWEN_Buffer_AppendString(tbuf, s);
6390  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6391  s=Typemaker2_Signal_GetName(sig);
6392  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6393  GWEN_Buffer_AppendString(tbuf, s+1);
6394  GWEN_Buffer_AppendString(tbuf, "(const ");
6395  s=Typemaker2_Type_GetIdentifier(ty);
6396  GWEN_Buffer_AppendString(tbuf, s);
6397  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6398 
6399 
6400  /* EmitSignal */
6401  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6402  if (s) {
6403  GWEN_Buffer_AppendString(tbuf, s);
6404  GWEN_Buffer_AppendString(tbuf, " ");
6405  }
6406  GWEN_Buffer_AppendString(tbuf, "int ");
6407  s=Typemaker2_Type_GetPrefix(ty);
6408  GWEN_Buffer_AppendString(tbuf, s);
6409  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6410  s=Typemaker2_Signal_GetName(sig);
6411  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6412  GWEN_Buffer_AppendString(tbuf, s+1);
6413  GWEN_Buffer_AppendString(tbuf, "(");
6414  s=Typemaker2_Type_GetIdentifier(ty);
6415  GWEN_Buffer_AppendString(tbuf, s);
6416  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6417  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6418  if (s && *s && strcasecmp(s, "none")) {
6419  GWEN_Buffer_AppendString(tbuf, ", ");
6420  GWEN_Buffer_AppendString(tbuf, s);
6421  GWEN_Buffer_AppendString(tbuf, " param1");
6422  }
6423  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6424  if (s && *s && strcasecmp(s, "none")) {
6425  GWEN_Buffer_AppendString(tbuf, ", ");
6426  GWEN_Buffer_AppendString(tbuf, s);
6427  GWEN_Buffer_AppendString(tbuf, " param2");
6428  }
6429  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6430  GWEN_Buffer_AppendString(tbuf, ", int param3");
6431  }
6432  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6433  GWEN_Buffer_AppendString(tbuf, ", int param4");
6434  }
6435  GWEN_Buffer_AppendString(tbuf, ");\n");
6436 
6437 
6438  sig=Typemaker2_Signal_List_Next(sig);
6439  }
6440  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6441  GWEN_Buffer_Reset(tbuf);
6442 
6443  /* implementation */
6444  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6445  sig=Typemaker2_Signal_List_First(sigList);
6446  while (sig) {
6447 
6448  /* SignalConnect */
6449  GWEN_Buffer_AppendString(tbuf, "int ");
6450  s=Typemaker2_Type_GetPrefix(ty);
6451  GWEN_Buffer_AppendString(tbuf, s);
6452  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6453  s=Typemaker2_Signal_GetName(sig);
6454  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6455  GWEN_Buffer_AppendString(tbuf, s+1);
6456  GWEN_Buffer_AppendString(tbuf, "(");
6457  s=Typemaker2_Type_GetIdentifier(ty);
6458  GWEN_Buffer_AppendString(tbuf, s);
6459  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6460 
6461  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6462  GWEN_Buffer_AppendString(tbuf, "\n");
6463  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6464  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6465  s=Typemaker2_Signal_GetName(sig); /* name */
6466  GWEN_Buffer_AppendString(tbuf, "\"");
6467  GWEN_Buffer_AppendString(tbuf, s);
6468  GWEN_Buffer_AppendString(tbuf, "\", ");
6469  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6470  GWEN_Buffer_AppendString(tbuf, "\"");
6471  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6472  GWEN_Buffer_AppendString(tbuf, "\", ");
6473  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6474  GWEN_Buffer_AppendString(tbuf, "\"");
6475  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6476  GWEN_Buffer_AppendString(tbuf, "\");\n");
6477  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6478  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Connect(sig, slot);\n");
6479  GWEN_Buffer_AppendString(tbuf, " else\n");
6480  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6481 
6482  GWEN_Buffer_AppendString(tbuf, "}\n");
6483  GWEN_Buffer_AppendString(tbuf, "\n");
6484 
6485  /* SignalDisconnect */
6486  GWEN_Buffer_AppendString(tbuf, "int ");
6487  s=Typemaker2_Type_GetPrefix(ty);
6488  GWEN_Buffer_AppendString(tbuf, s);
6489  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6490  s=Typemaker2_Signal_GetName(sig);
6491  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6492  GWEN_Buffer_AppendString(tbuf, s+1);
6493  GWEN_Buffer_AppendString(tbuf, "(");
6494  s=Typemaker2_Type_GetIdentifier(ty);
6495  GWEN_Buffer_AppendString(tbuf, s);
6496  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6497 
6498  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6499  GWEN_Buffer_AppendString(tbuf, "\n");
6500  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6501  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6502  s=Typemaker2_Signal_GetName(sig); /* name */
6503  GWEN_Buffer_AppendString(tbuf, "\"");
6504  GWEN_Buffer_AppendString(tbuf, s);
6505  GWEN_Buffer_AppendString(tbuf, "\", ");
6506  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6507  GWEN_Buffer_AppendString(tbuf, "\"");
6508  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6509  GWEN_Buffer_AppendString(tbuf, "\", ");
6510  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6511  GWEN_Buffer_AppendString(tbuf, "\"");
6512  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6513  GWEN_Buffer_AppendString(tbuf, "\");\n");
6514  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6515  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Disconnect(sig, slot);\n");
6516  GWEN_Buffer_AppendString(tbuf, " else\n");
6517  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6518 
6519  GWEN_Buffer_AppendString(tbuf, "}\n");
6520  GWEN_Buffer_AppendString(tbuf, "\n");
6521 
6522 
6523  /* GetSignal */
6524  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6525  s=Typemaker2_Type_GetPrefix(ty);
6526  GWEN_Buffer_AppendString(tbuf, s);
6527  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6528  s=Typemaker2_Signal_GetName(sig);
6529  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6530  GWEN_Buffer_AppendString(tbuf, s+1);
6531  GWEN_Buffer_AppendString(tbuf, "(const ");
6532  s=Typemaker2_Type_GetIdentifier(ty);
6533  GWEN_Buffer_AppendString(tbuf, s);
6534  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6535 
6536  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6537  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6538  s=Typemaker2_Signal_GetName(sig); /* name */
6539  GWEN_Buffer_AppendString(tbuf, "\"");
6540  GWEN_Buffer_AppendString(tbuf, s);
6541  GWEN_Buffer_AppendString(tbuf, "\", ");
6542  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6543  GWEN_Buffer_AppendString(tbuf, "\"");
6544  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6545  GWEN_Buffer_AppendString(tbuf, "\", ");
6546  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6547  GWEN_Buffer_AppendString(tbuf, "\"");
6548  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6549  GWEN_Buffer_AppendString(tbuf, "\");\n");
6550 
6551  GWEN_Buffer_AppendString(tbuf, "}\n");
6552  GWEN_Buffer_AppendString(tbuf, "\n");
6553 
6554 
6555  /* EmitSignal */
6556  GWEN_Buffer_AppendString(tbuf, "int ");
6557  s=Typemaker2_Type_GetPrefix(ty);
6558  GWEN_Buffer_AppendString(tbuf, s);
6559  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6560  s=Typemaker2_Signal_GetName(sig);
6561  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6562  GWEN_Buffer_AppendString(tbuf, s+1);
6563  GWEN_Buffer_AppendString(tbuf, "(");
6564  s=Typemaker2_Type_GetIdentifier(ty);
6565  GWEN_Buffer_AppendString(tbuf, s);
6566  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6567  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6568  if (s && *s && strcasecmp(s, "none")) {
6569  GWEN_Buffer_AppendString(tbuf, ", ");
6570  GWEN_Buffer_AppendString(tbuf, s);
6571  GWEN_Buffer_AppendString(tbuf, " param1");
6572  }
6573  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6574  if (s && *s && strcasecmp(s, "none")) {
6575  GWEN_Buffer_AppendString(tbuf, ", ");
6576  GWEN_Buffer_AppendString(tbuf, s);
6577  GWEN_Buffer_AppendString(tbuf, " param2");
6578  }
6579  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6580  GWEN_Buffer_AppendString(tbuf, ", int param3");
6581  }
6582  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6583  GWEN_Buffer_AppendString(tbuf, ", int param4");
6584  }
6585  GWEN_Buffer_AppendString(tbuf, "){\n");
6586 
6587  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6588  GWEN_Buffer_AppendString(tbuf, "\n");
6589  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6590  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6591  s=Typemaker2_Signal_GetName(sig); /* name */
6592  GWEN_Buffer_AppendString(tbuf, "\"");
6593  GWEN_Buffer_AppendString(tbuf, s);
6594  GWEN_Buffer_AppendString(tbuf, "\", ");
6595 
6596  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6597  GWEN_Buffer_AppendString(tbuf, "\"");
6598  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6599  GWEN_Buffer_AppendString(tbuf, "\", ");
6600  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6601  GWEN_Buffer_AppendString(tbuf, "\"");
6602  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6603  GWEN_Buffer_AppendString(tbuf, "\");\n");
6604 
6605  GWEN_Buffer_AppendString(tbuf, " if (sig) \n");
6606  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Emit(sig, ");
6607  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6608  if (s && *s && strcasecmp(s, "none")) {
6609  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6610  GWEN_Buffer_AppendString(tbuf, "param1, ");
6611  }
6612  else
6613  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6614  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6615  if (s && *s && strcasecmp(s, "none")) {
6616  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6617  GWEN_Buffer_AppendString(tbuf, " param2, ");
6618  }
6619  else
6620  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6621  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3)
6622  GWEN_Buffer_AppendString(tbuf, "param3, ");
6623  else
6624  GWEN_Buffer_AppendString(tbuf, "0, ");
6625  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4)
6626  GWEN_Buffer_AppendString(tbuf, "param4");
6627  else
6628  GWEN_Buffer_AppendString(tbuf, "0");
6629  GWEN_Buffer_AppendString(tbuf, ");\n");
6630 
6631 
6632  GWEN_Buffer_AppendString(tbuf, " else\n");
6633  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6634 
6635  GWEN_Buffer_AppendString(tbuf, "}\n");
6636  GWEN_Buffer_AppendString(tbuf, "\n");
6637 
6638 
6639  sig=Typemaker2_Signal_List_Next(sig);
6640  }
6641  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6642  GWEN_Buffer_Reset(tbuf);
6643 
6644  }
6645  GWEN_Buffer_free(tbuf);
6646 
6647  return 0;
6648 }
6649 
6650 
6651 
6652 static int _buildSlotFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6653 {
6654  GWEN_BUFFER *tbuf;
6655  const char *s;
6656  TYPEMAKER2_TYPEMANAGER *tym;
6657  TYPEMAKER2_SLOT_LIST *slotList;
6658 
6659  tym=Typemaker2_Builder_GetTypeManager(tb);
6660  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6661 
6662  slotList=Typemaker2_Type_GetSlots(ty);
6663  if (slotList) {
6664  TYPEMAKER2_SLOT *slot;
6665 
6666  /* private prototypes */
6667  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6668  slot=Typemaker2_Slot_List_First(slotList);
6669  while (slot) {
6670 
6671  /* callback function */
6672  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6673  s=Typemaker2_Type_GetPrefix(ty);
6674  GWEN_Buffer_AppendString(tbuf, s);
6675  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6676  s=Typemaker2_Slot_GetName(slot);
6677  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6678  GWEN_Buffer_AppendString(tbuf, s+1);
6679  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4);\n");
6680 
6681  slot=Typemaker2_Slot_List_Next(slot);
6682  }
6683 
6684  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6685  GWEN_Buffer_Reset(tbuf);
6686 
6687  /* public prototypes */
6688  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6689  slot=Typemaker2_Slot_List_First(slotList);
6690  while (slot) {
6691  /* GetSlot */
6692  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6693  if (s) {
6694  GWEN_Buffer_AppendString(tbuf, s);
6695  GWEN_Buffer_AppendString(tbuf, " ");
6696  }
6697  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6698  s=Typemaker2_Type_GetPrefix(ty);
6699  GWEN_Buffer_AppendString(tbuf, s);
6700  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6701  s=Typemaker2_Slot_GetName(slot);
6702  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6703  GWEN_Buffer_AppendString(tbuf, s+1);
6704  GWEN_Buffer_AppendString(tbuf, "(const ");
6705  s=Typemaker2_Type_GetIdentifier(ty);
6706  GWEN_Buffer_AppendString(tbuf, s);
6707  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6708 
6709 
6710  slot=Typemaker2_Slot_List_Next(slot);
6711  }
6712  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6713  GWEN_Buffer_Reset(tbuf);
6714 
6715  /* implementation */
6716  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6717  slot=Typemaker2_Slot_List_First(slotList);
6718  while (slot) {
6719 
6720  /* callback function */
6721  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6722  s=Typemaker2_Type_GetPrefix(ty);
6723  GWEN_Buffer_AppendString(tbuf, s);
6724  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6725  s=Typemaker2_Slot_GetName(slot);
6726  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6727  GWEN_Buffer_AppendString(tbuf, s+1);
6728  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4) {\n");
6729 
6730  GWEN_Buffer_AppendString(tbuf, " ");
6731  s=Typemaker2_Type_GetIdentifier(ty);
6732  GWEN_Buffer_AppendString(tbuf, s);
6733  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
6734 
6735  GWEN_Buffer_AppendString(tbuf, "\n");
6736  GWEN_Buffer_AppendString(tbuf, " p_struct=(");
6737  GWEN_Buffer_AppendString(tbuf, s);
6738  GWEN_Buffer_AppendString(tbuf, "*) userData;\n");
6739 
6740  GWEN_Buffer_AppendString(tbuf, " return ");
6741  s=Typemaker2_Type_GetPrefix(ty);
6742  GWEN_Buffer_AppendString(tbuf, s);
6743  GWEN_Buffer_AppendString(tbuf, "_");
6744  s=Typemaker2_Slot_GetName(slot);
6745  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6746  GWEN_Buffer_AppendString(tbuf, s+1);
6747  GWEN_Buffer_AppendString(tbuf, "(p_struct");
6748 
6749  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6750  if (s && *s && strcasecmp(s, "none")) {
6751  GWEN_Buffer_AppendString(tbuf, ", (");
6752  GWEN_Buffer_AppendString(tbuf, s);
6753  GWEN_Buffer_AppendString(tbuf, ") p1");
6754  }
6755  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6756  if (s && *s && strcasecmp(s, "none")) {
6757  GWEN_Buffer_AppendString(tbuf, ", (");
6758  GWEN_Buffer_AppendString(tbuf, s);
6759  GWEN_Buffer_AppendString(tbuf, ") p2");
6760  }
6761  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3)
6762  GWEN_Buffer_AppendString(tbuf, ", p3");
6763  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4)
6764  GWEN_Buffer_AppendString(tbuf, ", p4");
6765 
6766  GWEN_Buffer_AppendString(tbuf, ");\n");
6767 
6768  GWEN_Buffer_AppendString(tbuf, "}\n\n");
6769 
6770 
6771  /* GetSlot */
6772  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6773  s=Typemaker2_Type_GetPrefix(ty);
6774  GWEN_Buffer_AppendString(tbuf, s);
6775  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6776  s=Typemaker2_Slot_GetName(slot);
6777  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6778  GWEN_Buffer_AppendString(tbuf, s+1);
6779  GWEN_Buffer_AppendString(tbuf, "(const ");
6780  s=Typemaker2_Type_GetIdentifier(ty);
6781  GWEN_Buffer_AppendString(tbuf, s);
6782  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6783 
6784  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6785  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSlot(p_struct->_signalObject, ");
6786  s=Typemaker2_Slot_GetName(slot); /* name */
6787  GWEN_Buffer_AppendString(tbuf, "\"");
6788  GWEN_Buffer_AppendString(tbuf, s);
6789  GWEN_Buffer_AppendString(tbuf, "\", ");
6790  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6791  GWEN_Buffer_AppendString(tbuf, "\"");
6792  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6793  GWEN_Buffer_AppendString(tbuf, "\", ");
6794  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6795  GWEN_Buffer_AppendString(tbuf, "\"");
6796  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6797  GWEN_Buffer_AppendString(tbuf, "\");\n");
6798 
6799  GWEN_Buffer_AppendString(tbuf, "}\n");
6800  GWEN_Buffer_AppendString(tbuf, "\n");
6801 
6802  slot=Typemaker2_Slot_List_Next(slot);
6803  }
6804  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6805  GWEN_Buffer_Reset(tbuf);
6806 
6807  }
6808  GWEN_Buffer_free(tbuf);
6809 
6810  return 0;
6811 }
6812 
6813 
6814 
6815 static int _buildCacheFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6816 {
6817  GWEN_BUFFER *tbuf;
6818  const char *s;
6819  TYPEMAKER2_TYPEMANAGER *tym;
6820 
6821  tym=Typemaker2_Builder_GetTypeManager(tb);
6822  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6823 
6824  /* public prototypes */
6825  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
6826 
6827  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6828  if (s) {
6829  GWEN_Buffer_AppendString(tbuf, s);
6830  GWEN_Buffer_AppendString(tbuf, " ");
6831  }
6832  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6833  s=Typemaker2_Type_GetPrefix(ty);
6834  GWEN_Buffer_AppendString(tbuf, s);
6835  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr);\n");
6836  GWEN_Buffer_AppendString(tbuf, "\n");
6837 
6838  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6839  if (s) {
6840  GWEN_Buffer_AppendString(tbuf, s);
6841  GWEN_Buffer_AppendString(tbuf, " ");
6842  }
6843  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6844  s=Typemaker2_Type_GetPrefix(ty);
6845  GWEN_Buffer_AppendString(tbuf, s);
6846  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr);\n");
6847  GWEN_Buffer_AppendString(tbuf, "\n");
6848 
6849  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6850  GWEN_Buffer_Reset(tbuf);
6851 
6852 
6853  /* implementations */
6854  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
6855 
6856  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6857  s=Typemaker2_Type_GetPrefix(ty);
6858  GWEN_Buffer_AppendString(tbuf, s);
6859  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr) {\n");
6860  GWEN_Buffer_AppendString(tbuf, " ");
6861  s=Typemaker2_Type_GetPrefix(ty);
6862  GWEN_Buffer_AppendString(tbuf, s);
6863  GWEN_Buffer_AppendString(tbuf, "_Attach((");
6864  s=Typemaker2_Type_GetIdentifier(ty);
6865  GWEN_Buffer_AppendString(tbuf, s);
6866  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
6867  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6868  GWEN_Buffer_AppendString(tbuf, "}\n");
6869  GWEN_Buffer_AppendString(tbuf, "\n");
6870 
6871  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
6872  s=Typemaker2_Type_GetPrefix(ty);
6873  GWEN_Buffer_AppendString(tbuf, s);
6874  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr){\n");
6875  GWEN_Buffer_AppendString(tbuf, " ");
6876  s=Typemaker2_Type_GetPrefix(ty);
6877  GWEN_Buffer_AppendString(tbuf, s);
6878  GWEN_Buffer_AppendString(tbuf, "_free((");
6879  s=Typemaker2_Type_GetIdentifier(ty);
6880  GWEN_Buffer_AppendString(tbuf, s);
6881  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
6882  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6883  GWEN_Buffer_AppendString(tbuf, "}\n");
6884  GWEN_Buffer_AppendString(tbuf, "\n");
6885 
6886 
6887  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6888  GWEN_Buffer_free(tbuf);
6889 
6890  return 0;
6891 }
6892 
6893 
6894 
6895 static int _buildGroupApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty,
6896  TYPEMAKER2_GROUP *grp, int depth, GWEN_BUFFER *buf)
6897 {
6898  char numbuf[32];
6899  const char *s;
6900  TYPEMAKER2_GROUP *childGrp;
6901  TYPEMAKER2_MEMBER_LIST *members;
6902  const char *sTypeIdentifier;
6903  const char *sTypePrefix;
6904 
6905  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
6906  sTypePrefix=Typemaker2_Type_GetPrefix(ty);
6907 
6908  /* write title */
6909  GWEN_Buffer_AppendString(buf, "\n\n");
6910  GWEN_Buffer_AppendString(buf, "<h");
6911  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth);
6912  numbuf[sizeof(numbuf)-1]=0;
6913  GWEN_Buffer_AppendString(buf, numbuf);
6914  GWEN_Buffer_AppendString(buf, ">");
6915  s=Typemaker2_Group_GetTitle(grp);
6916  if (s && *s)
6917  GWEN_Buffer_AppendString(buf, s);
6918  else
6919  GWEN_Buffer_AppendString(buf, "Unnamed Group");
6920  GWEN_Buffer_AppendString(buf, "</h");
6921  GWEN_Buffer_AppendString(buf, numbuf);
6922  GWEN_Buffer_AppendString(buf, ">\n");
6923  GWEN_Buffer_AppendString(buf, "\n");
6924 
6925  s=Typemaker2_Group_GetDescription(grp);
6926  if (s && *s) {
6927  GWEN_DB_NODE *dbCall;
6928  int rv;
6929 
6930  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
6931  assert(dbCall);
6932  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
6933  if (rv<0) {
6934  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6935  GWEN_DB_Group_free(dbCall);
6936  GWEN_Buffer_free(buf);
6937  return rv;
6938  }
6939  GWEN_DB_Group_free(dbCall);
6940  GWEN_Buffer_AppendString(buf, "\n");
6941  }
6942 
6943  /* write member docs */
6944  members=Typemaker2_Type_GetMembers(ty);
6945  if (members) {
6946  TYPEMAKER2_MEMBER *tm;
6947 
6948  tm=Typemaker2_Member_List_First(members);
6949  while (tm) {
6950 
6951  if (Typemaker2_Member_GetGroupPtr(tm)==grp) {
6952  const char *sMemberName;
6953 
6954  /* write APIDOC for member */
6955  sMemberName=Typemaker2_Member_GetName(tm);
6956 
6957  /* write anchor */
6958  GWEN_Buffer_AppendString(buf, "\n\n@anchor ");
6959  GWEN_Buffer_AppendString(buf, sTypeIdentifier);
6960  GWEN_Buffer_AppendString(buf, "_");
6961  GWEN_Buffer_AppendString(buf, sMemberName);
6962  GWEN_Buffer_AppendString(buf, "\n");
6963 
6964  /* write name */
6965  GWEN_Buffer_AppendString(buf, "<h");
6966  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth+1);
6967  numbuf[sizeof(numbuf)-1]=0;
6968  GWEN_Buffer_AppendString(buf, numbuf);
6969  GWEN_Buffer_AppendString(buf, ">");
6970  s=Typemaker2_Member_GetName(tm);
6971  GWEN_Buffer_AppendString(buf, s);
6972  GWEN_Buffer_AppendString(buf, "</h");
6973  GWEN_Buffer_AppendString(buf, numbuf);
6974  GWEN_Buffer_AppendString(buf, ">\n");
6975  GWEN_Buffer_AppendString(buf, "\n");
6976 
6977  /* add description, if any */
6978  s=Typemaker2_Member_GetDescription(tm);
6979  if (s && *s) {
6980  GWEN_DB_NODE *dbCall;
6981  int rv;
6982 
6983  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
6984  assert(dbCall);
6985  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
6986  if (rv<0) {
6987  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6988  GWEN_DB_Group_free(dbCall);
6989  GWEN_Buffer_free(buf);
6990  return rv;
6991  }
6992  GWEN_DB_Group_free(dbCall);
6993  GWEN_Buffer_AppendString(buf, "\n");
6994  }
6995 
6996  /* add setter/getter info */
6997  GWEN_Buffer_AppendString(buf, "<p>");
6998  GWEN_Buffer_AppendString(buf, "Set this property with @ref ");
6999  GWEN_Buffer_AppendString(buf, sTypePrefix);
7000  GWEN_Buffer_AppendString(buf, "_Set");
7001  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7002  GWEN_Buffer_AppendString(buf, sMemberName+1);
7003  GWEN_Buffer_AppendString(buf, "(), get it with @ref ");
7004  GWEN_Buffer_AppendString(buf, sTypePrefix);
7005  GWEN_Buffer_AppendString(buf, "_Get");
7006  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7007  GWEN_Buffer_AppendString(buf, sMemberName+1);
7008  GWEN_Buffer_AppendString(buf, "().");
7009  GWEN_Buffer_AppendString(buf, "</p>\n");
7010  }
7011  tm=Typemaker2_Member_List_Next(tm);
7012  }
7013  }
7014 
7015  /* write children groups */
7016  childGrp=Typemaker2_Group_Tree_GetFirstChild(grp);
7017  while (childGrp) {
7018  int rv;
7019 
7020  rv=_buildGroupApiDoc(tb, ty, childGrp, depth+1, buf);
7021  if (rv<0) {
7022  DBG_ERROR(0, "here (%d)", rv);
7023  return rv;
7024  }
7025  childGrp=Typemaker2_Group_Tree_GetNext(childGrp);
7026  }
7027 
7028  return 0;
7029 }
7030 
7031 
7032 
7033 
7034 static int _buildApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7035 {
7036  TYPEMAKER2_GROUP_TREE *groupTree;
7037  TYPEMAKER2_GROUP *grp;
7038  GWEN_BUFFER *tbuf;
7039  const char *sTypeIdentifier;
7040 
7041  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
7042 
7043  groupTree=Typemaker2_Type_GetGroupTree(ty);
7044 
7045  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7046 
7047  GWEN_Buffer_AppendString(tbuf, "/** @page P_");
7048  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7049  GWEN_Buffer_AppendString(tbuf, " Structure ");
7050  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7051 
7052  GWEN_Buffer_AppendString(tbuf, "\n");
7053 
7054  GWEN_Buffer_AppendString(tbuf, "<p>This page describes the properties of ");
7055  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7056  GWEN_Buffer_AppendString(tbuf, ".</p>\n");
7057 
7058  GWEN_Buffer_AppendString(tbuf, "\n");
7059 
7060 
7061  grp=Typemaker2_Group_Tree_GetFirst(groupTree);
7062  while (grp) {
7063  _buildGroupApiDoc(tb, ty, grp, 1, tbuf);
7064  grp=Typemaker2_Group_Tree_GetNext(grp);
7065  }
7066  GWEN_Buffer_AppendString(tbuf, "\n");
7067  GWEN_Buffer_AppendString(tbuf, "*/\n");
7068 
7069  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
7070 
7071  GWEN_Buffer_free(tbuf);
7072 
7073  return 0;
7074 }
7075 
7076 
7077 
7078 
7079 static int _addVirtualFnsFromSlots(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7080 {
7081  GWEN_BUFFER *tbuf;
7082  const char *s;
7083  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7084  TYPEMAKER2_SLOT_LIST *slotList;
7085 
7086  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7087  fnList=Typemaker2_Type_GetVirtualFns(ty);
7088 
7089  slotList=Typemaker2_Type_GetSlots(ty);
7090  if (slotList) {
7091  TYPEMAKER2_SLOT *slot;
7092 
7093  slot=Typemaker2_Slot_List_First(slotList);
7094  while (slot) {
7095  TYPEMAKER2_VIRTUALFN *fn;
7096  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
7097 
7098  /* callback function */
7099  s=Typemaker2_Slot_GetName(slot);
7100  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
7101  GWEN_Buffer_AppendString(tbuf, s+1);
7102 
7103  fn=Typemaker2_VirtualFn_new();
7104  plist=Typemaker2_VirtualFn_GetParamTypeList(fn);
7105 
7106  /* name */
7107  Typemaker2_VirtualFn_SetName(fn, GWEN_Buffer_GetStart(tbuf));
7108 
7109  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
7110  if (s && *s && strcasecmp(s, "none")) {
7111  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7112 
7113  prm=Typemaker2_VirtualFn_Param_new();
7114  Typemaker2_VirtualFn_Param_SetType(prm, s);
7115  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7116  }
7117  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
7118  if (s && *s && strcasecmp(s, "none")) {
7119  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7120 
7121  prm=Typemaker2_VirtualFn_Param_new();
7122  Typemaker2_VirtualFn_Param_SetType(prm, s);
7123  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7124  }
7125  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3) {
7126  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7127 
7128  prm=Typemaker2_VirtualFn_Param_new();
7129  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7130  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7131  }
7132  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4) {
7133  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7134 
7135  prm=Typemaker2_VirtualFn_Param_new();
7136  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7137  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7138  }
7139 
7140  Typemaker2_VirtualFn_SetAccess(fn, TypeMaker2_Access_Public);
7141  Typemaker2_VirtualFn_SetLocation(fn, "post");
7142  Typemaker2_VirtualFn_SetReturnType(fn, "int");
7143  Typemaker2_VirtualFn_SetDefaultReturnValue(fn, "GWEN_ERROR_NOT_IMPLEMENTED");
7144 
7145  Typemaker2_VirtualFn_AddFlags(fn, TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT);
7146 
7147  Typemaker2_VirtualFn_List_Add(fn, fnList);
7148 
7149  slot=Typemaker2_Slot_List_Next(slot);
7150  }
7151  }
7152  GWEN_Buffer_free(tbuf);
7153 
7154  return 0;
7155 }
7156 
7157 
7158 
7159 static void _delVirtualFnsFromSlots(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7160 {
7161  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7162 
7163  fnList=Typemaker2_Type_GetVirtualFns(ty);
7164  if (fnList) {
7165  TYPEMAKER2_VIRTUALFN *fn;
7166 
7167  fn=Typemaker2_VirtualFn_List_First(fnList);
7168  while (fn) {
7169  TYPEMAKER2_VIRTUALFN *fnNext;
7170 
7171  fnNext=Typemaker2_VirtualFn_List_Next(fn);
7172  if (Typemaker2_VirtualFn_GetFlags(fn) & TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT) {
7173  Typemaker2_VirtualFn_List_Del(fn);
7174  Typemaker2_VirtualFn_free(fn);
7175  }
7176  fn=fnNext;
7177  }
7178  }
7179 }
7180 
7181 
7182 
7183 
7184 static int Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7185 {
7186  int rv;
7187  uint32_t flags;
7188 
7189  flags=Typemaker2_Type_GetFlags(ty);
7190 
7191  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7192  _delVirtualFnsFromSlots(tb, ty);
7193  rv=_addVirtualFnsFromSlots(tb, ty);
7194  if (rv<0) {
7195  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7196  return rv;
7197  }
7198  }
7199 
7200 
7201  rv=_setEnumStringFns(tb, ty);
7202  if (rv<0) {
7203  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7204  return rv;
7205  }
7206 
7207  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7208  rv=_buildFieldIds(tb, ty);
7209  if (rv<0) {
7210  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7211  return rv;
7212  }
7213  }
7214 
7215  rv=_buildApiDoc(tb, ty);
7216  if (rv<0) {
7217  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7218  return rv;
7219  }
7220 
7221  rv=_buildDefineDefines(tb, ty);
7222  if (rv<0) {
7223  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7224  return rv;
7225  }
7226 
7227  rv=_buildTypedef(tb, ty);
7228  if (rv<0) {
7229  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7230  return rv;
7231  }
7232 
7233  rv=_buildDefineEnums(tb, ty);
7234  if (rv<0) {
7235  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7236  return rv;
7237  }
7238 
7239  rv=_buildDefineVirtualFns(tb, ty, "pre");
7240  if (rv<0) {
7241  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7242  return rv;
7243  }
7244 
7245  rv=_buildPostHeaders(tb, ty);
7246  if (rv<0) {
7247  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7248  return rv;
7249  }
7250 
7251  rv=_buildDefineVirtualFns(tb, ty, "post");
7252  if (rv<0) {
7253  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7254  return rv;
7255  }
7256 
7257  rv=_buildStruct(tb, ty);
7258  if (rv<0) {
7259  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7260  return rv;
7261  }
7262 
7263  rv=_buildMacroFunctions(tb, ty);
7264  if (rv<0) {
7265  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7266  return rv;
7267  }
7268 
7269  rv=_buildEnumFromString(tb, ty);
7270  if (rv<0) {
7271  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7272  return rv;
7273  }
7274 
7275  rv=_buildEnumToString(tb, ty);
7276  if (rv<0) {
7277  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7278  return rv;
7279  }
7280 
7281  rv=_buildConstructor(tb, ty);
7282  if (rv<0) {
7283  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7284  return rv;
7285  }
7286 
7287  rv=_buildDestructor(tb, ty);
7288  if (rv<0) {
7289  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7290  return rv;
7291  }
7292 
7293  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
7294  rv=_buildAttach(tb, ty);
7295  if (rv<0) {
7296  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7297  return rv;
7298  }
7299  }
7300 
7301  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7302  rv=_buildDup(tb, ty);
7303  if (rv<0) {
7304  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7305  return rv;
7306  }
7307  }
7308 
7309  if (!(flags & TYPEMAKER2_TYPEFLAGS_NOCOPY)) {
7310  rv=_buildCopy(tb, ty);
7311  if (rv<0) {
7312  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7313  return rv;
7314  }
7315  }
7316 
7317  rv=_buildGetter(tb, ty);
7318  if (rv<0) {
7319  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7320  return rv;
7321  }
7322 
7323  rv=_buildSetter(tb, ty);
7324  if (rv<0) {
7325  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7326  return rv;
7327  }
7328 
7329  rv=_buildProtoVirtualFns(tb, ty);
7330  if (rv<0) {
7331  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7332  return rv;
7333  }
7334 
7335  rv=_buildCodeVirtualFns(tb, ty);
7336  if (rv<0) {
7337  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7338  return rv;
7339  }
7340 
7341  rv=_buildProtoSetterVirtualFns(tb, ty);
7342  if (rv<0) {
7343  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7344  return rv;
7345  }
7346 
7347  rv=_buildSetterVirtualFns(tb, ty);
7348  if (rv<0) {
7349  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7350  return rv;
7351  }
7352 
7353  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
7354  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7355  rv=_buildList1Dup(tb, ty);
7356  if (rv<0) {
7357  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7358  return rv;
7359  }
7360  }
7361  }
7362 
7363  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_DB) {
7364  rv=_buildReadDb(tb, ty);
7365  if (rv<0) {
7366  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7367  return rv;
7368  }
7369 
7370  rv=_buildWriteDb(tb, ty);
7371  if (rv<0) {
7372  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7373  return rv;
7374  }
7375 
7376  rv=_buildFromDb(tb, ty);
7377  if (rv<0) {
7378  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7379  return rv;
7380  }
7381 
7382  rv=_buildToDb(tb, ty);
7383  if (rv<0) {
7384  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7385  return rv;
7386  }
7387 
7388  }
7389 
7390  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_XML) {
7391  rv=_buildReadXml(tb, ty);
7392  if (rv<0) {
7393  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7394  return rv;
7395  }
7396 
7397  rv=_buildWriteXml(tb, ty);
7398  if (rv<0) {
7399  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7400  return rv;
7401  }
7402 
7403  rv=_buildToXml(tb, ty);
7404  if (rv<0) {
7405  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7406  return rv;
7407  }
7408 
7409  rv=_buildFromXml(tb, ty);
7410  if (rv<0) {
7411  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7412  return rv;
7413  }
7414  }
7415 
7416  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7417  rv=_buildReadObject(tb, ty);
7418  if (rv<0) {
7419  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7420  return rv;
7421  }
7422 
7423  rv=_buildWriteObject(tb, ty);
7424  if (rv<0) {
7425  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7426  return rv;
7427  }
7428 
7429  rv=_buildToObject(tb, ty);
7430  if (rv<0) {
7431  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7432  return rv;
7433  }
7434 
7435  rv=_buildFromObject(tb, ty);
7436  if (rv<0) {
7437  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7438  return rv;
7439  }
7440 
7441  rv=_buildCreateColumnList(tb, ty);
7442  if (rv<0) {
7443  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7444  return rv;
7445  }
7446 
7447  rv=_buildCreateTable(tb, ty);
7448  if (rv<0) {
7449  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7450  return rv;
7451  }
7452 
7453  rv=_buildCreateObject(tb, ty);
7454  if (rv<0) {
7455  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7456  return rv;
7457  }
7458  }
7459 
7460  rv=_buildGetByMember(tb, ty);
7461  if (rv<0) {
7462  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7463  return rv;
7464  }
7465 
7466  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_HASH) {
7467  rv=_buildToHashString(tb, ty);
7468  if (rv<0) {
7469  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7470  return rv;
7471  }
7472  }
7473 
7474  rv=_buildMemberInlines(tb, ty);
7475  if (rv<0) {
7476  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7477  return rv;
7478  }
7479 
7480 
7481  rv=_buildSortByMember(tb, ty);
7482  if (rv<0) {
7483  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7484  return rv;
7485  }
7486 
7487 
7488  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) {
7489  rv=_buildSignalFunctions(tb, ty);
7490  if (rv<0) {
7491  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7492  return rv;
7493  }
7494  }
7495 
7496  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7497  rv=_buildSlotFunctions(tb, ty);
7498  if (rv<0) {
7499  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7500  return rv;
7501  }
7502  }
7503 
7504  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS) {
7505  rv=_buildCacheFunctions(tb, ty);
7506  if (rv<0) {
7507  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7508  return rv;
7509  }
7510  }
7511 
7512  rv=_buildInlines(tb, ty);
7513  if (rv<0) {
7514  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7515  return rv;
7516  }
7517 
7518  rv=_buildEndHeaders(tb, ty);
7519  if (rv<0) {
7520  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7521  return rv;
7522  }
7523 
7524  return 0;
7525 }
7526 
7527 
7528 
7529 TYPEMAKER2_BUILDER *Typemaker2_Builder_C_new()
7530 {
7531  TYPEMAKER2_BUILDER *tb;
7532 
7533  tb=Typemaker2_Builder_new();
7534  Typemaker2_Builder_SetBuildFn(tb, Typemaker2_Builder_C_Build);
7535 
7536  return tb;
7537 }
7538 
7539 
7540 
7541 
7542 
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:69
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:70
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:77
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:235
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:85
TYPEMAKER2_TYPEFLAGS_WITH_HASH
#define TYPEMAKER2_TYPEFLAGS_WITH_HASH
Definition: tm_type.h:68
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:65
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:5439
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:6652
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:67
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:6815
_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:4452
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
_addVirtualFnsFromSlots
static int _addVirtualFnsFromSlots(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7079
_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:297
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:5135
TYPEMAKER2_TYPEFLAGS_WITH_XML
#define TYPEMAKER2_TYPEFLAGS_WITH_XML
Definition: tm_type.h:53
_buildToHashString
static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5993
TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
#define TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
Definition: tm_slot.h:17
TypeMaker2_Access_Protected
Definition: tm_type.h:86
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:62
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:5003
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:719
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:6178
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:6895
_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_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:4261
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:5651
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:5849
TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
#define TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
Definition: tm_type.h:61
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:63
TYPEMAKER2_TYPEFLAGS_WITH_TREE
#define TYPEMAKER2_TYPEFLAGS_WITH_TREE
Definition: tm_type.h:59
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:7184
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:399
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:7034
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:5889
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:41
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:6272
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:6323
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:58
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:5287
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:7529
_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:4707
_buildInlines
static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6104
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:5591
TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
#define TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
Definition: tm_type.h:60
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:4608
_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:4870
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:57
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)
_delVirtualFnsFromSlots
static void _delVirtualFnsFromSlots(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7159
_buildCreateObject
static int _buildCreateObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3971
_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:78
_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:56
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:54
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:87
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:1062
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:88
TYPEMAKER2_TYPEFLAGS_WITH_DB
#define TYPEMAKER2_TYPEFLAGS_WITH_DB
Definition: tm_type.h:52
Typemaker2_Define_GetMode
int Typemaker2_Define_GetMode(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:208
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
_setEnumStringFns
static int _setEnumStringFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4817
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:55
Typemaker2_VirtualFn_GetAccess
int Typemaker2_VirtualFn_GetAccess(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:282
Generated by   doxygen 1.8.14