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