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