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
_buildFieldIds(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
75 /** writes typedef line into public header and also writes includes */
_buildTypedef(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildPostHeaders(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildEndHeaders(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildStruct(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildMacroFunctions(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildConstructor(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildDestructor(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildGetter(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildSetter(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildReadDb(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildWriteDb(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildToDb(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildFromDb(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildReadXml(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildWriteXml(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildToXml(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildFromXml(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildReadObject(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildWriteObject(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildToObject(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildFromObject(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCreateColumnList(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildDup(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCopy(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildList1Dup(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCreateTable(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCreateObject(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildDefineEnums(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildDefineVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,const char * loc)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
_buildProtoVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCodeVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildProtoSetterVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildSetterVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildProtoGetterVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildGetterVirtualFns(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_setEnumStringFns(GWEN_UNUSED TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildEnumFromString(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildEnumToString(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildList1GetByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,TYPEMAKER2_MEMBER * tm)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
_buildTreeGetByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,TYPEMAKER2_MEMBER * tm)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
_buildTree2GetByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,TYPEMAKER2_MEMBER * tm)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
_buildGetByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildList1SortByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,TYPEMAKER2_MEMBER * tm)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
_buildSortByMember(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildDefineDefines(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildToHashString(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildInlines(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildMemberInlines(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildAttach(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildSignalFunctions(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildSlotFunctions(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildCacheFunctions(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_buildGroupApiDoc(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty,TYPEMAKER2_GROUP * grp,int depth,GWEN_BUFFER * buf)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
_buildApiDoc(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_addVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
_delVirtualFnsFromSlots(GWEN_UNUSED TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
Typemaker2_Builder_C_Build(TYPEMAKER2_BUILDER * tb,TYPEMAKER2_TYPE * ty)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
Typemaker2_Builder_C_new()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
7726