gwenhywfar  5.6.0
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 int _buildProtoGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4826 {
4827  TYPEMAKER2_VIRTUALFN_LIST *fns;
4828  TYPEMAKER2_TYPEMANAGER *tym;
4829  /* uint32_t flags; */
4830 
4831  tym=Typemaker2_Builder_GetTypeManager(tb);
4832  fns=Typemaker2_Type_GetVirtualFns(ty);
4833  /* flags=Typemaker2_Type_GetFlags(ty); */
4834 
4835  assert(fns);
4836  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4837  GWEN_BUFFER *tbuf;
4838  const char *s;
4839  TYPEMAKER2_VIRTUALFN *vf;
4840 
4841  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4842 
4843  GWEN_Buffer_AppendString(tbuf, "/* getters for virtual functions */\n");
4844  vf=Typemaker2_VirtualFn_List_First(fns);
4845  while (vf) {
4846  int access=Typemaker2_VirtualFn_GetAccess(vf);
4847 
4848  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
4849  if (s && *s) {
4850  GWEN_Buffer_AppendString(tbuf, s);
4851  GWEN_Buffer_AppendString(tbuf, " ");
4852  }
4853 
4854  s=Typemaker2_Type_GetIdentifier(ty);
4855  GWEN_Buffer_AppendString(tbuf, s);
4856  GWEN_Buffer_AppendString(tbuf, "_");
4857  s=Typemaker2_VirtualFn_GetName(vf);
4858  if (!(s && *s)) {
4859  GWEN_Buffer_free(tbuf);
4860  return GWEN_ERROR_BAD_DATA;
4861  }
4862  while (*s)
4863  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4864  GWEN_Buffer_AppendString(tbuf, "_FN ");
4865 
4866  s=Typemaker2_Type_GetPrefix(ty);
4867  GWEN_Buffer_AppendString(tbuf, s);
4868  GWEN_Buffer_AppendString(tbuf, "_Get");
4869  s=Typemaker2_VirtualFn_GetName(vf);
4870  if (!(s && *s)) {
4871  GWEN_Buffer_free(tbuf);
4872  return GWEN_ERROR_BAD_DATA;
4873  }
4874  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4875  GWEN_Buffer_AppendString(tbuf, s+1);
4876  GWEN_Buffer_AppendString(tbuf, "Fn(const ");
4877 
4878  s=Typemaker2_Type_GetIdentifier(ty);
4879  GWEN_Buffer_AppendString(tbuf, s);
4880  /* created structs are always pointers */
4881  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
4882 
4883  switch (access) {
4884  case TypeMaker2_Access_Public:
4885  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4886  break;
4887  case TypeMaker2_Access_Library:
4888  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4889  break;
4890  case TypeMaker2_Access_Protected:
4891  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4892  break;
4893  case TypeMaker2_Access_Private:
4894  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
4895  break;
4896  default:
4897  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
4898  GWEN_Buffer_free(tbuf);
4899  return GWEN_ERROR_BAD_DATA;
4900  }
4901  GWEN_Buffer_Reset(tbuf);
4902 
4903  vf=Typemaker2_VirtualFn_List_Next(vf);
4904  }
4905  }
4906 
4907  return 0;
4908 }
4909 
4910 
4911 
4912 int _buildGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4913 {
4914  TYPEMAKER2_VIRTUALFN_LIST *fns;
4915  /* TYPEMAKER2_TYPEMANAGER *tym; */
4916  /* uint32_t flags; */
4917 
4918  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4919  fns=Typemaker2_Type_GetVirtualFns(ty);
4920  /* flags=Typemaker2_Type_GetFlags(ty); */
4921 
4922  assert(fns);
4923  if (Typemaker2_VirtualFn_List_GetCount(fns)) {
4924  GWEN_BUFFER *tbuf;
4925  const char *s;
4926  TYPEMAKER2_VIRTUALFN *vf;
4927 
4928  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
4929 
4930  GWEN_Buffer_AppendString(tbuf, "/* getters for virtual functions */\n");
4931  vf=Typemaker2_VirtualFn_List_First(fns);
4932  while (vf) {
4933 
4934  s=Typemaker2_Type_GetIdentifier(ty);
4935  GWEN_Buffer_AppendString(tbuf, s);
4936  GWEN_Buffer_AppendString(tbuf, "_");
4937 
4938  s=Typemaker2_VirtualFn_GetName(vf);
4939  if (!(s && *s)) {
4940  GWEN_Buffer_free(tbuf);
4941  return GWEN_ERROR_BAD_DATA;
4942  }
4943  while (*s)
4944  GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
4945  GWEN_Buffer_AppendString(tbuf, "_FN ");
4946 
4947  s=Typemaker2_Type_GetPrefix(ty);
4948  GWEN_Buffer_AppendString(tbuf, s);
4949  GWEN_Buffer_AppendString(tbuf, "_Get");
4950  s=Typemaker2_VirtualFn_GetName(vf);
4951  if (!(s && *s)) {
4952  GWEN_Buffer_free(tbuf);
4953  return GWEN_ERROR_BAD_DATA;
4954  }
4955  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
4956  GWEN_Buffer_AppendString(tbuf, s+1);
4957  GWEN_Buffer_AppendString(tbuf, "Fn(const ");
4958 
4959  s=Typemaker2_Type_GetIdentifier(ty);
4960  GWEN_Buffer_AppendString(tbuf, s);
4961  /* created structs are always pointers */
4962  GWEN_Buffer_AppendString(tbuf, " *p_struct){\n");
4963 
4964  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
4965  GWEN_Buffer_AppendString(tbuf, " return p_struct->");
4966  s=Typemaker2_VirtualFn_GetName(vf);
4967  if (!(s && *s)) {
4968  GWEN_Buffer_free(tbuf);
4969  return GWEN_ERROR_BAD_DATA;
4970  }
4971  GWEN_Buffer_AppendString(tbuf, s);
4972  GWEN_Buffer_AppendString(tbuf, "Fn;\n");
4973 
4974  GWEN_Buffer_AppendString(tbuf, "}\n");
4975 
4976  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
4977  GWEN_Buffer_Reset(tbuf);
4978 
4979  vf=Typemaker2_VirtualFn_List_Next(vf);
4980  }
4981  }
4982 
4983  return 0;
4984 }
4985 
4986 
4987 
4988 static int _setEnumStringFns(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
4989 {
4990  TYPEMAKER2_ENUM_LIST *enums;
4991  /* TYPEMAKER2_TYPEMANAGER *tym; */
4992  /* uint32_t flags; */
4993 
4994  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
4995  enums=Typemaker2_Type_GetEnums(ty);
4996  /* flags=Typemaker2_Type_GetFlags(ty); */
4997 
4998  assert(enums);
4999  if (Typemaker2_Enum_List_GetCount(enums)) {
5000  TYPEMAKER2_ENUM *te;
5001 
5002  te=Typemaker2_Enum_List_First(enums);
5003  while (te) {
5004  const char *prefix;
5005  GWEN_BUFFER *tbuf;
5006 
5007  prefix=Typemaker2_Enum_GetPrefix(te);
5008  if (prefix==NULL || *prefix==0) {
5009  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
5010  return GWEN_ERROR_BAD_DATA;
5011  }
5012 
5013  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5014  if (prefix && *prefix) {
5015  GWEN_Buffer_AppendString(tbuf, prefix);
5016  if (prefix[strlen(prefix)-1]!='_')
5017  GWEN_Buffer_AppendString(tbuf, "_");
5018  }
5019  GWEN_Buffer_AppendString(tbuf, "fromString");
5020  Typemaker2_Enum_SetFromStringFn(te, GWEN_Buffer_GetStart(tbuf));
5021  GWEN_Buffer_Reset(tbuf);
5022 
5023  if (prefix && *prefix) {
5024  GWEN_Buffer_AppendString(tbuf, prefix);
5025  if (prefix[strlen(prefix)-1]!='_')
5026  GWEN_Buffer_AppendString(tbuf, "_");
5027  }
5028  GWEN_Buffer_AppendString(tbuf, "toString");
5029  Typemaker2_Enum_SetToStringFn(te, GWEN_Buffer_GetStart(tbuf));
5030  GWEN_Buffer_free(tbuf);
5031 
5032  te=Typemaker2_Enum_List_Next(te);
5033  }
5034  }
5035 
5036  return 0;
5037 }
5038 
5039 
5040 
5041 static int _buildEnumFromString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5042 {
5043  TYPEMAKER2_ENUM_LIST *enums;
5044  TYPEMAKER2_TYPEMANAGER *tym;
5045  /* uint32_t flags; */
5046 
5047  tym=Typemaker2_Builder_GetTypeManager(tb);
5048  enums=Typemaker2_Type_GetEnums(ty);
5049  /* flags=Typemaker2_Type_GetFlags(ty); */
5050 
5051  assert(enums);
5052  if (Typemaker2_Enum_List_GetCount(enums)) {
5053  GWEN_BUFFER *tbuf;
5054  const char *s;
5055  TYPEMAKER2_ENUM *te;
5056 
5057  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5058 
5059  te=Typemaker2_Enum_List_First(enums);
5060  while (te) {
5061  const char *prefix;
5062  const char *etype;
5063  TYPEMAKER2_ITEM *ti;
5064  int acc=TypeMaker2_Access_Public;
5065  int i;
5066 
5067  prefix=Typemaker2_Enum_GetPrefix(te);
5068  if (prefix==NULL || *prefix==0) {
5069  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
5070  GWEN_Buffer_free(tbuf);
5071  return GWEN_ERROR_BAD_DATA;
5072  }
5073 
5074  etype=Typemaker2_Enum_GetType(te);
5075 
5076  /* prototype */
5077  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5078  if (s) {
5079  GWEN_Buffer_AppendString(tbuf, s);
5080  GWEN_Buffer_AppendString(tbuf, " ");
5081  }
5082  if (etype && *etype) {
5083  GWEN_Buffer_AppendString(tbuf, etype);
5084  GWEN_Buffer_AppendString(tbuf, " ");
5085  }
5086  else
5087  GWEN_Buffer_AppendString(tbuf, "int ");
5088  if (prefix && *prefix) {
5089  GWEN_Buffer_AppendString(tbuf, prefix);
5090  if (prefix[strlen(prefix)-1]!='_')
5091  GWEN_Buffer_AppendString(tbuf, "_");
5092  }
5093  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s);\n");
5094  switch (acc) {
5095  case TypeMaker2_Access_Public:
5096  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5097  break;
5098  case TypeMaker2_Access_Library:
5099  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5100  break;
5101  case TypeMaker2_Access_Protected:
5102  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5103  break;
5104  case TypeMaker2_Access_Private:
5105  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5106  break;
5107  default:
5108  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5109  GWEN_Buffer_free(tbuf);
5110  return GWEN_ERROR_BAD_DATA;
5111  }
5112  GWEN_Buffer_Reset(tbuf);
5113 
5114  /* implementation */
5115  if (etype && *etype) {
5116  GWEN_Buffer_AppendString(tbuf, etype);
5117  GWEN_Buffer_AppendString(tbuf, " ");
5118  }
5119  else
5120  GWEN_Buffer_AppendString(tbuf, "int ");
5121  if (prefix && *prefix) {
5122  GWEN_Buffer_AppendString(tbuf, prefix);
5123  if (prefix[strlen(prefix)-1]!='_')
5124  GWEN_Buffer_AppendString(tbuf, "_");
5125  }
5126  GWEN_Buffer_AppendString(tbuf, "fromString(const char *p_s) {\n");
5127 
5128  GWEN_Buffer_AppendString(tbuf, " if (p_s && *p_s) {\n");
5129 
5130  i=0;
5131  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
5132  while (ti) {
5133  GWEN_Buffer_AppendString(tbuf, " ");
5134  if (i++)
5135  GWEN_Buffer_AppendString(tbuf, "else ");
5136  GWEN_Buffer_AppendString(tbuf, "if (strcasecmp(p_s, \"");
5137  s=Typemaker2_Item_GetName(ti);
5138  if (s && *s) {
5139  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
5140  GWEN_Buffer_AppendString(tbuf, s+1);
5141  }
5142  GWEN_Buffer_AppendString(tbuf, "\")==0)\n");
5143  GWEN_Buffer_AppendString(tbuf, " return ");
5144  if (prefix)
5145  GWEN_Buffer_AppendString(tbuf, prefix);
5146  s=Typemaker2_Item_GetName(ti);
5147  if (s && *s) {
5148  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5149  GWEN_Buffer_AppendString(tbuf, s+1);
5150  }
5151  GWEN_Buffer_AppendString(tbuf, ";\n");
5152 
5153  ti=Typemaker2_Item_List_Next(ti);
5154  }
5155  GWEN_Buffer_AppendString(tbuf, " }\n");
5156  GWEN_Buffer_AppendString(tbuf, " return ");
5157  if (prefix)
5158  GWEN_Buffer_AppendString(tbuf, prefix);
5159  GWEN_Buffer_AppendString(tbuf, "Unknown;\n");
5160  GWEN_Buffer_AppendString(tbuf, "}\n");
5161 
5162  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5163  GWEN_Buffer_Reset(tbuf);
5164  te=Typemaker2_Enum_List_Next(te);
5165  }
5166  GWEN_Buffer_free(tbuf);
5167  } /* if enums */
5168 
5169  return 0;
5170 }
5171 
5172 
5173 
5174 static int _buildEnumToString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5175 {
5176  TYPEMAKER2_ENUM_LIST *enums;
5177  TYPEMAKER2_TYPEMANAGER *tym;
5178  /* uint32_t flags; */
5179 
5180  tym=Typemaker2_Builder_GetTypeManager(tb);
5181  enums=Typemaker2_Type_GetEnums(ty);
5182  /* flags=Typemaker2_Type_GetFlags(ty); */
5183 
5184  assert(enums);
5185  if (Typemaker2_Enum_List_GetCount(enums)) {
5186  GWEN_BUFFER *tbuf;
5187  const char *s;
5188  TYPEMAKER2_ENUM *te;
5189 
5190  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5191 
5192  te=Typemaker2_Enum_List_First(enums);
5193  while (te) {
5194  const char *prefix;
5195  const char *etype;
5196  TYPEMAKER2_ITEM *ti;
5197  int acc=TypeMaker2_Access_Public;
5198 
5199  prefix=Typemaker2_Enum_GetPrefix(te);
5200  if (prefix==NULL || *prefix==0) {
5201  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in enum definition");
5202  GWEN_Buffer_free(tbuf);
5203  return GWEN_ERROR_BAD_DATA;
5204  }
5205 
5206  etype=Typemaker2_Enum_GetType(te);
5207 
5208  /* prototype */
5209  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5210  if (s) {
5211  GWEN_Buffer_AppendString(tbuf, s);
5212  GWEN_Buffer_AppendString(tbuf, " ");
5213  }
5214  GWEN_Buffer_AppendString(tbuf, "const char *");
5215  if (prefix && *prefix) {
5216  GWEN_Buffer_AppendString(tbuf, prefix);
5217  if (prefix[strlen(prefix)-1]!='_')
5218  GWEN_Buffer_AppendString(tbuf, "_");
5219  }
5220  GWEN_Buffer_AppendString(tbuf, "toString(");
5221  if (etype && *etype)
5222  GWEN_Buffer_AppendString(tbuf, etype);
5223  else
5224  GWEN_Buffer_AppendString(tbuf, "int");
5225  GWEN_Buffer_AppendString(tbuf, " p_i);\n");
5226 
5227  switch (acc) {
5228  case TypeMaker2_Access_Public:
5229  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5230  break;
5231  case TypeMaker2_Access_Library:
5232  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5233  break;
5234  case TypeMaker2_Access_Protected:
5235  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5236  break;
5237  case TypeMaker2_Access_Private:
5238  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5239  break;
5240  default:
5241  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
5242  GWEN_Buffer_free(tbuf);
5243  return GWEN_ERROR_BAD_DATA;
5244  }
5245  GWEN_Buffer_Reset(tbuf);
5246 
5247  /* implementation */
5248  GWEN_Buffer_AppendString(tbuf, "const char *");
5249  if (prefix && *prefix) {
5250  GWEN_Buffer_AppendString(tbuf, prefix);
5251  if (prefix[strlen(prefix)-1]!='_')
5252  GWEN_Buffer_AppendString(tbuf, "_");
5253  }
5254  GWEN_Buffer_AppendString(tbuf, "toString(");
5255  if (etype && *etype)
5256  GWEN_Buffer_AppendString(tbuf, etype);
5257  else
5258  GWEN_Buffer_AppendString(tbuf, "int");
5259  GWEN_Buffer_AppendString(tbuf, " p_i) {\n");
5260 
5261  GWEN_Buffer_AppendString(tbuf, " switch(p_i) {\n");
5262  ti=Typemaker2_Item_List_First(Typemaker2_Enum_GetItems(te));
5263  while (ti) {
5264  GWEN_Buffer_AppendString(tbuf, " case ");
5265  if (prefix)
5266  GWEN_Buffer_AppendString(tbuf, prefix);
5267  s=Typemaker2_Item_GetName(ti);
5268  if (s && *s) {
5269  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5270  GWEN_Buffer_AppendString(tbuf, s+1);
5271  }
5272  GWEN_Buffer_AppendString(tbuf, ": return \"");
5273  s=Typemaker2_Item_GetName(ti);
5274  if (s && *s) {
5275  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
5276  GWEN_Buffer_AppendString(tbuf, s+1);
5277  }
5278  GWEN_Buffer_AppendString(tbuf, "\";\n");
5279 
5280  ti=Typemaker2_Item_List_Next(ti);
5281  }
5282 
5283  /* handle "unknown" */
5284  GWEN_Buffer_AppendString(tbuf, " case ");
5285  if (prefix)
5286  GWEN_Buffer_AppendString(tbuf, prefix);
5287  GWEN_Buffer_AppendString(tbuf, "Unknown:\n");
5288 
5289  /* handle default */
5290  GWEN_Buffer_AppendString(tbuf, " default: return \"unknown\";\n");
5291  GWEN_Buffer_AppendString(tbuf, " }\n");
5292  GWEN_Buffer_AppendString(tbuf, "}\n");
5293 
5294  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5295  GWEN_Buffer_Reset(tbuf);
5296  te=Typemaker2_Enum_List_Next(te);
5297  }
5298  GWEN_Buffer_free(tbuf);
5299  } /* if enums */
5300 
5301  return 0;
5302 }
5303 
5304 
5305 
5306 static int _buildList1GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5307 {
5308  GWEN_BUFFER *tbuf;
5309  const char *s;
5310  /* uint32_t flags; */
5311  TYPEMAKER2_TYPEMANAGER *tym;
5312  TYPEMAKER2_TYPE *mty;
5313 
5314  tym=Typemaker2_Builder_GetTypeManager(tb);
5315  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5316 
5317  /* flags=Typemaker2_Type_GetFlags(ty); */
5318 
5319  mty=Typemaker2_Member_GetTypePtr(tm);
5320  assert(mty);
5321 
5322  /* prototype */
5323  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5324  if (s) {
5325  GWEN_Buffer_AppendString(tbuf, s);
5326  GWEN_Buffer_AppendString(tbuf, " ");
5327  }
5328 
5329  s=Typemaker2_Type_GetIdentifier(ty);
5330  GWEN_Buffer_AppendString(tbuf, s);
5331  GWEN_Buffer_AppendString(tbuf, " *");
5332 
5333  s=Typemaker2_Type_GetPrefix(ty);
5334  GWEN_Buffer_AppendString(tbuf, s);
5335  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5336  GWEN_Buffer_AppendString(tbuf, "By");
5337  s=Typemaker2_Member_GetName(tm);
5338  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5339  GWEN_Buffer_AppendString(tbuf, s+1);
5340  GWEN_Buffer_AppendString(tbuf, "(const ");
5341  s=Typemaker2_Type_GetIdentifier(ty);
5342  GWEN_Buffer_AppendString(tbuf, s);
5343  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5344  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5345  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5346  GWEN_Buffer_AppendString(tbuf, " const ");
5347  s=Typemaker2_Type_GetIdentifier(mty);
5348  GWEN_Buffer_AppendString(tbuf, s);
5349  GWEN_Buffer_AppendString(tbuf, " *");
5350  }
5351  else {
5352  s=Typemaker2_Type_GetIdentifier(mty);
5353  GWEN_Buffer_AppendString(tbuf, s);
5354  GWEN_Buffer_AppendString(tbuf, " ");
5355  }
5356  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5357 
5358  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5359  GWEN_Buffer_Reset(tbuf);
5360 
5361  /* implementation */
5362  s=Typemaker2_Type_GetIdentifier(ty);
5363  GWEN_Buffer_AppendString(tbuf, s);
5364  GWEN_Buffer_AppendString(tbuf, " *");
5365 
5366  s=Typemaker2_Type_GetPrefix(ty);
5367  GWEN_Buffer_AppendString(tbuf, s);
5368  GWEN_Buffer_AppendString(tbuf, "_List_Get");
5369  GWEN_Buffer_AppendString(tbuf, "By");
5370  s=Typemaker2_Member_GetName(tm);
5371  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5372  GWEN_Buffer_AppendString(tbuf, s+1);
5373  GWEN_Buffer_AppendString(tbuf, "(const ");
5374  s=Typemaker2_Type_GetIdentifier(ty);
5375  GWEN_Buffer_AppendString(tbuf, s);
5376  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, ");
5377  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5378  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5379  GWEN_Buffer_AppendString(tbuf, " const ");
5380  s=Typemaker2_Type_GetIdentifier(mty);
5381  GWEN_Buffer_AppendString(tbuf, s);
5382  GWEN_Buffer_AppendString(tbuf, " *");
5383  }
5384  else {
5385  s=Typemaker2_Type_GetIdentifier(mty);
5386  GWEN_Buffer_AppendString(tbuf, s);
5387  GWEN_Buffer_AppendString(tbuf, " ");
5388  }
5389  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5390 
5391  GWEN_Buffer_AppendString(tbuf, " ");
5392  s=Typemaker2_Type_GetIdentifier(ty);
5393  GWEN_Buffer_AppendString(tbuf, s);
5394  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5395  GWEN_Buffer_AppendString(tbuf, "\n");
5396 
5397  GWEN_Buffer_AppendString(tbuf, " assert(p_list);\n");
5398  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5399  s=Typemaker2_Type_GetPrefix(ty);
5400  GWEN_Buffer_AppendString(tbuf, s);
5401  GWEN_Buffer_AppendString(tbuf, "_List_First(p_list);\n");
5402  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5403  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5404  GWEN_Buffer_AppendString(tbuf, "\n");
5405 
5406  GWEN_Buffer_AppendString(tbuf, " ");
5407  if (1) {
5408  GWEN_BUFFER *dstbuf;
5409  GWEN_BUFFER *srcbuf;
5410  int rv;
5411 
5412  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5413  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5414 
5415  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5416  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5417  s=Typemaker2_Member_GetName(tm);
5418  GWEN_Buffer_AppendString(dstbuf, s);
5419 
5420  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5421  GWEN_Buffer_GetStart(srcbuf),
5422  GWEN_Buffer_GetStart(dstbuf),
5423  tbuf);
5424  if (rv<0) {
5425  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5426  GWEN_Buffer_free(srcbuf);
5427  GWEN_Buffer_free(dstbuf);
5428  GWEN_Buffer_free(tbuf);
5429  return rv;
5430  }
5431  GWEN_Buffer_AppendString(tbuf, "\n");
5432  GWEN_Buffer_free(srcbuf);
5433  GWEN_Buffer_free(dstbuf);
5434  }
5435 
5436 
5437  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5438  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5439 
5440  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5441  s=Typemaker2_Type_GetPrefix(ty);
5442  GWEN_Buffer_AppendString(tbuf, s);
5443  GWEN_Buffer_AppendString(tbuf, "_List_Next(p_struct);\n");
5444 
5445  GWEN_Buffer_AppendString(tbuf, " }\n");
5446 
5447  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5448  GWEN_Buffer_AppendString(tbuf, "}\n");
5449 
5450  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5451  GWEN_Buffer_free(tbuf);
5452 
5453  return 0;
5454 }
5455 
5456 
5457 
5458 static int _buildTreeGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5459 {
5460  GWEN_BUFFER *tbuf;
5461  const char *s;
5462  /* uint32_t flags; */
5463  TYPEMAKER2_TYPEMANAGER *tym;
5464  TYPEMAKER2_TYPE *mty;
5465 
5466  tym=Typemaker2_Builder_GetTypeManager(tb);
5467  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5468 
5469  /* flags=Typemaker2_Type_GetFlags(ty); */
5470 
5471  mty=Typemaker2_Member_GetTypePtr(tm);
5472  assert(mty);
5473 
5474  /* prototype */
5475  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5476  if (s) {
5477  GWEN_Buffer_AppendString(tbuf, s);
5478  GWEN_Buffer_AppendString(tbuf, " ");
5479  }
5480 
5481  s=Typemaker2_Type_GetIdentifier(ty);
5482  GWEN_Buffer_AppendString(tbuf, s);
5483  GWEN_Buffer_AppendString(tbuf, " *");
5484 
5485  s=Typemaker2_Type_GetPrefix(ty);
5486  GWEN_Buffer_AppendString(tbuf, s);
5487  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5488  GWEN_Buffer_AppendString(tbuf, "By");
5489  s=Typemaker2_Member_GetName(tm);
5490  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5491  GWEN_Buffer_AppendString(tbuf, s+1);
5492  GWEN_Buffer_AppendString(tbuf, "(const ");
5493  s=Typemaker2_Type_GetIdentifier(ty);
5494  GWEN_Buffer_AppendString(tbuf, s);
5495  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5496  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5497  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5498  GWEN_Buffer_AppendString(tbuf, " const ");
5499  s=Typemaker2_Type_GetIdentifier(mty);
5500  GWEN_Buffer_AppendString(tbuf, s);
5501  GWEN_Buffer_AppendString(tbuf, " *");
5502  }
5503  else {
5504  s=Typemaker2_Type_GetIdentifier(mty);
5505  GWEN_Buffer_AppendString(tbuf, s);
5506  GWEN_Buffer_AppendString(tbuf, " ");
5507  }
5508  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5509 
5510  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5511  GWEN_Buffer_Reset(tbuf);
5512 
5513  /* implementation */
5514  s=Typemaker2_Type_GetIdentifier(ty);
5515  GWEN_Buffer_AppendString(tbuf, s);
5516  GWEN_Buffer_AppendString(tbuf, " *");
5517 
5518  s=Typemaker2_Type_GetPrefix(ty);
5519  GWEN_Buffer_AppendString(tbuf, s);
5520  GWEN_Buffer_AppendString(tbuf, "_Tree_Get");
5521  GWEN_Buffer_AppendString(tbuf, "By");
5522  s=Typemaker2_Member_GetName(tm);
5523  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5524  GWEN_Buffer_AppendString(tbuf, s+1);
5525  GWEN_Buffer_AppendString(tbuf, "(const ");
5526  s=Typemaker2_Type_GetIdentifier(ty);
5527  GWEN_Buffer_AppendString(tbuf, s);
5528  GWEN_Buffer_AppendString(tbuf, "_TREE *p_tree, ");
5529  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5530  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5531  GWEN_Buffer_AppendString(tbuf, " const ");
5532  s=Typemaker2_Type_GetIdentifier(mty);
5533  GWEN_Buffer_AppendString(tbuf, s);
5534  GWEN_Buffer_AppendString(tbuf, " *");
5535  }
5536  else {
5537  s=Typemaker2_Type_GetIdentifier(mty);
5538  GWEN_Buffer_AppendString(tbuf, s);
5539  GWEN_Buffer_AppendString(tbuf, " ");
5540  }
5541  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5542 
5543  GWEN_Buffer_AppendString(tbuf, " ");
5544  s=Typemaker2_Type_GetIdentifier(ty);
5545  GWEN_Buffer_AppendString(tbuf, s);
5546  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5547  GWEN_Buffer_AppendString(tbuf, "\n");
5548 
5549  GWEN_Buffer_AppendString(tbuf, " assert(p_tree);\n");
5550  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5551  s=Typemaker2_Type_GetPrefix(ty);
5552  GWEN_Buffer_AppendString(tbuf, s);
5553  GWEN_Buffer_AppendString(tbuf, "_Tree_GetFirst(p_tree);\n");
5554  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5555  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5556  GWEN_Buffer_AppendString(tbuf, "\n");
5557 
5558  GWEN_Buffer_AppendString(tbuf, " ");
5559  if (1) {
5560  GWEN_BUFFER *dstbuf;
5561  GWEN_BUFFER *srcbuf;
5562  int rv;
5563 
5564  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5565  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5566 
5567  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5568  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5569  s=Typemaker2_Member_GetName(tm);
5570  GWEN_Buffer_AppendString(dstbuf, s);
5571 
5572  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5573  GWEN_Buffer_GetStart(srcbuf),
5574  GWEN_Buffer_GetStart(dstbuf),
5575  tbuf);
5576  if (rv<0) {
5577  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5578  GWEN_Buffer_free(srcbuf);
5579  GWEN_Buffer_free(dstbuf);
5580  GWEN_Buffer_free(tbuf);
5581  return rv;
5582  }
5583  GWEN_Buffer_AppendString(tbuf, "\n");
5584  GWEN_Buffer_free(srcbuf);
5585  GWEN_Buffer_free(dstbuf);
5586  }
5587 
5588 
5589  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5590  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5591 
5592  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5593  s=Typemaker2_Type_GetPrefix(ty);
5594  GWEN_Buffer_AppendString(tbuf, s);
5595  GWEN_Buffer_AppendString(tbuf, "_Tree_GetBelow(p_struct);\n");
5596 
5597  GWEN_Buffer_AppendString(tbuf, " }\n");
5598 
5599  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5600  GWEN_Buffer_AppendString(tbuf, "}\n");
5601 
5602  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5603  GWEN_Buffer_free(tbuf);
5604 
5605  return 0;
5606 }
5607 
5608 
5609 
5610 static int _buildTree2GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5611 {
5612  GWEN_BUFFER *tbuf;
5613  const char *s;
5614  /* uint32_t flags; */
5615  TYPEMAKER2_TYPEMANAGER *tym;
5616  TYPEMAKER2_TYPE *mty;
5617 
5618  tym=Typemaker2_Builder_GetTypeManager(tb);
5619  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5620 
5621  /* flags=Typemaker2_Type_GetFlags(ty); */
5622 
5623  mty=Typemaker2_Member_GetTypePtr(tm);
5624  assert(mty);
5625 
5626  /* prototype */
5627  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5628  if (s) {
5629  GWEN_Buffer_AppendString(tbuf, s);
5630  GWEN_Buffer_AppendString(tbuf, " ");
5631  }
5632 
5633  s=Typemaker2_Type_GetIdentifier(ty);
5634  GWEN_Buffer_AppendString(tbuf, s);
5635  GWEN_Buffer_AppendString(tbuf, " *");
5636 
5637  s=Typemaker2_Type_GetPrefix(ty);
5638  GWEN_Buffer_AppendString(tbuf, s);
5639  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5640  GWEN_Buffer_AppendString(tbuf, "By");
5641  s=Typemaker2_Member_GetName(tm);
5642  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5643  GWEN_Buffer_AppendString(tbuf, s+1);
5644  GWEN_Buffer_AppendString(tbuf, "(const ");
5645  s=Typemaker2_Type_GetIdentifier(ty);
5646  GWEN_Buffer_AppendString(tbuf, s);
5647  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5648  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5649  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5650  GWEN_Buffer_AppendString(tbuf, " const ");
5651  s=Typemaker2_Type_GetIdentifier(mty);
5652  GWEN_Buffer_AppendString(tbuf, s);
5653  GWEN_Buffer_AppendString(tbuf, " *");
5654  }
5655  else {
5656  s=Typemaker2_Type_GetIdentifier(mty);
5657  GWEN_Buffer_AppendString(tbuf, s);
5658  GWEN_Buffer_AppendString(tbuf, " ");
5659  }
5660  GWEN_Buffer_AppendString(tbuf, "p_cmp);\n");
5661 
5662  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5663  GWEN_Buffer_Reset(tbuf);
5664 
5665  /* implementation */
5666  s=Typemaker2_Type_GetIdentifier(ty);
5667  GWEN_Buffer_AppendString(tbuf, s);
5668  GWEN_Buffer_AppendString(tbuf, " *");
5669 
5670  s=Typemaker2_Type_GetPrefix(ty);
5671  GWEN_Buffer_AppendString(tbuf, s);
5672  GWEN_Buffer_AppendString(tbuf, "_Tree2_Get");
5673  GWEN_Buffer_AppendString(tbuf, "By");
5674  s=Typemaker2_Member_GetName(tm);
5675  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5676  GWEN_Buffer_AppendString(tbuf, s+1);
5677  GWEN_Buffer_AppendString(tbuf, "(const ");
5678  s=Typemaker2_Type_GetIdentifier(ty);
5679  GWEN_Buffer_AppendString(tbuf, s);
5680  GWEN_Buffer_AppendString(tbuf, " *p_object, ");
5681  if (Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Pointer ||
5682  Typemaker2_Type_GetType(mty)==TypeMaker2_Type_Array) {
5683  GWEN_Buffer_AppendString(tbuf, " const ");
5684  s=Typemaker2_Type_GetIdentifier(mty);
5685  GWEN_Buffer_AppendString(tbuf, s);
5686  GWEN_Buffer_AppendString(tbuf, " *");
5687  }
5688  else {
5689  s=Typemaker2_Type_GetIdentifier(mty);
5690  GWEN_Buffer_AppendString(tbuf, s);
5691  GWEN_Buffer_AppendString(tbuf, " ");
5692  }
5693  GWEN_Buffer_AppendString(tbuf, "p_cmp) {\n");
5694 
5695  GWEN_Buffer_AppendString(tbuf, " ");
5696  s=Typemaker2_Type_GetIdentifier(ty);
5697  GWEN_Buffer_AppendString(tbuf, s);
5698  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
5699  GWEN_Buffer_AppendString(tbuf, "\n");
5700 
5701  GWEN_Buffer_AppendString(tbuf, " assert(p_object);\n");
5702  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5703  s=Typemaker2_Type_GetPrefix(ty);
5704  GWEN_Buffer_AppendString(tbuf, s);
5705  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetFirstChild(p_object);\n");
5706  GWEN_Buffer_AppendString(tbuf, " while(p_struct) {\n");
5707  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5708  GWEN_Buffer_AppendString(tbuf, "\n");
5709 
5710  GWEN_Buffer_AppendString(tbuf, " ");
5711  if (1) {
5712  GWEN_BUFFER *dstbuf;
5713  GWEN_BUFFER *srcbuf;
5714  int rv;
5715 
5716  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5717  GWEN_Buffer_AppendString(srcbuf, "p_cmp");
5718 
5719  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5720  GWEN_Buffer_AppendString(dstbuf, "p_struct->");
5721  s=Typemaker2_Member_GetName(tm);
5722  GWEN_Buffer_AppendString(dstbuf, s);
5723 
5724  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5725  GWEN_Buffer_GetStart(srcbuf),
5726  GWEN_Buffer_GetStart(dstbuf),
5727  tbuf);
5728  if (rv<0) {
5729  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5730  GWEN_Buffer_free(srcbuf);
5731  GWEN_Buffer_free(dstbuf);
5732  GWEN_Buffer_free(tbuf);
5733  return rv;
5734  }
5735  GWEN_Buffer_AppendString(tbuf, "\n");
5736  GWEN_Buffer_free(srcbuf);
5737  GWEN_Buffer_free(dstbuf);
5738  }
5739 
5740 
5741  GWEN_Buffer_AppendString(tbuf, " if (p_rv == 0)\n");
5742  GWEN_Buffer_AppendString(tbuf, " return p_struct;\n");
5743 
5744  GWEN_Buffer_AppendString(tbuf, " p_struct = ");
5745  s=Typemaker2_Type_GetPrefix(ty);
5746  GWEN_Buffer_AppendString(tbuf, s);
5747  GWEN_Buffer_AppendString(tbuf, "_Tree2_GetBelow(p_struct);\n");
5748 
5749  GWEN_Buffer_AppendString(tbuf, " }\n");
5750 
5751  GWEN_Buffer_AppendString(tbuf, " return NULL;\n");
5752  GWEN_Buffer_AppendString(tbuf, "}\n");
5753 
5754  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5755  GWEN_Buffer_free(tbuf);
5756 
5757  return 0;
5758 }
5759 
5760 
5761 
5762 static int _buildGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
5763 {
5764  GWEN_BUFFER *tbuf;
5765  TYPEMAKER2_MEMBER_LIST *tml;
5766  uint32_t flags;
5767  /* TYPEMAKER2_TYPEMANAGER *tym; */
5768 
5769  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
5770  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5771 
5772  flags=Typemaker2_Type_GetFlags(ty);
5773 
5774  tml=Typemaker2_Type_GetMembers(ty);
5775  if (tml) {
5776  TYPEMAKER2_MEMBER *tm;
5777 
5778  tm=Typemaker2_Member_List_First(tml);
5779  while (tm) {
5780  TYPEMAKER2_TYPE *mty;
5781  int rv;
5782 
5783  mty=Typemaker2_Member_GetTypePtr(tm);
5784  assert(mty);
5785 
5786  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_GETBYMEMBER) {
5787  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
5788  rv=_buildList1GetByMember(tb, ty, tm);
5789  if (rv<0) {
5790  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5791  return rv;
5792  }
5793  }
5794 
5795  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE) {
5796  rv=_buildTreeGetByMember(tb, ty, tm);
5797  if (rv<0) {
5798  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5799  return rv;
5800  }
5801  }
5802 
5803  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_TREE2) {
5804  rv=_buildTree2GetByMember(tb, ty, tm);
5805  if (rv<0) {
5806  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5807  return rv;
5808  }
5809  }
5810 
5811  }
5812  tm=Typemaker2_Member_List_Next(tm);
5813  }
5814  GWEN_Buffer_AppendString(tbuf, " return p_cl;\n");
5815  }
5816 
5817  return 0;
5818 }
5819 
5820 
5821 
5822 static int _buildList1SortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
5823 {
5824  GWEN_BUFFER *tbuf;
5825  const char *s;
5826  /* uint32_t flags; */
5827  TYPEMAKER2_TYPEMANAGER *tym;
5828  TYPEMAKER2_TYPE *mty;
5829 
5830  tym=Typemaker2_Builder_GetTypeManager(tb);
5831  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
5832 
5833  /* flags=Typemaker2_Type_GetFlags(ty); */
5834 
5835  mty=Typemaker2_Member_GetTypePtr(tm);
5836  assert(mty);
5837 
5838  /* ==== prototypes ========================================================*/
5839  /* ---- _List_SortByMember ----------------------------------------------- */
5840  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
5841  if (s) {
5842  GWEN_Buffer_AppendString(tbuf, s);
5843  GWEN_Buffer_AppendString(tbuf, " ");
5844  }
5845 
5846  /* return type */
5847  GWEN_Buffer_AppendString(tbuf, "void ");
5848 
5849  /* function name */
5850  s=Typemaker2_Type_GetPrefix(ty);
5851  GWEN_Buffer_AppendString(tbuf, s);
5852  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5853  s=Typemaker2_Member_GetName(tm);
5854  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5855  GWEN_Buffer_AppendString(tbuf, s+1);
5856 
5857  /* argument list */
5858  GWEN_Buffer_AppendString(tbuf, "(");
5859  s=Typemaker2_Type_GetIdentifier(ty);
5860  GWEN_Buffer_AppendString(tbuf, s);
5861  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending);\n");
5862 
5863  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5864  GWEN_Buffer_Reset(tbuf);
5865 
5866 
5867  /* ---- _List_Compare_Member --------------------------------------------- */
5868  /* return type */
5869  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5870 
5871  /* function name */
5872  s=Typemaker2_Type_GetPrefix(ty);
5873  GWEN_Buffer_AppendString(tbuf, s);
5874  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5875  s=Typemaker2_Member_GetName(tm);
5876  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5877  GWEN_Buffer_AppendString(tbuf, s+1);
5878 
5879  /* argument list */
5880  GWEN_Buffer_AppendString(tbuf, "(const ");
5881  s=Typemaker2_Type_GetIdentifier(ty);
5882  GWEN_Buffer_AppendString(tbuf, s);
5883  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5884  GWEN_Buffer_AppendString(tbuf, "const ");
5885  GWEN_Buffer_AppendString(tbuf, s);
5886  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5887  GWEN_Buffer_AppendString(tbuf, "int p_ascending);\n");
5888 
5889  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
5890  GWEN_Buffer_Reset(tbuf);
5891 
5892 
5893  /* ==== implementations =================================================== */
5894  /* ---- _List_SortByMember ----------------------------------------------- */
5895  /* return type */
5896  GWEN_Buffer_AppendString(tbuf, "void ");
5897 
5898  /* function name */
5899  s=Typemaker2_Type_GetPrefix(ty);
5900  GWEN_Buffer_AppendString(tbuf, s);
5901  GWEN_Buffer_AppendString(tbuf, "_List_SortBy");
5902  s=Typemaker2_Member_GetName(tm);
5903  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5904  GWEN_Buffer_AppendString(tbuf, s+1);
5905 
5906  /* argument list */
5907  GWEN_Buffer_AppendString(tbuf, "(");
5908  s=Typemaker2_Type_GetIdentifier(ty);
5909  GWEN_Buffer_AppendString(tbuf, s);
5910  GWEN_Buffer_AppendString(tbuf, "_LIST *p_list, int p_ascending) {\n");
5911 
5912 
5913  GWEN_Buffer_AppendString(tbuf, " ");
5914 
5915  s=Typemaker2_Type_GetIdentifier(ty);
5916  GWEN_Buffer_AppendString(tbuf, s);
5917  GWEN_Buffer_AppendString(tbuf, "_LIST_SORT_FN oldSortFn;\n");
5918 
5919  GWEN_Buffer_AppendString(tbuf, "\n");
5920  GWEN_Buffer_AppendString(tbuf, " oldSortFn=");
5921  s=Typemaker2_Type_GetPrefix(ty);
5922  GWEN_Buffer_AppendString(tbuf, s);
5923  GWEN_Buffer_AppendString(tbuf, "_List_SetSortFn(p_list, ");
5924 
5925  s=Typemaker2_Type_GetPrefix(ty);
5926  GWEN_Buffer_AppendString(tbuf, s);
5927  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5928  s=Typemaker2_Member_GetName(tm);
5929  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5930  GWEN_Buffer_AppendString(tbuf, s+1);
5931  GWEN_Buffer_AppendString(tbuf, ");\n");
5932 
5933  GWEN_Buffer_AppendString(tbuf, " ");
5934  s=Typemaker2_Type_GetPrefix(ty);
5935  GWEN_Buffer_AppendString(tbuf, s);
5936  GWEN_Buffer_AppendString(tbuf, "_List_Sort(p_list, p_ascending);\n");
5937 
5938  GWEN_Buffer_AppendString(tbuf, " ");
5939  s=Typemaker2_Type_GetPrefix(ty);
5940  GWEN_Buffer_AppendString(tbuf, s);
5941  GWEN_Buffer_AppendString(tbuf, "_List_SetSortFn(p_list, oldSortFn);\n");
5942 
5943  GWEN_Buffer_AppendString(tbuf, "}\n");
5944 
5945  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
5946  GWEN_Buffer_Reset(tbuf);
5947 
5948 
5949  /* ---- _List_Compare_Member --------------------------------------------- */
5950  /* return type */
5951  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
5952 
5953  /* function name */
5954  s=Typemaker2_Type_GetPrefix(ty);
5955  GWEN_Buffer_AppendString(tbuf, s);
5956  GWEN_Buffer_AppendString(tbuf, "_List_Compare_");
5957  s=Typemaker2_Member_GetName(tm);
5958  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
5959  GWEN_Buffer_AppendString(tbuf, s+1);
5960 
5961  /* argument list */
5962  GWEN_Buffer_AppendString(tbuf, "(const ");
5963  s=Typemaker2_Type_GetIdentifier(ty);
5964  GWEN_Buffer_AppendString(tbuf, s);
5965  GWEN_Buffer_AppendString(tbuf, " *p_a, ");
5966  GWEN_Buffer_AppendString(tbuf, "const ");
5967  GWEN_Buffer_AppendString(tbuf, s);
5968  GWEN_Buffer_AppendString(tbuf, " *p_b, ");
5969  GWEN_Buffer_AppendString(tbuf, "int p_ascending) {\n");
5970 
5971  GWEN_Buffer_AppendString(tbuf, " int p_rv;\n");
5972  GWEN_Buffer_AppendString(tbuf, "\n");
5973 
5974  if (1) {
5975  GWEN_BUFFER *dstbuf;
5976  GWEN_BUFFER *srcbuf;
5977  int rv;
5978 
5979  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
5980  GWEN_Buffer_AppendString(srcbuf, "p_a->");
5981  s=Typemaker2_Member_GetName(tm);
5982  GWEN_Buffer_AppendString(srcbuf, s);
5983 
5984 
5985  dstbuf=GWEN_Buffer_new(0, 256, 0, 1);
5986  GWEN_Buffer_AppendString(dstbuf, "p_b->");
5987  s=Typemaker2_Member_GetName(tm);
5988  GWEN_Buffer_AppendString(dstbuf, s);
5989 
5990  rv=Typemaker2_Builder_Invoke_CompareFn(tb, ty, tm,
5991  GWEN_Buffer_GetStart(srcbuf),
5992  GWEN_Buffer_GetStart(dstbuf),
5993  tbuf);
5994  if (rv<0) {
5995  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
5996  GWEN_Buffer_free(srcbuf);
5997  GWEN_Buffer_free(dstbuf);
5998  GWEN_Buffer_free(tbuf);
5999  return rv;
6000  }
6001  GWEN_Buffer_AppendString(tbuf, "\n");
6002  GWEN_Buffer_free(srcbuf);
6003  GWEN_Buffer_free(dstbuf);
6004  }
6005 
6006  GWEN_Buffer_AppendString(tbuf, " if (p_ascending)\n");
6007  GWEN_Buffer_AppendString(tbuf, " return p_rv;\n");
6008  GWEN_Buffer_AppendString(tbuf, " else\n");
6009  GWEN_Buffer_AppendString(tbuf, " return -p_rv;\n");
6010  GWEN_Buffer_AppendString(tbuf, "}\n");
6011 
6012  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6013  GWEN_Buffer_free(tbuf);
6014 
6015  return 0;
6016 }
6017 
6018 
6019 
6020 static int _buildSortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6021 {
6022  TYPEMAKER2_MEMBER_LIST *tml;
6023  uint32_t flags;
6024  /* TYPEMAKER2_TYPEMANAGER *tym; */
6025 
6026  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6027 
6028  flags=Typemaker2_Type_GetFlags(ty);
6029 
6030  tml=Typemaker2_Type_GetMembers(ty);
6031  if (tml) {
6032  TYPEMAKER2_MEMBER *tm;
6033 
6034  tm=Typemaker2_Member_List_First(tml);
6035  while (tm) {
6036  TYPEMAKER2_TYPE *mty;
6037  int rv;
6038 
6039  mty=Typemaker2_Member_GetTypePtr(tm);
6040  assert(mty);
6041 
6042  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_SORTBYMEMBER) {
6043  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
6044  rv=_buildList1SortByMember(tb, ty, tm);
6045  if (rv<0) {
6046  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6047  return rv;
6048  }
6049  }
6050  }
6051  tm=Typemaker2_Member_List_Next(tm);
6052  }
6053  }
6054 
6055  return 0;
6056 }
6057 
6058 
6059 
6060 static int _buildDefineDefines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6061 {
6062  TYPEMAKER2_DEFINE_LIST *defines;
6063  /* TYPEMAKER2_TYPEMANAGER *tym; */
6064  /* uint32_t flags; */
6065 
6066  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6067  defines=Typemaker2_Type_GetDefines(ty);
6068  /* flags=Typemaker2_Type_GetFlags(ty); */
6069 
6070  assert(defines);
6071  if (Typemaker2_Define_List_GetCount(defines)) {
6072  GWEN_BUFFER *tbuf;
6073  const char *s;
6074  TYPEMAKER2_DEFINE *td;
6075 
6076  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6077 
6078  td=Typemaker2_Define_List_First(defines);
6079  while (td) {
6080  const char *prefix;
6081  TYPEMAKER2_ITEM *ti;
6082  int access=TypeMaker2_Access_Public;
6083  int j=Typemaker2_Define_GetStartValue(td);
6084 
6085  GWEN_Buffer_AppendString(tbuf, "/* define ");
6086  s=Typemaker2_Define_GetId(td);
6087  if (s && *s)
6088  GWEN_Buffer_AppendString(tbuf, s);
6089  GWEN_Buffer_AppendString(tbuf, " */\n");
6090 
6091  prefix=Typemaker2_Define_GetPrefix(td);
6092  if (prefix==NULL || *prefix==0) {
6093  DBG_ERROR(GWEN_LOGDOMAIN, "No prefix in define definition");
6094  GWEN_Buffer_free(tbuf);
6095  return GWEN_ERROR_BAD_DATA;
6096  }
6097 
6098  ti=Typemaker2_Item_List_First(Typemaker2_Define_GetItems(td));
6099  while (ti) {
6100  GWEN_Buffer_AppendString(tbuf, "#define ");
6101  if (prefix)
6102  GWEN_Buffer_AppendString(tbuf, prefix);
6103  s=Typemaker2_Item_GetName(ti);
6104  if (s && *s) {
6105  GWEN_Buffer_AppendString(tbuf, s);
6106  }
6107  s=Typemaker2_Item_GetValue(ti);
6108  if (s) {
6109  GWEN_Buffer_AppendString(tbuf, " ");
6110  GWEN_Buffer_AppendString(tbuf, s);
6111  }
6112  else {
6113  char numbuf[32];
6114  int k=0;
6115 
6116  switch (Typemaker2_Define_GetMode(td)) {
6117  case Typemaker2_Define_Mode_BitField:
6118  k=1<<j;
6119  break;
6120  case Typemaker2_Define_Mode_Sequence:
6121  default:
6122  k=j;
6123  }
6124  snprintf(numbuf, sizeof(numbuf)-1, "%d", k);
6125  numbuf[sizeof(numbuf)-1]=0;
6126  GWEN_Buffer_AppendString(tbuf, " ");
6127  GWEN_Buffer_AppendString(tbuf, numbuf);
6128  j++;
6129  }
6130 
6131  GWEN_Buffer_AppendString(tbuf, "\n");
6132  ti=Typemaker2_Item_List_Next(ti);
6133  }
6134  GWEN_Buffer_AppendString(tbuf, "\n");
6135 
6136  switch (access) {
6137  case TypeMaker2_Access_Public:
6138  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6139  break;
6140  case TypeMaker2_Access_Library:
6141  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6142  break;
6143  case TypeMaker2_Access_Protected:
6144  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6145  break;
6146  case TypeMaker2_Access_Private:
6147  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6148  break;
6149  default:
6150  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6151  GWEN_Buffer_free(tbuf);
6152  return GWEN_ERROR_BAD_DATA;
6153  }
6154  GWEN_Buffer_Reset(tbuf);
6155 
6156  td=Typemaker2_Define_List_Next(td);
6157  }
6158  }
6159  return 0;
6160 }
6161 
6162 
6163 
6164 static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6165 {
6166  GWEN_BUFFER *tbuf;
6167  const char *s;
6168  /* uint32_t flags; */
6169  TYPEMAKER2_TYPEMANAGER *tym;
6170  TYPEMAKER2_MEMBER_LIST *tml;
6171 
6172  tym=Typemaker2_Builder_GetTypeManager(tb);
6173  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6174 
6175  /* flags=Typemaker2_Type_GetFlags(ty); */
6176 
6177  /* prototype */
6178  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6179  if (s) {
6180  GWEN_Buffer_AppendString(tbuf, s);
6181  GWEN_Buffer_AppendString(tbuf, " ");
6182  }
6183 
6184  GWEN_Buffer_AppendString(tbuf, "void ");
6185  s=Typemaker2_Type_GetPrefix(ty);
6186  GWEN_Buffer_AppendString(tbuf, s);
6187  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6188  GWEN_Buffer_AppendString(tbuf, "(const ");
6189  s=Typemaker2_Type_GetIdentifier(ty);
6190  GWEN_Buffer_AppendString(tbuf, s);
6191  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer);\n");
6192 
6193  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6194  GWEN_Buffer_Reset(tbuf);
6195 
6196  /* implementation */
6197  GWEN_Buffer_AppendString(tbuf, "void ");
6198  s=Typemaker2_Type_GetPrefix(ty);
6199  GWEN_Buffer_AppendString(tbuf, s);
6200  GWEN_Buffer_AppendString(tbuf, "_toHashString");
6201  GWEN_Buffer_AppendString(tbuf, "(const ");
6202  s=Typemaker2_Type_GetIdentifier(ty);
6203  GWEN_Buffer_AppendString(tbuf, s);
6204  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_BUFFER *p_buffer) {\n");
6205 
6206  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6207 
6208 
6209  tml=Typemaker2_Type_GetMembers(ty);
6210  if (tml) {
6211  TYPEMAKER2_MEMBER *tm;
6212 
6213  tm=Typemaker2_Member_List_First(tml);
6214  while (tm) {
6215  TYPEMAKER2_TYPE *mty;
6216 
6217  mty=Typemaker2_Member_GetTypePtr(tm);
6218  assert(mty);
6219 
6220  if (Typemaker2_Member_GetFlags(tm) & TYPEMAKER2_FLAGS_WITH_HASH) {
6221  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6222  s=Typemaker2_Member_GetName(tm);
6223  GWEN_Buffer_AppendString(tbuf, s);
6224  GWEN_Buffer_AppendString(tbuf, "\" */\n");
6225 
6226  /* toHashString */
6227  if (1) {
6228  GWEN_BUFFER *srcbuf;
6229  int rv;
6230 
6231  srcbuf=GWEN_Buffer_new(0, 256, 0, 1);
6232  GWEN_Buffer_AppendString(srcbuf, "p_struct->");
6233  s=Typemaker2_Member_GetName(tm);
6234  GWEN_Buffer_AppendString(srcbuf, s);
6235 
6236  GWEN_Buffer_AppendString(tbuf, " ");
6237  rv=Typemaker2_Builder_Invoke_ToHashStringFn(tb, ty, tm,
6238  GWEN_Buffer_GetStart(srcbuf),
6239  NULL, /* no dest */
6240  tbuf);
6241  if (rv<0) {
6242  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6243  GWEN_Buffer_free(srcbuf);
6244  GWEN_Buffer_free(tbuf);
6245  return rv;
6246  }
6247  GWEN_Buffer_AppendString(tbuf, "\n");
6248  GWEN_Buffer_free(srcbuf);
6249  }
6250 
6251  GWEN_Buffer_AppendString(tbuf, " GWEN_Buffer_AppendByte(p_buffer, \':\');\n");
6252  }
6253  else {
6254  GWEN_Buffer_AppendString(tbuf, " /* member \"");
6255  s=Typemaker2_Member_GetName(tm);
6256  GWEN_Buffer_AppendString(tbuf, s);
6257  GWEN_Buffer_AppendString(tbuf, "\" does not have the with_hash flag, ignoring */\n");
6258  }
6259 
6260  tm=Typemaker2_Member_List_Next(tm);
6261  }
6262  }
6263 
6264 
6265  GWEN_Buffer_AppendString(tbuf, "}\n");
6266 
6267  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6268  GWEN_Buffer_free(tbuf);
6269 
6270  return 0;
6271 }
6272 
6273 
6274 
6275 static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6276 {
6277  GWEN_BUFFER *tbuf;
6278  uint32_t flags;
6279  /* TYPEMAKER2_TYPEMANAGER *tym; */
6280 
6281  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6282  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6283 
6284  flags=Typemaker2_Type_GetFlags(ty);
6285 
6286  while (ty) {
6287  TYPEMAKER2_INLINE *ti;
6288 
6289  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(ty));
6290  while (ti) {
6291  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6292  const char *content;
6293 
6294  content=Typemaker2_Inline_GetContent(ti);
6295  if (content && *content) {
6296  GWEN_DB_NODE *db;
6297  int rv;
6298 
6299  db=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
6300  assert(db);
6301  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6302  if (rv<0) {
6303  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6304  GWEN_Buffer_free(tbuf);
6305  return rv;
6306  }
6307 
6308  /* include code */
6309  switch (Typemaker2_Inline_GetLocation(ti)) {
6310  case Typemaker2_InlineLocation_Header:
6311  switch (Typemaker2_Inline_GetAccess(ti)) {
6312  case TypeMaker2_Access_Public:
6313  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6314  break;
6315  case TypeMaker2_Access_Library:
6316  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6317  break;
6318  case TypeMaker2_Access_Protected:
6319  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6320  break;
6321  case TypeMaker2_Access_Private:
6322  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6323  break;
6324  default:
6325  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6326  GWEN_Buffer_free(tbuf);
6327  return GWEN_ERROR_BAD_DATA;
6328  }
6329  break;
6330 
6331  case Typemaker2_InlineLocation_Code:
6332  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6333  break;
6334  }
6335  }
6336  GWEN_Buffer_Reset(tbuf);
6337  }
6338 
6339  ti=Typemaker2_Inline_List_Next(ti);
6340  }
6341  ty=Typemaker2_Type_GetExtendsPtr(ty);
6342  }
6343 
6344  return 0;
6345 }
6346 
6347 
6348 
6349 static int _buildMemberInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6350 {
6351  GWEN_BUFFER *tbuf;
6352  uint32_t flags;
6353  /* TYPEMAKER2_TYPEMANAGER *tym; */
6354 
6355  /* tym=Typemaker2_Builder_GetTypeManager(tb); */
6356  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6357 
6358  flags=Typemaker2_Type_GetFlags(ty);
6359 
6360  while (ty) {
6361  TYPEMAKER2_MEMBER_LIST *tml;
6362 
6363  tml=Typemaker2_Type_GetMembers(ty);
6364  if (tml) {
6365  TYPEMAKER2_MEMBER *tm;
6366 
6367  tm=Typemaker2_Member_List_First(tml);
6368  while (tm) {
6369  TYPEMAKER2_TYPE *mty;
6370 
6371  mty=Typemaker2_Member_GetTypePtr(tm);
6372  if (mty) {
6373  TYPEMAKER2_INLINE *ti;
6374 
6375  /* get inlines from member type */
6376  ti=Typemaker2_Inline_List_First(Typemaker2_Type_GetInlines(mty));
6377  while (ti) {
6378  if ((flags & Typemaker2_Inline_GetTypeFlagsMask(ti))==Typemaker2_Inline_GetTypeFlagsValue(ti)) {
6379  const char *content;
6380 
6381  content=Typemaker2_Inline_GetContent(ti);
6382  if (content && *content) {
6383  GWEN_DB_NODE *db;
6384  int rv;
6385 
6386  /* replace vars in context of the struct type, not the particular member type */
6387  db=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
6388  assert(db);
6389  rv=Typemaker2_Builder_ReplaceVars(content, db, tbuf);
6390  if (rv<0) {
6391  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
6392  GWEN_Buffer_free(tbuf);
6393  return rv;
6394  }
6395 
6396  /* include code */
6397  switch (Typemaker2_Inline_GetLocation(ti)) {
6398  case Typemaker2_InlineLocation_Header:
6399  switch (Typemaker2_Inline_GetAccess(ti)) {
6400  case TypeMaker2_Access_Public:
6401  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6402  break;
6403  case TypeMaker2_Access_Library:
6404  Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6405  break;
6406  case TypeMaker2_Access_Protected:
6407  Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6408  break;
6409  case TypeMaker2_Access_Private:
6410  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6411  break;
6412  default:
6413  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
6414  GWEN_Buffer_free(tbuf);
6415  return GWEN_ERROR_BAD_DATA;
6416  }
6417  break;
6418 
6419  case Typemaker2_InlineLocation_Code:
6420  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6421  break;
6422  }
6423  }
6424  GWEN_Buffer_Reset(tbuf);
6425  }
6426 
6427  ti=Typemaker2_Inline_List_Next(ti);
6428  }
6429  } /* if mty */
6430 
6431  tm=Typemaker2_Member_List_Next(tm);
6432  } /* while tm */
6433  } /* if tml */
6434 
6435  ty=Typemaker2_Type_GetExtendsPtr(ty);
6436  }
6437 
6438  return 0;
6439 }
6440 
6441 
6442 
6443 static int _buildAttach(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6444 {
6445  GWEN_BUFFER *tbuf;
6446  const char *s;
6447  /* uint32_t flags; */
6448  TYPEMAKER2_TYPEMANAGER *tym;
6449 
6450  tym=Typemaker2_Builder_GetTypeManager(tb);
6451  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6452 
6453  /* flags=Typemaker2_Type_GetFlags(ty); */
6454 
6455  /* prototype */
6456  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6457  if (s) {
6458  GWEN_Buffer_AppendString(tbuf, s);
6459  GWEN_Buffer_AppendString(tbuf, " ");
6460  }
6461  GWEN_Buffer_AppendString(tbuf, "void ");
6462  s=Typemaker2_Type_GetPrefix(ty);
6463  GWEN_Buffer_AppendString(tbuf, s);
6464  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6465  s=Typemaker2_Type_GetIdentifier(ty);
6466  GWEN_Buffer_AppendString(tbuf, s);
6467  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6468 
6469  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6470  GWEN_Buffer_Reset(tbuf);
6471 
6472  /* implementation */
6473  GWEN_Buffer_AppendString(tbuf, "void ");
6474  s=Typemaker2_Type_GetPrefix(ty);
6475  GWEN_Buffer_AppendString(tbuf, s);
6476  GWEN_Buffer_AppendString(tbuf, "_Attach(");
6477  s=Typemaker2_Type_GetIdentifier(ty);
6478  GWEN_Buffer_AppendString(tbuf, s);
6479  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6480 
6481  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6482  GWEN_Buffer_AppendString(tbuf, " assert(p_struct->_refCount);\n");
6483  GWEN_Buffer_AppendString(tbuf, " p_struct->_refCount++;\n");
6484  GWEN_Buffer_AppendString(tbuf, "}\n");
6485 
6486  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6487  GWEN_Buffer_free(tbuf);
6488 
6489  return 0;
6490 }
6491 
6492 
6493 
6494 static int _buildSignalFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6495 {
6496  GWEN_BUFFER *tbuf;
6497  const char *s;
6498  /* uint32_t flags; */
6499  TYPEMAKER2_TYPEMANAGER *tym;
6500  TYPEMAKER2_SIGNAL_LIST *sigList;
6501 
6502  tym=Typemaker2_Builder_GetTypeManager(tb);
6503  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6504 
6505  /* flags=Typemaker2_Type_GetFlags(ty); */
6506 
6507  sigList=Typemaker2_Type_GetSignals(ty);
6508  if (sigList) {
6509  TYPEMAKER2_SIGNAL *sig;
6510 
6511  /* prototype */
6512  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6513  sig=Typemaker2_Signal_List_First(sigList);
6514  while (sig) {
6515 
6516  /* SignalConnect */
6517  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6518  if (s) {
6519  GWEN_Buffer_AppendString(tbuf, s);
6520  GWEN_Buffer_AppendString(tbuf, " ");
6521  }
6522  GWEN_Buffer_AppendString(tbuf, "int ");
6523  s=Typemaker2_Type_GetPrefix(ty);
6524  GWEN_Buffer_AppendString(tbuf, s);
6525  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6526  s=Typemaker2_Signal_GetName(sig);
6527  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6528  GWEN_Buffer_AppendString(tbuf, s+1);
6529  GWEN_Buffer_AppendString(tbuf, "(");
6530  s=Typemaker2_Type_GetIdentifier(ty);
6531  GWEN_Buffer_AppendString(tbuf, s);
6532  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6533 
6534  /* SignalDisconnect */
6535  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6536  if (s) {
6537  GWEN_Buffer_AppendString(tbuf, s);
6538  GWEN_Buffer_AppendString(tbuf, " ");
6539  }
6540  GWEN_Buffer_AppendString(tbuf, "int ");
6541  s=Typemaker2_Type_GetPrefix(ty);
6542  GWEN_Buffer_AppendString(tbuf, s);
6543  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6544  s=Typemaker2_Signal_GetName(sig);
6545  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6546  GWEN_Buffer_AppendString(tbuf, s+1);
6547  GWEN_Buffer_AppendString(tbuf, "(");
6548  s=Typemaker2_Type_GetIdentifier(ty);
6549  GWEN_Buffer_AppendString(tbuf, s);
6550  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot);\n");
6551 
6552  /* GetSignal */
6553  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6554  if (s) {
6555  GWEN_Buffer_AppendString(tbuf, s);
6556  GWEN_Buffer_AppendString(tbuf, " ");
6557  }
6558  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6559  s=Typemaker2_Type_GetPrefix(ty);
6560  GWEN_Buffer_AppendString(tbuf, s);
6561  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6562  s=Typemaker2_Signal_GetName(sig);
6563  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6564  GWEN_Buffer_AppendString(tbuf, s+1);
6565  GWEN_Buffer_AppendString(tbuf, "(const ");
6566  s=Typemaker2_Type_GetIdentifier(ty);
6567  GWEN_Buffer_AppendString(tbuf, s);
6568  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6569 
6570 
6571  /* EmitSignal */
6572  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6573  if (s) {
6574  GWEN_Buffer_AppendString(tbuf, s);
6575  GWEN_Buffer_AppendString(tbuf, " ");
6576  }
6577  GWEN_Buffer_AppendString(tbuf, "int ");
6578  s=Typemaker2_Type_GetPrefix(ty);
6579  GWEN_Buffer_AppendString(tbuf, s);
6580  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6581  s=Typemaker2_Signal_GetName(sig);
6582  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6583  GWEN_Buffer_AppendString(tbuf, s+1);
6584  GWEN_Buffer_AppendString(tbuf, "(");
6585  s=Typemaker2_Type_GetIdentifier(ty);
6586  GWEN_Buffer_AppendString(tbuf, s);
6587  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6588  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6589  if (s && *s && strcasecmp(s, "none")) {
6590  GWEN_Buffer_AppendString(tbuf, ", ");
6591  GWEN_Buffer_AppendString(tbuf, s);
6592  GWEN_Buffer_AppendString(tbuf, " param1");
6593  }
6594  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6595  if (s && *s && strcasecmp(s, "none")) {
6596  GWEN_Buffer_AppendString(tbuf, ", ");
6597  GWEN_Buffer_AppendString(tbuf, s);
6598  GWEN_Buffer_AppendString(tbuf, " param2");
6599  }
6600  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6601  GWEN_Buffer_AppendString(tbuf, ", int param3");
6602  }
6603  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6604  GWEN_Buffer_AppendString(tbuf, ", int param4");
6605  }
6606  GWEN_Buffer_AppendString(tbuf, ");\n");
6607 
6608 
6609  sig=Typemaker2_Signal_List_Next(sig);
6610  }
6611  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6612  GWEN_Buffer_Reset(tbuf);
6613 
6614  /* implementation */
6615  GWEN_Buffer_AppendString(tbuf, "/* signal functions */\n");
6616  sig=Typemaker2_Signal_List_First(sigList);
6617  while (sig) {
6618 
6619  /* SignalConnect */
6620  GWEN_Buffer_AppendString(tbuf, "int ");
6621  s=Typemaker2_Type_GetPrefix(ty);
6622  GWEN_Buffer_AppendString(tbuf, s);
6623  GWEN_Buffer_AppendString(tbuf, "_SignalConnect_");
6624  s=Typemaker2_Signal_GetName(sig);
6625  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6626  GWEN_Buffer_AppendString(tbuf, s+1);
6627  GWEN_Buffer_AppendString(tbuf, "(");
6628  s=Typemaker2_Type_GetIdentifier(ty);
6629  GWEN_Buffer_AppendString(tbuf, s);
6630  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6631 
6632  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6633  GWEN_Buffer_AppendString(tbuf, "\n");
6634  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6635  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6636  s=Typemaker2_Signal_GetName(sig); /* name */
6637  GWEN_Buffer_AppendString(tbuf, "\"");
6638  GWEN_Buffer_AppendString(tbuf, s);
6639  GWEN_Buffer_AppendString(tbuf, "\", ");
6640  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6641  GWEN_Buffer_AppendString(tbuf, "\"");
6642  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6643  GWEN_Buffer_AppendString(tbuf, "\", ");
6644  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6645  GWEN_Buffer_AppendString(tbuf, "\"");
6646  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6647  GWEN_Buffer_AppendString(tbuf, "\");\n");
6648  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6649  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Connect(sig, slot);\n");
6650  GWEN_Buffer_AppendString(tbuf, " else\n");
6651  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6652 
6653  GWEN_Buffer_AppendString(tbuf, "}\n");
6654  GWEN_Buffer_AppendString(tbuf, "\n");
6655 
6656  /* SignalDisconnect */
6657  GWEN_Buffer_AppendString(tbuf, "int ");
6658  s=Typemaker2_Type_GetPrefix(ty);
6659  GWEN_Buffer_AppendString(tbuf, s);
6660  GWEN_Buffer_AppendString(tbuf, "_SignalDisconnect_");
6661  s=Typemaker2_Signal_GetName(sig);
6662  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6663  GWEN_Buffer_AppendString(tbuf, s+1);
6664  GWEN_Buffer_AppendString(tbuf, "(");
6665  s=Typemaker2_Type_GetIdentifier(ty);
6666  GWEN_Buffer_AppendString(tbuf, s);
6667  GWEN_Buffer_AppendString(tbuf, " *p_struct, GWEN_SLOT *slot) {\n");
6668 
6669  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6670  GWEN_Buffer_AppendString(tbuf, "\n");
6671  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6672  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6673  s=Typemaker2_Signal_GetName(sig); /* name */
6674  GWEN_Buffer_AppendString(tbuf, "\"");
6675  GWEN_Buffer_AppendString(tbuf, s);
6676  GWEN_Buffer_AppendString(tbuf, "\", ");
6677  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6678  GWEN_Buffer_AppendString(tbuf, "\"");
6679  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6680  GWEN_Buffer_AppendString(tbuf, "\", ");
6681  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6682  GWEN_Buffer_AppendString(tbuf, "\"");
6683  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6684  GWEN_Buffer_AppendString(tbuf, "\");\n");
6685  GWEN_Buffer_AppendString(tbuf, " if (sig)\n");
6686  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Disconnect(sig, slot);\n");
6687  GWEN_Buffer_AppendString(tbuf, " else\n");
6688  GWEN_Buffer_AppendString(tbuf, " return GWEN_ERROR_NOT_FOUND;\n");
6689 
6690  GWEN_Buffer_AppendString(tbuf, "}\n");
6691  GWEN_Buffer_AppendString(tbuf, "\n");
6692 
6693 
6694  /* GetSignal */
6695  GWEN_Buffer_AppendString(tbuf, "GWEN_SIGNAL *");
6696  s=Typemaker2_Type_GetPrefix(ty);
6697  GWEN_Buffer_AppendString(tbuf, s);
6698  GWEN_Buffer_AppendString(tbuf, "_GetSignal_");
6699  s=Typemaker2_Signal_GetName(sig);
6700  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6701  GWEN_Buffer_AppendString(tbuf, s+1);
6702  GWEN_Buffer_AppendString(tbuf, "(const ");
6703  s=Typemaker2_Type_GetIdentifier(ty);
6704  GWEN_Buffer_AppendString(tbuf, s);
6705  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6706 
6707  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6708  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6709  s=Typemaker2_Signal_GetName(sig); /* name */
6710  GWEN_Buffer_AppendString(tbuf, "\"");
6711  GWEN_Buffer_AppendString(tbuf, s);
6712  GWEN_Buffer_AppendString(tbuf, "\", ");
6713  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6714  GWEN_Buffer_AppendString(tbuf, "\"");
6715  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6716  GWEN_Buffer_AppendString(tbuf, "\", ");
6717  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6718  GWEN_Buffer_AppendString(tbuf, "\"");
6719  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6720  GWEN_Buffer_AppendString(tbuf, "\");\n");
6721 
6722  GWEN_Buffer_AppendString(tbuf, "}\n");
6723  GWEN_Buffer_AppendString(tbuf, "\n");
6724 
6725 
6726  /* EmitSignal */
6727  GWEN_Buffer_AppendString(tbuf, "int ");
6728  s=Typemaker2_Type_GetPrefix(ty);
6729  GWEN_Buffer_AppendString(tbuf, s);
6730  GWEN_Buffer_AppendString(tbuf, "_EmitSignal_");
6731  s=Typemaker2_Signal_GetName(sig);
6732  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6733  GWEN_Buffer_AppendString(tbuf, s+1);
6734  GWEN_Buffer_AppendString(tbuf, "(");
6735  s=Typemaker2_Type_GetIdentifier(ty);
6736  GWEN_Buffer_AppendString(tbuf, s);
6737  GWEN_Buffer_AppendString(tbuf, " *p_struct");
6738  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6739  if (s && *s && strcasecmp(s, "none")) {
6740  GWEN_Buffer_AppendString(tbuf, ", ");
6741  GWEN_Buffer_AppendString(tbuf, s);
6742  GWEN_Buffer_AppendString(tbuf, " param1");
6743  }
6744  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6745  if (s && *s && strcasecmp(s, "none")) {
6746  GWEN_Buffer_AppendString(tbuf, ", ");
6747  GWEN_Buffer_AppendString(tbuf, s);
6748  GWEN_Buffer_AppendString(tbuf, " param2");
6749  }
6750  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3) {
6751  GWEN_Buffer_AppendString(tbuf, ", int param3");
6752  }
6753  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4) {
6754  GWEN_Buffer_AppendString(tbuf, ", int param4");
6755  }
6756  GWEN_Buffer_AppendString(tbuf, "){\n");
6757 
6758  GWEN_Buffer_AppendString(tbuf, " GWEN_SIGNAL *sig;\n");
6759  GWEN_Buffer_AppendString(tbuf, "\n");
6760  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6761  GWEN_Buffer_AppendString(tbuf, " sig=GWEN_SignalObject_FindSignal(p_struct->_signalObject, ");
6762  s=Typemaker2_Signal_GetName(sig); /* name */
6763  GWEN_Buffer_AppendString(tbuf, "\"");
6764  GWEN_Buffer_AppendString(tbuf, s);
6765  GWEN_Buffer_AppendString(tbuf, "\", ");
6766 
6767  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6768  GWEN_Buffer_AppendString(tbuf, "\"");
6769  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6770  GWEN_Buffer_AppendString(tbuf, "\", ");
6771  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6772  GWEN_Buffer_AppendString(tbuf, "\"");
6773  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6774  GWEN_Buffer_AppendString(tbuf, "\");\n");
6775 
6776  GWEN_Buffer_AppendString(tbuf, " if (sig) \n");
6777  GWEN_Buffer_AppendString(tbuf, " return GWEN_Signal_Emit(sig, ");
6778  s=Typemaker2_Signal_GetParamType1(sig); /* param 1 */
6779  if (s && *s && strcasecmp(s, "none")) {
6780  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6781  GWEN_Buffer_AppendString(tbuf, "param1, ");
6782  }
6783  else
6784  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6785  s=Typemaker2_Signal_GetParamType2(sig); /* param 2 */
6786  if (s && *s && strcasecmp(s, "none")) {
6787  GWEN_Buffer_AppendString(tbuf, "(void*) ");
6788  GWEN_Buffer_AppendString(tbuf, " param2, ");
6789  }
6790  else
6791  GWEN_Buffer_AppendString(tbuf, "NULL, ");
6792  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3)
6793  GWEN_Buffer_AppendString(tbuf, "param3, ");
6794  else
6795  GWEN_Buffer_AppendString(tbuf, "0, ");
6796  if (Typemaker2_Signal_GetFlags(sig) & TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4)
6797  GWEN_Buffer_AppendString(tbuf, "param4");
6798  else
6799  GWEN_Buffer_AppendString(tbuf, "0");
6800  GWEN_Buffer_AppendString(tbuf, ");\n");
6801 
6802 
6803  GWEN_Buffer_AppendString(tbuf, " else\n");
6804  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
6805 
6806  GWEN_Buffer_AppendString(tbuf, "}\n");
6807  GWEN_Buffer_AppendString(tbuf, "\n");
6808 
6809 
6810  sig=Typemaker2_Signal_List_Next(sig);
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 _buildSlotFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6824 {
6825  GWEN_BUFFER *tbuf;
6826  const char *s;
6827  TYPEMAKER2_TYPEMANAGER *tym;
6828  TYPEMAKER2_SLOT_LIST *slotList;
6829 
6830  tym=Typemaker2_Builder_GetTypeManager(tb);
6831  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6832 
6833  slotList=Typemaker2_Type_GetSlots(ty);
6834  if (slotList) {
6835  TYPEMAKER2_SLOT *slot;
6836 
6837  /* private prototypes */
6838  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6839  slot=Typemaker2_Slot_List_First(slotList);
6840  while (slot) {
6841 
6842  /* callback function */
6843  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6844  s=Typemaker2_Type_GetPrefix(ty);
6845  GWEN_Buffer_AppendString(tbuf, s);
6846  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6847  s=Typemaker2_Slot_GetName(slot);
6848  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6849  GWEN_Buffer_AppendString(tbuf, s+1);
6850  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4);\n");
6851 
6852  slot=Typemaker2_Slot_List_Next(slot);
6853  }
6854 
6855  Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6856  GWEN_Buffer_Reset(tbuf);
6857 
6858  /* public prototypes */
6859  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6860  slot=Typemaker2_Slot_List_First(slotList);
6861  while (slot) {
6862  /* GetSlot */
6863  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6864  if (s) {
6865  GWEN_Buffer_AppendString(tbuf, s);
6866  GWEN_Buffer_AppendString(tbuf, " ");
6867  }
6868  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6869  s=Typemaker2_Type_GetPrefix(ty);
6870  GWEN_Buffer_AppendString(tbuf, s);
6871  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6872  s=Typemaker2_Slot_GetName(slot);
6873  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6874  GWEN_Buffer_AppendString(tbuf, s+1);
6875  GWEN_Buffer_AppendString(tbuf, "(const ");
6876  s=Typemaker2_Type_GetIdentifier(ty);
6877  GWEN_Buffer_AppendString(tbuf, s);
6878  GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
6879 
6880 
6881  slot=Typemaker2_Slot_List_Next(slot);
6882  }
6883  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
6884  GWEN_Buffer_Reset(tbuf);
6885 
6886  /* implementation */
6887  GWEN_Buffer_AppendString(tbuf, "/* slot functions */\n");
6888  slot=Typemaker2_Slot_List_First(slotList);
6889  while (slot) {
6890 
6891  /* callback function */
6892  GWEN_Buffer_AppendString(tbuf, "static int GWENHYWFAR_CB ");
6893  s=Typemaker2_Type_GetPrefix(ty);
6894  GWEN_Buffer_AppendString(tbuf, s);
6895  GWEN_Buffer_AppendString(tbuf, "_SlotCallback_");
6896  s=Typemaker2_Slot_GetName(slot);
6897  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6898  GWEN_Buffer_AppendString(tbuf, s+1);
6899  GWEN_Buffer_AppendString(tbuf, "(GWEN_SLOT *slot, void *userData, void *p1, void *p2, int p3, int p4) {\n");
6900 
6901  GWEN_Buffer_AppendString(tbuf, " ");
6902  s=Typemaker2_Type_GetIdentifier(ty);
6903  GWEN_Buffer_AppendString(tbuf, s);
6904  GWEN_Buffer_AppendString(tbuf, " *p_struct;\n");
6905 
6906  GWEN_Buffer_AppendString(tbuf, "\n");
6907  GWEN_Buffer_AppendString(tbuf, " p_struct=(");
6908  GWEN_Buffer_AppendString(tbuf, s);
6909  GWEN_Buffer_AppendString(tbuf, "*) userData;\n");
6910 
6911  GWEN_Buffer_AppendString(tbuf, " return ");
6912  s=Typemaker2_Type_GetPrefix(ty);
6913  GWEN_Buffer_AppendString(tbuf, s);
6914  GWEN_Buffer_AppendString(tbuf, "_");
6915  s=Typemaker2_Slot_GetName(slot);
6916  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6917  GWEN_Buffer_AppendString(tbuf, s+1);
6918  GWEN_Buffer_AppendString(tbuf, "(p_struct");
6919 
6920  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6921  if (s && *s && strcasecmp(s, "none")) {
6922  GWEN_Buffer_AppendString(tbuf, ", (");
6923  GWEN_Buffer_AppendString(tbuf, s);
6924  GWEN_Buffer_AppendString(tbuf, ") p1");
6925  }
6926  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6927  if (s && *s && strcasecmp(s, "none")) {
6928  GWEN_Buffer_AppendString(tbuf, ", (");
6929  GWEN_Buffer_AppendString(tbuf, s);
6930  GWEN_Buffer_AppendString(tbuf, ") p2");
6931  }
6932  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3)
6933  GWEN_Buffer_AppendString(tbuf, ", p3");
6934  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4)
6935  GWEN_Buffer_AppendString(tbuf, ", p4");
6936 
6937  GWEN_Buffer_AppendString(tbuf, ");\n");
6938 
6939  GWEN_Buffer_AppendString(tbuf, "}\n\n");
6940 
6941 
6942  /* GetSlot */
6943  GWEN_Buffer_AppendString(tbuf, "GWEN_SLOT *");
6944  s=Typemaker2_Type_GetPrefix(ty);
6945  GWEN_Buffer_AppendString(tbuf, s);
6946  GWEN_Buffer_AppendString(tbuf, "_GetSlot_");
6947  s=Typemaker2_Slot_GetName(slot);
6948  GWEN_Buffer_AppendByte(tbuf, toupper(*s));
6949  GWEN_Buffer_AppendString(tbuf, s+1);
6950  GWEN_Buffer_AppendString(tbuf, "(const ");
6951  s=Typemaker2_Type_GetIdentifier(ty);
6952  GWEN_Buffer_AppendString(tbuf, s);
6953  GWEN_Buffer_AppendString(tbuf, " *p_struct) {\n");
6954 
6955  GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
6956  GWEN_Buffer_AppendString(tbuf, " return GWEN_SignalObject_FindSlot(p_struct->_signalObject, ");
6957  s=Typemaker2_Slot_GetName(slot); /* name */
6958  GWEN_Buffer_AppendString(tbuf, "\"");
6959  GWEN_Buffer_AppendString(tbuf, s);
6960  GWEN_Buffer_AppendString(tbuf, "\", ");
6961  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
6962  GWEN_Buffer_AppendString(tbuf, "\"");
6963  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6964  GWEN_Buffer_AppendString(tbuf, "\", ");
6965  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
6966  GWEN_Buffer_AppendString(tbuf, "\"");
6967  GWEN_Buffer_AppendString(tbuf, s?s:"none");
6968  GWEN_Buffer_AppendString(tbuf, "\");\n");
6969 
6970  GWEN_Buffer_AppendString(tbuf, "}\n");
6971  GWEN_Buffer_AppendString(tbuf, "\n");
6972 
6973  slot=Typemaker2_Slot_List_Next(slot);
6974  }
6975  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
6976  GWEN_Buffer_Reset(tbuf);
6977 
6978  }
6979  GWEN_Buffer_free(tbuf);
6980 
6981  return 0;
6982 }
6983 
6984 
6985 
6986 static int _buildCacheFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
6987 {
6988  GWEN_BUFFER *tbuf;
6989  const char *s;
6990  TYPEMAKER2_TYPEMANAGER *tym;
6991 
6992  tym=Typemaker2_Builder_GetTypeManager(tb);
6993  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
6994 
6995  /* public prototypes */
6996  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
6997 
6998  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
6999  if (s) {
7000  GWEN_Buffer_AppendString(tbuf, s);
7001  GWEN_Buffer_AppendString(tbuf, " ");
7002  }
7003  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
7004  s=Typemaker2_Type_GetPrefix(ty);
7005  GWEN_Buffer_AppendString(tbuf, s);
7006  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr);\n");
7007  GWEN_Buffer_AppendString(tbuf, "\n");
7008 
7009  s=Typemaker2_TypeManager_GetApiDeclaration(tym);
7010  if (s) {
7011  GWEN_Buffer_AppendString(tbuf, s);
7012  GWEN_Buffer_AppendString(tbuf, " ");
7013  }
7014  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
7015  s=Typemaker2_Type_GetPrefix(ty);
7016  GWEN_Buffer_AppendString(tbuf, s);
7017  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr);\n");
7018  GWEN_Buffer_AppendString(tbuf, "\n");
7019 
7020  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
7021  GWEN_Buffer_Reset(tbuf);
7022 
7023 
7024  /* implementations */
7025  GWEN_Buffer_AppendString(tbuf, "/* cache functions */\n");
7026 
7027  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
7028  s=Typemaker2_Type_GetPrefix(ty);
7029  GWEN_Buffer_AppendString(tbuf, s);
7030  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Attach(void *ptr) {\n");
7031  GWEN_Buffer_AppendString(tbuf, " ");
7032  s=Typemaker2_Type_GetPrefix(ty);
7033  GWEN_Buffer_AppendString(tbuf, s);
7034  GWEN_Buffer_AppendString(tbuf, "_Attach((");
7035  s=Typemaker2_Type_GetIdentifier(ty);
7036  GWEN_Buffer_AppendString(tbuf, s);
7037  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
7038  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
7039  GWEN_Buffer_AppendString(tbuf, "}\n");
7040  GWEN_Buffer_AppendString(tbuf, "\n");
7041 
7042  GWEN_Buffer_AppendString(tbuf, "int GWENHYWFAR_CB ");
7043  s=Typemaker2_Type_GetPrefix(ty);
7044  GWEN_Buffer_AppendString(tbuf, s);
7045  GWEN_Buffer_AppendString(tbuf, "_CacheFn_Free(void *ptr){\n");
7046  GWEN_Buffer_AppendString(tbuf, " ");
7047  s=Typemaker2_Type_GetPrefix(ty);
7048  GWEN_Buffer_AppendString(tbuf, s);
7049  GWEN_Buffer_AppendString(tbuf, "_free((");
7050  s=Typemaker2_Type_GetIdentifier(ty);
7051  GWEN_Buffer_AppendString(tbuf, s);
7052  GWEN_Buffer_AppendString(tbuf, "*) ptr);\n");
7053  GWEN_Buffer_AppendString(tbuf, " return 0;\n");
7054  GWEN_Buffer_AppendString(tbuf, "}\n");
7055  GWEN_Buffer_AppendString(tbuf, "\n");
7056 
7057 
7058  Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
7059  GWEN_Buffer_free(tbuf);
7060 
7061  return 0;
7062 }
7063 
7064 
7065 
7066 static int _buildGroupApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty,
7067  TYPEMAKER2_GROUP *grp, int depth, GWEN_BUFFER *buf)
7068 {
7069  char numbuf[32];
7070  const char *s;
7071  TYPEMAKER2_GROUP *childGrp;
7072  TYPEMAKER2_MEMBER_LIST *members;
7073  const char *sTypeIdentifier;
7074  const char *sTypePrefix;
7075 
7076  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
7077  sTypePrefix=Typemaker2_Type_GetPrefix(ty);
7078 
7079  /* write title */
7080  GWEN_Buffer_AppendString(buf, "\n\n");
7081  GWEN_Buffer_AppendString(buf, "<h");
7082  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth);
7083  numbuf[sizeof(numbuf)-1]=0;
7084  GWEN_Buffer_AppendString(buf, numbuf);
7085  GWEN_Buffer_AppendString(buf, ">");
7086  s=Typemaker2_Group_GetTitle(grp);
7087  if (s && *s)
7088  GWEN_Buffer_AppendString(buf, s);
7089  else
7090  GWEN_Buffer_AppendString(buf, "Unnamed Group");
7091  GWEN_Buffer_AppendString(buf, "</h");
7092  GWEN_Buffer_AppendString(buf, numbuf);
7093  GWEN_Buffer_AppendString(buf, ">\n");
7094  GWEN_Buffer_AppendString(buf, "\n");
7095 
7096  s=Typemaker2_Group_GetDescription(grp);
7097  if (s && *s) {
7098  GWEN_DB_NODE *dbCall;
7099  int rv;
7100 
7101  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, NULL, NULL, NULL);
7102  assert(dbCall);
7103  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
7104  if (rv<0) {
7105  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7106  GWEN_DB_Group_free(dbCall);
7107  GWEN_Buffer_free(buf);
7108  return rv;
7109  }
7110  GWEN_DB_Group_free(dbCall);
7111  GWEN_Buffer_AppendString(buf, "\n");
7112  }
7113 
7114  /* write member docs */
7115  members=Typemaker2_Type_GetMembers(ty);
7116  if (members) {
7117  TYPEMAKER2_MEMBER *tm;
7118 
7119  tm=Typemaker2_Member_List_First(members);
7120  while (tm) {
7121 
7122  if (Typemaker2_Member_GetGroupPtr(tm)==grp) {
7123  const char *sMemberName;
7124 
7125  /* write APIDOC for member */
7126  sMemberName=Typemaker2_Member_GetName(tm);
7127 
7128  /* write anchor */
7129  GWEN_Buffer_AppendString(buf, "\n\n@anchor ");
7130  GWEN_Buffer_AppendString(buf, sTypeIdentifier);
7131  GWEN_Buffer_AppendString(buf, "_");
7132  GWEN_Buffer_AppendString(buf, sMemberName);
7133  GWEN_Buffer_AppendString(buf, "\n");
7134 
7135  /* write name */
7136  GWEN_Buffer_AppendString(buf, "<h");
7137  snprintf(numbuf, sizeof(numbuf)-1, "%d", depth+1);
7138  numbuf[sizeof(numbuf)-1]=0;
7139  GWEN_Buffer_AppendString(buf, numbuf);
7140  GWEN_Buffer_AppendString(buf, ">");
7141  s=Typemaker2_Member_GetName(tm);
7142  GWEN_Buffer_AppendString(buf, s);
7143  GWEN_Buffer_AppendString(buf, "</h");
7144  GWEN_Buffer_AppendString(buf, numbuf);
7145  GWEN_Buffer_AppendString(buf, ">\n");
7146  GWEN_Buffer_AppendString(buf, "\n");
7147 
7148  /* add description, if any */
7149  s=Typemaker2_Member_GetDescription(tm);
7150  if (s && *s) {
7151  GWEN_DB_NODE *dbCall;
7152  int rv;
7153 
7154  dbCall=Typemaker2_Builder_CreateDbForCall(tb, ty, tm, NULL, NULL);
7155  assert(dbCall);
7156  rv=Typemaker2_Builder_ReplaceVars(s, dbCall, buf);
7157  if (rv<0) {
7158  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7159  GWEN_DB_Group_free(dbCall);
7160  GWEN_Buffer_free(buf);
7161  return rv;
7162  }
7163  GWEN_DB_Group_free(dbCall);
7164  GWEN_Buffer_AppendString(buf, "\n");
7165  }
7166 
7167  /* add setter/getter info */
7168  GWEN_Buffer_AppendString(buf, "<p>");
7169  GWEN_Buffer_AppendString(buf, "Set this property with @ref ");
7170  GWEN_Buffer_AppendString(buf, sTypePrefix);
7171  GWEN_Buffer_AppendString(buf, "_Set");
7172  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7173  GWEN_Buffer_AppendString(buf, sMemberName+1);
7174  GWEN_Buffer_AppendString(buf, "(), get it with @ref ");
7175  GWEN_Buffer_AppendString(buf, sTypePrefix);
7176  GWEN_Buffer_AppendString(buf, "_Get");
7177  GWEN_Buffer_AppendByte(buf, toupper(*sMemberName));
7178  GWEN_Buffer_AppendString(buf, sMemberName+1);
7179  GWEN_Buffer_AppendString(buf, "().");
7180  GWEN_Buffer_AppendString(buf, "</p>\n");
7181  }
7182  tm=Typemaker2_Member_List_Next(tm);
7183  }
7184  }
7185 
7186  /* write children groups */
7187  childGrp=Typemaker2_Group_Tree_GetFirstChild(grp);
7188  while (childGrp) {
7189  int rv;
7190 
7191  rv=_buildGroupApiDoc(tb, ty, childGrp, depth+1, buf);
7192  if (rv<0) {
7193  DBG_ERROR(0, "here (%d)", rv);
7194  return rv;
7195  }
7196  childGrp=Typemaker2_Group_Tree_GetNext(childGrp);
7197  }
7198 
7199  return 0;
7200 }
7201 
7202 
7203 
7204 
7205 static int _buildApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7206 {
7207  TYPEMAKER2_GROUP_TREE *groupTree;
7208  TYPEMAKER2_GROUP *grp;
7209  GWEN_BUFFER *tbuf;
7210  const char *sTypeIdentifier;
7211 
7212  sTypeIdentifier=Typemaker2_Type_GetIdentifier(ty);
7213 
7214  groupTree=Typemaker2_Type_GetGroupTree(ty);
7215 
7216  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7217 
7218  GWEN_Buffer_AppendString(tbuf, "/** @page P_");
7219  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7220  GWEN_Buffer_AppendString(tbuf, " Structure ");
7221  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7222 
7223  GWEN_Buffer_AppendString(tbuf, "\n");
7224 
7225  GWEN_Buffer_AppendString(tbuf, "<p>This page describes the properties of ");
7226  GWEN_Buffer_AppendString(tbuf, sTypeIdentifier);
7227  GWEN_Buffer_AppendString(tbuf, ".</p>\n");
7228 
7229  GWEN_Buffer_AppendString(tbuf, "\n");
7230 
7231 
7232  grp=Typemaker2_Group_Tree_GetFirst(groupTree);
7233  while (grp) {
7234  _buildGroupApiDoc(tb, ty, grp, 1, tbuf);
7235  grp=Typemaker2_Group_Tree_GetNext(grp);
7236  }
7237  GWEN_Buffer_AppendString(tbuf, "\n");
7238  GWEN_Buffer_AppendString(tbuf, "*/\n");
7239 
7240  Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
7241 
7242  GWEN_Buffer_free(tbuf);
7243 
7244  return 0;
7245 }
7246 
7247 
7248 
7249 
7250 static int _addVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7251 {
7252  GWEN_BUFFER *tbuf;
7253  const char *s;
7254  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7255  TYPEMAKER2_SLOT_LIST *slotList;
7256 
7257  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
7258  fnList=Typemaker2_Type_GetVirtualFns(ty);
7259 
7260  slotList=Typemaker2_Type_GetSlots(ty);
7261  if (slotList) {
7262  TYPEMAKER2_SLOT *slot;
7263 
7264  slot=Typemaker2_Slot_List_First(slotList);
7265  while (slot) {
7266  TYPEMAKER2_VIRTUALFN *fn;
7267  TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
7268 
7269  /* callback function */
7270  s=Typemaker2_Slot_GetName(slot);
7271  GWEN_Buffer_AppendByte(tbuf, tolower(*s));
7272  GWEN_Buffer_AppendString(tbuf, s+1);
7273 
7274  fn=Typemaker2_VirtualFn_new();
7275  plist=Typemaker2_VirtualFn_GetParamTypeList(fn);
7276 
7277  /* name */
7278  Typemaker2_VirtualFn_SetName(fn, GWEN_Buffer_GetStart(tbuf));
7279 
7280  s=Typemaker2_Slot_GetParamType1(slot); /* param 1 */
7281  if (s && *s && strcasecmp(s, "none")) {
7282  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7283 
7284  prm=Typemaker2_VirtualFn_Param_new();
7285  Typemaker2_VirtualFn_Param_SetType(prm, s);
7286  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7287  }
7288  s=Typemaker2_Slot_GetParamType2(slot); /* param 2 */
7289  if (s && *s && strcasecmp(s, "none")) {
7290  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7291 
7292  prm=Typemaker2_VirtualFn_Param_new();
7293  Typemaker2_VirtualFn_Param_SetType(prm, s);
7294  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7295  }
7296  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM3) {
7297  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7298 
7299  prm=Typemaker2_VirtualFn_Param_new();
7300  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7301  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7302  }
7303  if (Typemaker2_Slot_GetFlags(slot) & TYPEMAKER2_SLOT_FLAGS_USE_PARAM4) {
7304  TYPEMAKER2_VIRTUALFN_PARAM *prm;
7305 
7306  prm=Typemaker2_VirtualFn_Param_new();
7307  Typemaker2_VirtualFn_Param_SetType(prm, "int");
7308  Typemaker2_VirtualFn_Param_List_Add(prm, plist);
7309  }
7310 
7311  Typemaker2_VirtualFn_SetAccess(fn, TypeMaker2_Access_Public);
7312  Typemaker2_VirtualFn_SetLocation(fn, "post");
7313  Typemaker2_VirtualFn_SetReturnType(fn, "int");
7314  Typemaker2_VirtualFn_SetDefaultReturnValue(fn, "GWEN_ERROR_NOT_IMPLEMENTED");
7315 
7316  Typemaker2_VirtualFn_AddFlags(fn, TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT);
7317 
7318  Typemaker2_VirtualFn_List_Add(fn, fnList);
7319 
7320  slot=Typemaker2_Slot_List_Next(slot);
7321  }
7322  }
7323  GWEN_Buffer_free(tbuf);
7324 
7325  return 0;
7326 }
7327 
7328 
7329 
7330 static void _delVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7331 {
7332  TYPEMAKER2_VIRTUALFN_LIST *fnList;
7333 
7334  fnList=Typemaker2_Type_GetVirtualFns(ty);
7335  if (fnList) {
7336  TYPEMAKER2_VIRTUALFN *fn;
7337 
7338  fn=Typemaker2_VirtualFn_List_First(fnList);
7339  while (fn) {
7340  TYPEMAKER2_VIRTUALFN *fnNext;
7341 
7342  fnNext=Typemaker2_VirtualFn_List_Next(fn);
7343  if (Typemaker2_VirtualFn_GetFlags(fn) & TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT) {
7344  Typemaker2_VirtualFn_List_Del(fn);
7345  Typemaker2_VirtualFn_free(fn);
7346  }
7347  fn=fnNext;
7348  }
7349  }
7350 }
7351 
7352 
7353 
7354 
7355 static int Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
7356 {
7357  int rv;
7358  uint32_t flags;
7359 
7360  flags=Typemaker2_Type_GetFlags(ty);
7361 
7362  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7363  _delVirtualFnsFromSlots(tb, ty);
7364  rv=_addVirtualFnsFromSlots(tb, ty);
7365  if (rv<0) {
7366  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7367  return rv;
7368  }
7369  }
7370 
7371 
7372  rv=_setEnumStringFns(tb, ty);
7373  if (rv<0) {
7374  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7375  return rv;
7376  }
7377 
7378  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7379  rv=_buildFieldIds(tb, ty);
7380  if (rv<0) {
7381  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7382  return rv;
7383  }
7384  }
7385 
7386  rv=_buildApiDoc(tb, ty);
7387  if (rv<0) {
7388  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7389  return rv;
7390  }
7391 
7392  rv=_buildDefineDefines(tb, ty);
7393  if (rv<0) {
7394  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7395  return rv;
7396  }
7397 
7398  rv=_buildTypedef(tb, ty);
7399  if (rv<0) {
7400  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7401  return rv;
7402  }
7403 
7404  rv=_buildDefineEnums(tb, ty);
7405  if (rv<0) {
7406  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7407  return rv;
7408  }
7409 
7410  rv=_buildDefineVirtualFns(tb, ty, "pre");
7411  if (rv<0) {
7412  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7413  return rv;
7414  }
7415 
7416  rv=_buildPostHeaders(tb, ty);
7417  if (rv<0) {
7418  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7419  return rv;
7420  }
7421 
7422  rv=_buildDefineVirtualFns(tb, ty, "post");
7423  if (rv<0) {
7424  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7425  return rv;
7426  }
7427 
7428  rv=_buildStruct(tb, ty);
7429  if (rv<0) {
7430  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7431  return rv;
7432  }
7433 
7434  rv=_buildMacroFunctions(tb, ty);
7435  if (rv<0) {
7436  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7437  return rv;
7438  }
7439 
7440  rv=_buildEnumFromString(tb, ty);
7441  if (rv<0) {
7442  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7443  return rv;
7444  }
7445 
7446  rv=_buildEnumToString(tb, ty);
7447  if (rv<0) {
7448  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7449  return rv;
7450  }
7451 
7452  rv=_buildConstructor(tb, ty);
7453  if (rv<0) {
7454  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7455  return rv;
7456  }
7457 
7458  rv=_buildDestructor(tb, ty);
7459  if (rv<0) {
7460  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7461  return rv;
7462  }
7463 
7464  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT) {
7465  rv=_buildAttach(tb, ty);
7466  if (rv<0) {
7467  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7468  return rv;
7469  }
7470  }
7471 
7472  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7473  rv=_buildDup(tb, ty);
7474  if (rv<0) {
7475  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7476  return rv;
7477  }
7478  }
7479 
7480  if (!(flags & TYPEMAKER2_TYPEFLAGS_NOCOPY)) {
7481  rv=_buildCopy(tb, ty);
7482  if (rv<0) {
7483  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7484  return rv;
7485  }
7486  }
7487 
7488  rv=_buildGetter(tb, ty);
7489  if (rv<0) {
7490  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7491  return rv;
7492  }
7493 
7494  rv=_buildSetter(tb, ty);
7495  if (rv<0) {
7496  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7497  return rv;
7498  }
7499 
7500  rv=_buildProtoVirtualFns(tb, ty);
7501  if (rv<0) {
7502  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7503  return rv;
7504  }
7505 
7506  rv=_buildCodeVirtualFns(tb, ty);
7507  if (rv<0) {
7508  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7509  return rv;
7510  }
7511 
7512  rv=_buildProtoSetterVirtualFns(tb, ty);
7513  if (rv<0) {
7514  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7515  return rv;
7516  }
7517 
7518  rv=_buildSetterVirtualFns(tb, ty);
7519  if (rv<0) {
7520  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7521  return rv;
7522  }
7523 
7524  rv=_buildProtoGetterVirtualFns(tb, ty);
7525  if (rv<0) {
7526  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7527  return rv;
7528  }
7529 
7530  rv=_buildGetterVirtualFns(tb, ty);
7531  if (rv<0) {
7532  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7533  return rv;
7534  }
7535 
7536  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_LIST1) {
7537  if (!(flags & TYPEMAKER2_TYPEFLAGS_NODUP)) {
7538  rv=_buildList1Dup(tb, ty);
7539  if (rv<0) {
7540  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7541  return rv;
7542  }
7543  }
7544  }
7545 
7546  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_DB) {
7547  rv=_buildReadDb(tb, ty);
7548  if (rv<0) {
7549  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7550  return rv;
7551  }
7552 
7553  rv=_buildWriteDb(tb, ty);
7554  if (rv<0) {
7555  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7556  return rv;
7557  }
7558 
7559  rv=_buildFromDb(tb, ty);
7560  if (rv<0) {
7561  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7562  return rv;
7563  }
7564 
7565  rv=_buildToDb(tb, ty);
7566  if (rv<0) {
7567  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7568  return rv;
7569  }
7570 
7571  }
7572 
7573  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_XML) {
7574  rv=_buildReadXml(tb, ty);
7575  if (rv<0) {
7576  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7577  return rv;
7578  }
7579 
7580  rv=_buildWriteXml(tb, ty);
7581  if (rv<0) {
7582  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7583  return rv;
7584  }
7585 
7586  rv=_buildToXml(tb, ty);
7587  if (rv<0) {
7588  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7589  return rv;
7590  }
7591 
7592  rv=_buildFromXml(tb, ty);
7593  if (rv<0) {
7594  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7595  return rv;
7596  }
7597  }
7598 
7599  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_OBJECT) {
7600  rv=_buildReadObject(tb, ty);
7601  if (rv<0) {
7602  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7603  return rv;
7604  }
7605 
7606  rv=_buildWriteObject(tb, ty);
7607  if (rv<0) {
7608  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7609  return rv;
7610  }
7611 
7612  rv=_buildToObject(tb, ty);
7613  if (rv<0) {
7614  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7615  return rv;
7616  }
7617 
7618  rv=_buildFromObject(tb, ty);
7619  if (rv<0) {
7620  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7621  return rv;
7622  }
7623 
7624  rv=_buildCreateColumnList(tb, ty);
7625  if (rv<0) {
7626  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7627  return rv;
7628  }
7629 
7630  rv=_buildCreateTable(tb, ty);
7631  if (rv<0) {
7632  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7633  return rv;
7634  }
7635 
7636  rv=_buildCreateObject(tb, ty);
7637  if (rv<0) {
7638  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7639  return rv;
7640  }
7641  }
7642 
7643  rv=_buildGetByMember(tb, ty);
7644  if (rv<0) {
7645  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7646  return rv;
7647  }
7648 
7649  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_HASH) {
7650  rv=_buildToHashString(tb, ty);
7651  if (rv<0) {
7652  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7653  return rv;
7654  }
7655  }
7656 
7657  rv=_buildMemberInlines(tb, ty);
7658  if (rv<0) {
7659  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7660  return rv;
7661  }
7662 
7663 
7664  rv=_buildSortByMember(tb, ty);
7665  if (rv<0) {
7666  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7667  return rv;
7668  }
7669 
7670 
7671  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS) {
7672  rv=_buildSignalFunctions(tb, ty);
7673  if (rv<0) {
7674  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7675  return rv;
7676  }
7677  }
7678 
7679  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_SLOTS) {
7680  rv=_buildSlotFunctions(tb, ty);
7681  if (rv<0) {
7682  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7683  return rv;
7684  }
7685  }
7686 
7687  if (flags & TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS) {
7688  rv=_buildCacheFunctions(tb, ty);
7689  if (rv<0) {
7690  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7691  return rv;
7692  }
7693  }
7694 
7695  rv=_buildInlines(tb, ty);
7696  if (rv<0) {
7697  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7698  return rv;
7699  }
7700 
7701  rv=_buildEndHeaders(tb, ty);
7702  if (rv<0) {
7703  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
7704  return rv;
7705  }
7706 
7707  return 0;
7708 }
7709 
7710 
7711 
7712 TYPEMAKER2_BUILDER *Typemaker2_Builder_C_new()
7713 {
7714  TYPEMAKER2_BUILDER *tb;
7715 
7716  tb=Typemaker2_Builder_new();
7717  Typemaker2_Builder_SetBuildFn(tb, Typemaker2_Builder_C_Build);
7718 
7719  return tb;
7720 }
7721 
7722 
7723 
7724 
7725 
NULL
#define NULL
Definition: binreloc.c:300
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:650
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:42
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:394
GWEN_DB_Group_free
void GWEN_DB_Group_free(GWEN_DB_NODE *n)
Definition: db.c:419
GWEN_DB_NODE
struct GWEN_DB_NODE GWEN_DB_NODE
Definition: db.h:228
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:178
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
GWEN_ERROR_BAD_DATA
#define GWEN_ERROR_BAD_DATA
Definition: error.h:121
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:145
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition: logger.h:35
Typemaker2_Builder_new
TYPEMAKER2_BUILDER * Typemaker2_Builder_new()
Definition: tm_builder.c:53
Typemaker2_Builder_AddCode
void Typemaker2_Builder_AddCode(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:181
Typemaker2_Builder_AddPublicDeclaration
void Typemaker2_Builder_AddPublicDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:149
Typemaker2_Builder_GetTypeManager
TYPEMAKER2_TYPEMANAGER * Typemaker2_Builder_GetTypeManager(const TYPEMAKER2_BUILDER *tb)
Definition: tm_builder.c:133
Typemaker2_Builder_ReplaceVars
int Typemaker2_Builder_ReplaceVars(const char *s, GWEN_DB_NODE *db, GWEN_BUFFER *dbuf)
Definition: tm_builder.c:525
Typemaker2_Builder_AddLibraryDeclaration
void Typemaker2_Builder_AddLibraryDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:157
Typemaker2_Builder_AddProtectedDeclaration
void Typemaker2_Builder_AddProtectedDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:165
Typemaker2_Builder_SetBuildFn
void Typemaker2_Builder_SetBuildFn(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_BUILDER_BUILD_FN fn)
Definition: tm_builder.c:329
Typemaker2_Builder_AddPrivateDeclaration
void Typemaker2_Builder_AddPrivateDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:173
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
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_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_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_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_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_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_BUILDER
struct TYPEMAKER2_BUILDER TYPEMAKER2_BUILDER
Definition: tm_builder.h:26
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)
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)
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_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_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)
_buildFromObject
static int _buildFromObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3075
_buildConstructor
static int _buildConstructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:684
_buildReadObject
static int _buildReadObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2735
_buildSignalFunctions
static int _buildSignalFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6494
_buildSlotFunctions
static int _buildSlotFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6823
_buildGetter
static int _buildGetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1116
_buildToObject
static int _buildToObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3024
_buildFromDb
static int _buildFromDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2249
_buildMemberInlines
static int _buildMemberInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6349
_buildToHashString
static int _buildToHashString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6164
_buildToXml
static int _buildToXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2620
_buildDup
static int _buildDup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3268
_buildToDb
static int _buildToDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2198
_buildMacroFunctions
static int _buildMacroFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:595
Typemaker2_Builder_C_Build
static int Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7355
_buildReadXml
static int _buildReadXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2313
_buildGroupApiDoc
static int _buildGroupApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_GROUP *grp, int depth, GWEN_BUFFER *buf)
Definition: tm_builder_c.c:7066
_buildWriteDb
static int _buildWriteDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2083
_buildGetByMember
static int _buildGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5762
_buildProtoVirtualFns
int _buildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4269
_buildStruct
static int _buildStruct(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:424
_buildAttach
static int _buildAttach(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6443
_setEnumStringFns
static int _setEnumStringFns(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4988
_buildTypedef
static int _buildTypedef(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:76
_buildDefineDefines
static int _buildDefineDefines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6060
_delVirtualFnsFromSlots
static void _delVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7330
_buildInlines
static int _buildInlines(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6275
_buildEnumToString
static int _buildEnumToString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5174
_buildFromXml
static int _buildFromXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2671
_buildDefineVirtualFns
int _buildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
Definition: tm_builder_c.c:4131
_buildCopy
static int _buildCopy(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3526
_buildCodeVirtualFns
int _buildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4460
_buildPostHeaders
static int _buildPostHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:330
_buildSetter
static int _buildSetter(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1323
_buildWriteObject
static int _buildWriteObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2908
_buildList1Dup
static int _buildList1Dup(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3816
_addVirtualFnsFromSlots
static int _addVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7250
_buildList1SortByMember
static int _buildList1SortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5822
_buildApiDoc
static int _buildApiDoc(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:7205
_buildList1GetByMember
static int _buildList1GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5306
_buildCreateColumnList
static int _buildCreateColumnList(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3152
_buildDefineEnums
static int _buildDefineEnums(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4026
_buildCreateObject
static int _buildCreateObject(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3974
_buildSetterVirtualFns
int _buildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4715
_buildTreeGetByMember
static int _buildTreeGetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5458
_buildCreateTable
static int _buildCreateTable(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:3916
_buildCacheFunctions
static int _buildCacheFunctions(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6986
_buildTree2GetByMember
static int _buildTree2GetByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, TYPEMAKER2_MEMBER *tm)
Definition: tm_builder_c.c:5610
Typemaker2_Builder_C_new
TYPEMAKER2_BUILDER * Typemaker2_Builder_C_new()
Definition: tm_builder_c.c:7712
_buildSortByMember
static int _buildSortByMember(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:6020
_buildProtoGetterVirtualFns
int _buildProtoGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4825
_buildWriteXml
static int _buildWriteXml(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:2515
_buildFieldIds
static int _buildFieldIds(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:26
_buildDestructor
static int _buildDestructor(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:954
_buildGetterVirtualFns
int _buildGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4912
_buildEndHeaders
static int _buildEndHeaders(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:377
_buildProtoSetterVirtualFns
int _buildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:4616
_buildEnumFromString
static int _buildEnumFromString(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:5041
_buildReadDb
static int _buildReadDb(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm_builder_c.c:1886
tm_builder_c.h
Typemaker2_Define_GetItems
TYPEMAKER2_ITEM_LIST * Typemaker2_Define_GetItems(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:202
Typemaker2_Define_GetStartValue
int Typemaker2_Define_GetStartValue(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:214
Typemaker2_Define_GetMode
int Typemaker2_Define_GetMode(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:208
Typemaker2_Define_GetPrefix
const char * Typemaker2_Define_GetPrefix(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:190
Typemaker2_Define_GetId
const char * Typemaker2_Define_GetId(const TYPEMAKER2_DEFINE *p_struct)
Definition: tm_define.c:184
Typemaker2_Define_Mode_BitField
@ Typemaker2_Define_Mode_BitField
Definition: tm_define.h:31
Typemaker2_Define_Mode_Sequence
@ Typemaker2_Define_Mode_Sequence
Definition: tm_define.h:30
TYPEMAKER2_DEFINE
struct TYPEMAKER2_DEFINE TYPEMAKER2_DEFINE
Definition: tm_define.h:24
Typemaker2_Enum_SetFromStringFn
void Typemaker2_Enum_SetFromStringFn(TYPEMAKER2_ENUM *p_struct, const char *p_src)
Definition: tm_enum.c:286
Typemaker2_Enum_GetItems
TYPEMAKER2_ITEM_LIST * Typemaker2_Enum_GetItems(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:198
Typemaker2_Enum_SetToStringFn
void Typemaker2_Enum_SetToStringFn(TYPEMAKER2_ENUM *p_struct, const char *p_src)
Definition: tm_enum.c:272
Typemaker2_Enum_GetPrefix
const char * Typemaker2_Enum_GetPrefix(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:186
Typemaker2_Enum_GetType
const char * Typemaker2_Enum_GetType(const TYPEMAKER2_ENUM *p_struct)
Definition: tm_enum.c:192
TYPEMAKER2_ENUM
struct TYPEMAKER2_ENUM TYPEMAKER2_ENUM
Definition: tm_enum.h:24
Typemaker2_Group_GetDescription
const char * Typemaker2_Group_GetDescription(TYPEMAKER2_GROUP *gr)
Definition: tm_group.c:93
Typemaker2_Group_GetTitle
const char * Typemaker2_Group_GetTitle(TYPEMAKER2_GROUP *gr)
Definition: tm_group.c:69
TYPEMAKER2_GROUP
struct TYPEMAKER2_GROUP TYPEMAKER2_GROUP
Definition: tm_group.h:19
Typemaker2_Header_GetFileName
const char * Typemaker2_Header_GetFileName(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:68
Typemaker2_Header_GetType
int Typemaker2_Header_GetType(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:90
Typemaker2_Header_GetLocation
int Typemaker2_Header_GetLocation(const TYPEMAKER2_HEADER *th)
Definition: tm_header.c:108
Typemaker2_HeaderType_System
@ Typemaker2_HeaderType_System
Definition: tm_header.h:25
Typemaker2_HeaderLocation_Post
@ Typemaker2_HeaderLocation_Post
Definition: tm_header.h:32
Typemaker2_HeaderLocation_HeaderEnd
@ Typemaker2_HeaderLocation_HeaderEnd
Definition: tm_header.h:35
Typemaker2_HeaderLocation_Pre
@ Typemaker2_HeaderLocation_Pre
Definition: tm_header.h:31
TYPEMAKER2_HEADER
struct TYPEMAKER2_HEADER TYPEMAKER2_HEADER
Definition: tm_header.h:19
Typemaker2_Inline_GetLocation
int Typemaker2_Inline_GetLocation(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:91
Typemaker2_Inline_GetAccess
int Typemaker2_Inline_GetAccess(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:109
Typemaker2_Inline_GetTypeFlagsMask
int Typemaker2_Inline_GetTypeFlagsMask(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:127
Typemaker2_Inline_GetTypeFlagsValue
int Typemaker2_Inline_GetTypeFlagsValue(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:136
Typemaker2_Inline_GetContent
const char * Typemaker2_Inline_GetContent(const TYPEMAKER2_INLINE *th)
Definition: tm_inline.c:69
TYPEMAKER2_INLINE
struct TYPEMAKER2_INLINE TYPEMAKER2_INLINE
Definition: tm_inline.h:19
Typemaker2_InlineLocation_Header
@ Typemaker2_InlineLocation_Header
Definition: tm_inline.h:25
Typemaker2_InlineLocation_Code
@ Typemaker2_InlineLocation_Code
Definition: tm_inline.h:26
Typemaker2_Item_GetName
const char * Typemaker2_Item_GetName(const TYPEMAKER2_ITEM *p_struct)
Definition: tm_item.c:101
Typemaker2_Item_GetValue
const char * Typemaker2_Item_GetValue(const TYPEMAKER2_ITEM *p_struct)
Definition: tm_item.c:107
TYPEMAKER2_ITEM
struct TYPEMAKER2_ITEM TYPEMAKER2_ITEM
Definition: tm_item.h:22
Typemaker2_Member_GetMemberPosition
int Typemaker2_Member_GetMemberPosition(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:539
Typemaker2_Member_GetEnumPtr
TYPEMAKER2_ENUM * Typemaker2_Member_GetEnumPtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:485
Typemaker2_Member_GetDupFlags
uint32_t Typemaker2_Member_GetDupFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:303
Typemaker2_Member_GetTypePtr
TYPEMAKER2_TYPE * Typemaker2_Member_GetTypePtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:467
Typemaker2_Member_GetSetFlags
uint32_t Typemaker2_Member_GetSetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:259
Typemaker2_Member_GetCopyFlags
uint32_t Typemaker2_Member_GetCopyFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:325
Typemaker2_Member_GetPresetValue
const char * Typemaker2_Member_GetPresetValue(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:414
Typemaker2_Member_GetAccess
int Typemaker2_Member_GetAccess(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:347
Typemaker2_Member_GetFlags
uint32_t Typemaker2_Member_GetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:237
Typemaker2_Member_GetFieldId
const char * Typemaker2_Member_GetFieldId(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:171
Typemaker2_Member_GetMaxLen
int Typemaker2_Member_GetMaxLen(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:369
Typemaker2_Member_GetDescription
const char * Typemaker2_Member_GetDescription(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:149
Typemaker2_Member_GetName
const char * Typemaker2_Member_GetName(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:83
Typemaker2_Member_GetGetFlags
uint32_t Typemaker2_Member_GetGetFlags(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:281
Typemaker2_Member_GetGroupPtr
TYPEMAKER2_GROUP * Typemaker2_Member_GetGroupPtr(const TYPEMAKER2_MEMBER *tm)
Definition: tm_member.c:521
TYPEMAKER2_MEMBER
struct TYPEMAKER2_MEMBER TYPEMAKER2_MEMBER
Definition: tm_member.h:21
Typemaker2_Signal_GetParamType1
const char * Typemaker2_Signal_GetParamType1(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:134
Typemaker2_Signal_GetParamType2
const char * Typemaker2_Signal_GetParamType2(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:140
Typemaker2_Signal_GetName
const char * Typemaker2_Signal_GetName(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:128
Typemaker2_Signal_GetFlags
uint32_t Typemaker2_Signal_GetFlags(const TYPEMAKER2_SIGNAL *p_struct)
Definition: tm_signal.c:146
TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4
#define TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4
Definition: tm_signal.h:18
TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3
#define TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3
Definition: tm_signal.h:17
TYPEMAKER2_SIGNAL
struct TYPEMAKER2_SIGNAL TYPEMAKER2_SIGNAL
Definition: tm_signal.h:27
Typemaker2_Slot_GetParamType1
const char * Typemaker2_Slot_GetParamType1(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:134
Typemaker2_Slot_GetFlags
uint32_t Typemaker2_Slot_GetFlags(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:146
Typemaker2_Slot_GetParamType2
const char * Typemaker2_Slot_GetParamType2(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:140
Typemaker2_Slot_GetName
const char * Typemaker2_Slot_GetName(const TYPEMAKER2_SLOT *p_struct)
Definition: tm_slot.c:128
TYPEMAKER2_SLOT
struct TYPEMAKER2_SLOT TYPEMAKER2_SLOT
Definition: tm_slot.h:27
TYPEMAKER2_SLOT_FLAGS_USE_PARAM4
#define TYPEMAKER2_SLOT_FLAGS_USE_PARAM4
Definition: tm_slot.h:18
TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
#define TYPEMAKER2_SLOT_FLAGS_USE_PARAM3
Definition: tm_slot.h:17
Typemaker2_Type_GetIdentifier
const char * Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:543
Typemaker2_Type_GetFreeHook
const char * Typemaker2_Type_GetFreeHook(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:244
Typemaker2_Type_GetType
int Typemaker2_Type_GetType(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:171
Typemaker2_Type_GetSignals
TYPEMAKER2_SIGNAL_LIST * Typemaker2_Type_GetSignals(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:704
Typemaker2_Type_GetPrefix
const char * Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:565
Typemaker2_Type_GetFieldCountId
const char * Typemaker2_Type_GetFieldCountId(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:749
Typemaker2_Type_GetInlines
TYPEMAKER2_INLINE_LIST * Typemaker2_Type_GetInlines(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:686
Typemaker2_Type_GetHeaders
TYPEMAKER2_HEADER_LIST * Typemaker2_Type_GetHeaders(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:650
Typemaker2_Type_GetFlags
uint32_t Typemaker2_Type_GetFlags(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:341
Typemaker2_Type_GetVirtualFns
TYPEMAKER2_VIRTUALFN_LIST * Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:695
Typemaker2_Type_GetNonVolatileMemberCount
int Typemaker2_Type_GetNonVolatileMemberCount(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:731
Typemaker2_Type_GetAqDbType
const char * Typemaker2_Type_GetAqDbType(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:195
Typemaker2_Type_GetSlots
TYPEMAKER2_SLOT_LIST * Typemaker2_Type_GetSlots(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:713
Typemaker2_Type_GetMembers
TYPEMAKER2_MEMBER_LIST * Typemaker2_Type_GetMembers(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:641
Typemaker2_Type_GetDefines
TYPEMAKER2_DEFINE_LIST * Typemaker2_Type_GetDefines(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:668
Typemaker2_Type_GetEnums
TYPEMAKER2_ENUM_LIST * Typemaker2_Type_GetEnums(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:659
Typemaker2_Type_GetUsePrivateConstructor
int Typemaker2_Type_GetUsePrivateConstructor(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:473
Typemaker2_Type_GetGroupTree
TYPEMAKER2_GROUP_TREE * Typemaker2_Type_GetGroupTree(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:722
Typemaker2_Type_GetExtendsPtr
TYPEMAKER2_TYPE * Typemaker2_Type_GetExtendsPtr(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:587
TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
#define TYPEMAKER2_TYPEFLAGS_WITH_REFCOUNT
Definition: tm_type.h:61
TYPEMAKER2_FLAGS_DUP
#define TYPEMAKER2_FLAGS_DUP
Definition: tm_type.h:35
TYPEMAKER2_TYPEFLAGS_WITH_IDMAP
#define TYPEMAKER2_TYPEFLAGS_WITH_IDMAP
Definition: tm_type.h:59
TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
#define TYPEMAKER2_TYPEFLAGS_WITH_SIGNALS
Definition: tm_type.h:62
TYPEMAKER2_TYPE
struct TYPEMAKER2_TYPE TYPEMAKER2_TYPE
Definition: tm_type.h:21
TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS
#define TYPEMAKER2_TYPEFLAGS_WITH_CACHEFNS
Definition: tm_type.h:64
TYPEMAKER2_FLAGS_NOCONSTOBJECT
#define TYPEMAKER2_FLAGS_NOCONSTOBJECT
Definition: tm_type.h:45
TypeMaker2_Type_Array
@ TypeMaker2_Type_Array
Definition: tm_type.h:79
TypeMaker2_Type_Pointer
@ TypeMaker2_Type_Pointer
Definition: tm_type.h:78
TYPEMAKER2_TYPEFLAGS_WITH_XML
#define TYPEMAKER2_TYPEFLAGS_WITH_XML
Definition: tm_type.h:54
TYPEMAKER2_TYPEFLAGS_NODUP
#define TYPEMAKER2_TYPEFLAGS_NODUP
Definition: tm_type.h:66
TYPEMAKER2_TYPEFLAGS_WITH_LIST1
#define TYPEMAKER2_TYPEFLAGS_WITH_LIST1
Definition: tm_type.h:56
TYPEMAKER2_FLAGS_CONST
#define TYPEMAKER2_FLAGS_CONST
Definition: tm_type.h:33
TYPEMAKER2_TYPEFLAGS_WITH_DB
#define TYPEMAKER2_TYPEFLAGS_WITH_DB
Definition: tm_type.h:53
TYPEMAKER2_FLAGS_WITH_HASH
#define TYPEMAKER2_FLAGS_WITH_HASH
Definition: tm_type.h:47
TYPEMAKER2_FLAGS_WITH_GETBYMEMBER
#define TYPEMAKER2_FLAGS_WITH_GETBYMEMBER
Definition: tm_type.h:46
TYPEMAKER2_FLAGS_ENUM
#define TYPEMAKER2_FLAGS_ENUM
Definition: tm_type.h:38
TYPEMAKER2_FLAGS_VOLATILE
#define TYPEMAKER2_FLAGS_VOLATILE
Definition: tm_type.h:32
TYPEMAKER2_TYPEFLAGS_WITH_HASH
#define TYPEMAKER2_TYPEFLAGS_WITH_HASH
Definition: tm_type.h:69
TYPEMAKER2_FLAGS_OMIT
#define TYPEMAKER2_FLAGS_OMIT
Definition: tm_type.h:41
TYPEMAKER2_TYPEFLAGS_WITH_INHERIT
#define TYPEMAKER2_TYPEFLAGS_WITH_INHERIT
Definition: tm_type.h:58
TYPEMAKER2_FLAGS_WITH_FLAGS
#define TYPEMAKER2_FLAGS_WITH_FLAGS
Definition: tm_type.h:49
TypeMaker2_Access_Private
@ TypeMaker2_Access_Private
Definition: tm_type.h:89
TypeMaker2_Access_Library
@ TypeMaker2_Access_Library
Definition: tm_type.h:88
TypeMaker2_Access_Protected
@ TypeMaker2_Access_Protected
Definition: tm_type.h:87
TypeMaker2_Access_Public
@ TypeMaker2_Access_Public
Definition: tm_type.h:86
TYPEMAKER2_FLAGS_OWN
#define TYPEMAKER2_FLAGS_OWN
Definition: tm_type.h:31
TYPEMAKER2_FLAGS_SORTBYMEMBER
#define TYPEMAKER2_FLAGS_SORTBYMEMBER
Definition: tm_type.h:44
TYPEMAKER2_FLAGS_ASSIGN
#define TYPEMAKER2_FLAGS_ASSIGN
Definition: tm_type.h:40
TYPEMAKER2_TYPEFLAGS_WITH_LIST2
#define TYPEMAKER2_TYPEFLAGS_WITH_LIST2
Definition: tm_type.h:57
TYPEMAKER2_FLAGS_GWEN_CB
#define TYPEMAKER2_FLAGS_GWEN_CB
Definition: tm_type.h:50
TYPEMAKER2_TYPEFLAGS_WITH_OBJECT
#define TYPEMAKER2_TYPEFLAGS_WITH_OBJECT
Definition: tm_type.h:55
TYPEMAKER2_TYPEFLAGS_WITH_TREE
#define TYPEMAKER2_TYPEFLAGS_WITH_TREE
Definition: tm_type.h:60
TYPEMAKER2_TYPEFLAGS_WITH_SLOTS
#define TYPEMAKER2_TYPEFLAGS_WITH_SLOTS
Definition: tm_type.h:63
TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2
#define TYPEMAKER2_TYPEFLAGS_WITH_CONSTLIST2
Definition: tm_type.h:70
TYPEMAKER2_TYPEFLAGS_NOCOPY
#define TYPEMAKER2_TYPEFLAGS_NOCOPY
Definition: tm_type.h:68
TYPEMAKER2_FLAGS_NODUP
#define TYPEMAKER2_FLAGS_NODUP
Definition: tm_type.h:36
TYPEMAKER2_FLAGS_NOCOPY
#define TYPEMAKER2_FLAGS_NOCOPY
Definition: tm_type.h:43
TYPEMAKER2_TYPEFLAGS_WITH_TREE2
#define TYPEMAKER2_TYPEFLAGS_WITH_TREE2
Definition: tm_type.h:71
Typemaker2_TypeManager_GetApiDeclaration
const char * Typemaker2_TypeManager_GetApiDeclaration(const TYPEMAKER2_TYPEMANAGER *tym)
Definition: tm_typemanager.c:82
TYPEMAKER2_TYPEMANAGER
struct TYPEMAKER2_TYPEMANAGER TYPEMAKER2_TYPEMANAGER
Definition: tm_typemanager.h:19
Typemaker2_VirtualFn_SetDefaultReturnValue
void Typemaker2_VirtualFn_SetDefaultReturnValue(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:356
Typemaker2_VirtualFn_GetReturnTypeDescr
const char * Typemaker2_VirtualFn_GetReturnTypeDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:326
Typemaker2_VirtualFn_GetParamTypeList
TYPEMAKER2_VIRTUALFN_PARAM_LIST * Typemaker2_VirtualFn_GetParamTypeList(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:370
Typemaker2_VirtualFn_new
TYPEMAKER2_VIRTUALFN * Typemaker2_VirtualFn_new()
Definition: tm_virtualfn.c:30
Typemaker2_VirtualFn_GetDescr
const char * Typemaker2_VirtualFn_GetDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:218
Typemaker2_VirtualFn_Param_GetDescr
const char * Typemaker2_VirtualFn_Param_GetDescr(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:478
Typemaker2_VirtualFn_SetName
void Typemaker2_VirtualFn_SetName(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:180
Typemaker2_VirtualFn_Param_GetType
const char * Typemaker2_VirtualFn_Param_GetType(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:458
Typemaker2_VirtualFn_Param_SetType
void Typemaker2_VirtualFn_Param_SetType(TYPEMAKER2_VIRTUALFN_PARAM *prm, const char *s)
Definition: tm_virtualfn.c:466
Typemaker2_VirtualFn_GetName
const char * Typemaker2_VirtualFn_GetName(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:170
Typemaker2_VirtualFn_GetFlags
uint32_t Typemaker2_VirtualFn_GetFlags(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:242
Typemaker2_VirtualFn_free
void Typemaker2_VirtualFn_free(TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:45
Typemaker2_VirtualFn_GetDefaultReturnValue
const char * Typemaker2_VirtualFn_GetDefaultReturnValue(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:346
Typemaker2_VirtualFn_Param_GetName
const char * Typemaker2_VirtualFn_Param_GetName(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:438
Typemaker2_VirtualFn_SetAccess
void Typemaker2_VirtualFn_SetAccess(TYPEMAKER2_VIRTUALFN *vf, int i)
Definition: tm_virtualfn.c:292
Typemaker2_VirtualFn_SetReturnType
void Typemaker2_VirtualFn_SetReturnType(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:312
Typemaker2_VirtualFn_AddFlags
void Typemaker2_VirtualFn_AddFlags(TYPEMAKER2_VIRTUALFN *vf, uint32_t fl)
Definition: tm_virtualfn.c:262
Typemaker2_VirtualFn_GetAccess
int Typemaker2_VirtualFn_GetAccess(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:282
Typemaker2_VirtualFn_Param_new
TYPEMAKER2_VIRTUALFN_PARAM * Typemaker2_VirtualFn_Param_new()
Definition: tm_virtualfn.c:413
Typemaker2_VirtualFn_GetPreset
const char * Typemaker2_VirtualFn_GetPreset(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:380
Typemaker2_VirtualFn_GetLocation
const char * Typemaker2_VirtualFn_GetLocation(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:194
Typemaker2_VirtualFn_SetLocation
void Typemaker2_VirtualFn_SetLocation(TYPEMAKER2_VIRTUALFN *vf, const char *s)
Definition: tm_virtualfn.c:204
Typemaker2_VirtualFn_GetReturnType
const char * Typemaker2_VirtualFn_GetReturnType(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:302
TYPEMAKER2_VIRTUALFN
struct TYPEMAKER2_VIRTUALFN TYPEMAKER2_VIRTUALFN
Definition: tm_virtualfn.h:21
TYPEMAKER2_VIRTUALFN_PARAM
struct TYPEMAKER2_VIRTUALFN_PARAM TYPEMAKER2_VIRTUALFN_PARAM
Definition: tm_virtualfn.h:24
TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT
#define TYPEMAKER2_VIRTUALFN_FLAGS_FROMSLOT
Definition: tm_virtualfn.h:28
Generated by doxygen 1.9.1