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