gwenhywfar 5.10.1
tm2c_virtualfn.c
Go to the documentation of this file.
1/***************************************************************************
2 begin : Thu Jul 02 2009
3 copyright : (C) 2018 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * Please see toplevel file COPYING for license details *
8 ***************************************************************************/
9
10#ifdef HAVE_CONFIG_H
11# include <config.h>
12#endif
13
14
15#include "tm2c_virtualfn.h"
16#include "tm2c_misc.h"
17
18#include <gwenhywfar/debug.h>
19
20#include <ctype.h>
21
22
23
24int TM2C_BuildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
25{
26 TYPEMAKER2_VIRTUALFN_LIST *fns;
27
28 fns=Typemaker2_Type_GetVirtualFns(ty);
29
30 assert(fns);
31 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
32 GWEN_BUFFER *tbuf;
33 const char *s;
34 TYPEMAKER2_VIRTUALFN *vf;
35
36 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
37
38 if (loc && *loc)
39 GWEN_Buffer_AppendArgs(tbuf, "/* definitions for virtual functions (%s) */\n", loc);
40 else
41 GWEN_Buffer_AppendString(tbuf, "/* definitions for virtual functions */\n");
42
43 vf=Typemaker2_VirtualFn_List_First(fns);
44 while (vf) {
45 s=Typemaker2_VirtualFn_GetLocation(vf);
46 if (!(s && *s))
47 s="pre";
48 if (s && loc && strcasecmp(s, loc)==0) {
49 int access=Typemaker2_VirtualFn_GetAccess(vf);
50 TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
51 int i;
52
53 GWEN_Buffer_AppendString(tbuf, "typedef ");
54 s=Typemaker2_VirtualFn_GetReturnType(vf);
55 if (!(s && *s)) {
56 GWEN_Buffer_free(tbuf);
57 return GWEN_ERROR_BAD_DATA;
58 }
59 GWEN_Buffer_AppendString(tbuf, s);
60
61 if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_GWEN_CB) {
62 GWEN_Buffer_AppendString(tbuf, " GWENHYWFAR_CB");
63 }
64
65 GWEN_Buffer_AppendArgs(tbuf, " (*%s_", Typemaker2_Type_GetIdentifier(ty));
66
67 s=Typemaker2_VirtualFn_GetName(vf);
68 if (!(s && *s)) {
69 GWEN_Buffer_free(tbuf);
70 return GWEN_ERROR_BAD_DATA;
71 }
72 while (*s) {
73 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
74 s++;
75 }
76 GWEN_Buffer_AppendString(tbuf, "_FN)(");
77
78 if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
79 GWEN_Buffer_AppendString(tbuf, "const ");
80
81 s=Typemaker2_Type_GetIdentifier(ty);
82 GWEN_Buffer_AppendString(tbuf, s);
83 /* created structs are always pointers */
84 GWEN_Buffer_AppendString(tbuf, " *p_struct");
85
86 plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
87 if (plist) {
88 TYPEMAKER2_VIRTUALFN_PARAM *prm;
89
90 i=1;
91 prm=Typemaker2_VirtualFn_Param_List_First(plist);
92 while (prm) {
93 const char *paramName;
94 const char *paramType;
95
96 GWEN_Buffer_AppendString(tbuf, ", ");
97
98 paramName=Typemaker2_VirtualFn_Param_GetName(prm);
99 paramType=Typemaker2_VirtualFn_Param_GetType(prm);
100
101 GWEN_Buffer_AppendString(tbuf, paramType);
102 GWEN_Buffer_AppendString(tbuf, " ");
103
104 if (paramName)
105 GWEN_Buffer_AppendString(tbuf, paramName);
106 else
107 GWEN_Buffer_AppendArgs(tbuf, "param%d", i);
108
109 prm=Typemaker2_VirtualFn_Param_List_Next(prm);
110 i++;
111 }
112 }
113
114 GWEN_Buffer_AppendString(tbuf, ");\n");
115 Typemaker2_Builder_AddDeclaration(tb, access, GWEN_Buffer_GetStart(tbuf));
116 GWEN_Buffer_Reset(tbuf);
117 }
118
119 vf=Typemaker2_VirtualFn_List_Next(vf);
120 }
121 GWEN_Buffer_free(tbuf);
122 }
123
124 return 0;
125}
126
127
128
129int TM2C_BuildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
130{
131 TYPEMAKER2_VIRTUALFN_LIST *fns;
132 TYPEMAKER2_TYPEMANAGER *tym;
133
134 tym=Typemaker2_Builder_GetTypeManager(tb);
135 fns=Typemaker2_Type_GetVirtualFns(ty);
136
137 assert(fns);
138 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
139 GWEN_BUFFER *tbuf;
140 const char *s;
141 TYPEMAKER2_VIRTUALFN *vf;
142
143 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
144
145 GWEN_Buffer_AppendString(tbuf, "/* prototypes for virtual functions */\n");
146 vf=Typemaker2_VirtualFn_List_First(fns);
147 while (vf) {
148 int access=Typemaker2_VirtualFn_GetAccess(vf);
149 TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
150 int i;
151
152 /* write APIDOC */
153 GWEN_Buffer_AppendString(tbuf, "/**\n");
154 s=Typemaker2_VirtualFn_GetDescr(vf);
155 if (s && *s) {
156 int len;
157
158 GWEN_Buffer_AppendString(tbuf, " * ");
159 GWEN_Buffer_AppendString(tbuf, s);
160 len=strlen(s);
161 if (s[len-1]!='\n')
162 GWEN_Buffer_AppendString(tbuf, "\n");
163 }
164
165 s=Typemaker2_VirtualFn_GetReturnTypeDescr(vf);
166 if (s && *s) {
167 int len;
168
169 GWEN_Buffer_AppendString(tbuf, " * @return ");
170 GWEN_Buffer_AppendString(tbuf, s);
171 len=strlen(s);
172 if (s[len-1]!='\n')
173 GWEN_Buffer_AppendString(tbuf, "\n");
174 }
175
176
177 i=1;
178 plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
179 if (plist) {
180 TYPEMAKER2_VIRTUALFN_PARAM *prm;
181
182 i=1;
183 prm=Typemaker2_VirtualFn_Param_List_First(plist);
184 while (prm) {
185 const char *paramDescr;
186
187 paramDescr=Typemaker2_VirtualFn_Param_GetDescr(prm);
188 if (paramDescr && *paramDescr) {
189 const char *paramName;
190 int len;
191
192 GWEN_Buffer_AppendString(tbuf, " * @param ");
193 paramName=Typemaker2_VirtualFn_Param_GetName(prm);
194 if (paramName)
195 GWEN_Buffer_AppendString(tbuf, paramName);
196 else {
197 char numbuf[64];
198
199 snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
200 numbuf[sizeof(numbuf)-1]=0;
201 GWEN_Buffer_AppendString(tbuf, numbuf);
202 }
203
204 GWEN_Buffer_AppendString(tbuf, " ");
205 GWEN_Buffer_AppendString(tbuf, paramDescr);
206 len=strlen(paramDescr);
207 if (paramDescr[len-1]!='\n')
208 GWEN_Buffer_AppendString(tbuf, "\n");
209 }
210
211 i++;
212 prm=Typemaker2_VirtualFn_Param_List_Next(prm);
213 }
214 }
215 GWEN_Buffer_AppendString(tbuf, " */\n");
216
217
218 s=Typemaker2_TypeManager_GetApiDeclaration(tym);
219 if (s && *s) {
220 GWEN_Buffer_AppendString(tbuf, s);
221 GWEN_Buffer_AppendString(tbuf, " ");
222 }
223
224 s=Typemaker2_VirtualFn_GetReturnType(vf);
225 if (!(s && *s)) {
226 GWEN_Buffer_free(tbuf);
227 return GWEN_ERROR_BAD_DATA;
228 }
229 GWEN_Buffer_AppendString(tbuf, s);
230 GWEN_Buffer_AppendString(tbuf, " ");
231
232 s=Typemaker2_Type_GetPrefix(ty);
233 GWEN_Buffer_AppendString(tbuf, s);
234 GWEN_Buffer_AppendString(tbuf, "_");
235 s=Typemaker2_VirtualFn_GetName(vf);
236 if (!(s && *s)) {
237 GWEN_Buffer_free(tbuf);
238 return GWEN_ERROR_BAD_DATA;
239 }
240 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
241 GWEN_Buffer_AppendString(tbuf, s+1);
242 GWEN_Buffer_AppendString(tbuf, "(");
243
244 if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
245 GWEN_Buffer_AppendString(tbuf, "const ");
246
247 s=Typemaker2_Type_GetIdentifier(ty);
248 GWEN_Buffer_AppendString(tbuf, s);
249 /* created structs are always pointers */
250 GWEN_Buffer_AppendString(tbuf, " *p_struct");
251
252
253 i=1;
254 plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
255 if (plist) {
256 TYPEMAKER2_VIRTUALFN_PARAM *prm;
257
258 i=1;
259 prm=Typemaker2_VirtualFn_Param_List_First(plist);
260 while (prm) {
261 const char *paramName;
262 const char *paramType;
263
264 GWEN_Buffer_AppendString(tbuf, ", ");
265
266 paramName=Typemaker2_VirtualFn_Param_GetName(prm);
267 paramType=Typemaker2_VirtualFn_Param_GetType(prm);
268
269 GWEN_Buffer_AppendString(tbuf, paramType);
270 GWEN_Buffer_AppendString(tbuf, " ");
271
272 if (paramName)
273 GWEN_Buffer_AppendString(tbuf, paramName);
274 else {
275 char numbuf[64];
276
277 snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
278 numbuf[sizeof(numbuf)-1]=0;
279 GWEN_Buffer_AppendString(tbuf, numbuf);
280 }
281
282 prm=Typemaker2_VirtualFn_Param_List_Next(prm);
283 i++;
284 }
285 }
286 GWEN_Buffer_AppendString(tbuf, ");\n");
287 Typemaker2_Builder_AddDeclaration(tb, access, GWEN_Buffer_GetStart(tbuf));
288 GWEN_Buffer_Reset(tbuf);
289
290 vf=Typemaker2_VirtualFn_List_Next(vf);
291 }
292 GWEN_Buffer_free(tbuf);
293 }
294
295 return 0;
296}
297
298
299
300int TM2C_BuildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
301{
302 TYPEMAKER2_VIRTUALFN_LIST *fns;
303
304 fns=Typemaker2_Type_GetVirtualFns(ty);
305
306 assert(fns);
307 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
308 GWEN_BUFFER *tbuf;
309 const char *s;
310 TYPEMAKER2_VIRTUALFN *vf;
311
312 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
313
314 GWEN_Buffer_AppendString(tbuf, "/* code for virtual functions */\n");
315 vf=Typemaker2_VirtualFn_List_First(fns);
316 while (vf) {
317 TYPEMAKER2_VIRTUALFN_PARAM_LIST *plist;
318 int i;
319
320 s=Typemaker2_VirtualFn_GetReturnType(vf);
321 if (!(s && *s)) {
322 GWEN_Buffer_free(tbuf);
323 return GWEN_ERROR_BAD_DATA;
324 }
325 GWEN_Buffer_AppendString(tbuf, s);
326 GWEN_Buffer_AppendString(tbuf, " ");
327
328 s=Typemaker2_Type_GetPrefix(ty);
329 GWEN_Buffer_AppendString(tbuf, s);
330 GWEN_Buffer_AppendString(tbuf, "_");
331 s=Typemaker2_VirtualFn_GetName(vf);
332 if (!(s && *s)) {
333 GWEN_Buffer_free(tbuf);
334 return GWEN_ERROR_BAD_DATA;
335 }
336 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
337 GWEN_Buffer_AppendString(tbuf, s+1);
338 GWEN_Buffer_AppendString(tbuf, "(");
339
340 if (Typemaker2_VirtualFn_GetFlags(vf) & TYPEMAKER2_FLAGS_CONST)
341 GWEN_Buffer_AppendString(tbuf, "const ");
342
343 s=Typemaker2_Type_GetIdentifier(ty);
344 GWEN_Buffer_AppendString(tbuf, s);
345 /* created structs are always pointers */
346 GWEN_Buffer_AppendString(tbuf, " *p_struct");
347
348
349 i=1;
350 plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
351 if (plist) {
352 TYPEMAKER2_VIRTUALFN_PARAM *prm;
353
354 i=1;
355 prm=Typemaker2_VirtualFn_Param_List_First(plist);
356 while (prm) {
357 const char *paramName;
358 const char *paramType;
359
360 GWEN_Buffer_AppendString(tbuf, ", ");
361
362 paramName=Typemaker2_VirtualFn_Param_GetName(prm);
363 paramType=Typemaker2_VirtualFn_Param_GetType(prm);
364
365 GWEN_Buffer_AppendString(tbuf, paramType);
366 GWEN_Buffer_AppendString(tbuf, " ");
367
368 if (paramName)
369 GWEN_Buffer_AppendString(tbuf, paramName);
370 else {
371 char numbuf[64];
372
373 snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
374 numbuf[sizeof(numbuf)-1]=0;
375 GWEN_Buffer_AppendString(tbuf, numbuf);
376 }
377
378 prm=Typemaker2_VirtualFn_Param_List_Next(prm);
379 i++;
380 }
381 }
382 GWEN_Buffer_AppendString(tbuf, ") {\n");
383
384 GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
385 GWEN_Buffer_AppendString(tbuf, " if (p_struct->");
386 s=Typemaker2_VirtualFn_GetName(vf);
387 if (!(s && *s)) {
388 DBG_ERROR(0, "Virtual functions has no name");
389 GWEN_Buffer_free(tbuf);
390 return GWEN_ERROR_BAD_DATA;
391 }
392 GWEN_Buffer_AppendString(tbuf, s);
393 GWEN_Buffer_AppendString(tbuf, "Fn)\n");
394 GWEN_Buffer_AppendString(tbuf, " return p_struct->");
395 GWEN_Buffer_AppendString(tbuf, s);
396 GWEN_Buffer_AppendString(tbuf, "Fn(p_struct");
397
398 i=1;
399 plist=Typemaker2_VirtualFn_GetParamTypeList(vf);
400 if (plist) {
401 TYPEMAKER2_VIRTUALFN_PARAM *prm;
402
403 i=1;
404 prm=Typemaker2_VirtualFn_Param_List_First(plist);
405 while (prm) {
406 const char *paramName;
407
408 GWEN_Buffer_AppendString(tbuf, ", ");
409
410 paramName=Typemaker2_VirtualFn_Param_GetName(prm);
411
412 if (paramName)
413 GWEN_Buffer_AppendString(tbuf, paramName);
414 else {
415 char numbuf[64];
416
417 snprintf(numbuf, sizeof(numbuf)-1, "param%d", i);
418 numbuf[sizeof(numbuf)-1]=0;
419 GWEN_Buffer_AppendString(tbuf, numbuf);
420 }
421
422 prm=Typemaker2_VirtualFn_Param_List_Next(prm);
423 i++;
424 }
425 }
426 GWEN_Buffer_AppendString(tbuf, ");\n");
427
428 GWEN_Buffer_AppendString(tbuf, " else\n");
429 GWEN_Buffer_AppendString(tbuf, " return ");
430 s=Typemaker2_VirtualFn_GetDefaultReturnValue(vf);
431 if (!(s && *s)) {
432 DBG_ERROR(0, "No default return value");
433 GWEN_Buffer_free(tbuf);
434 return GWEN_ERROR_BAD_DATA;
435 }
436 GWEN_Buffer_AppendString(tbuf, s);
437 GWEN_Buffer_AppendString(tbuf, ";\n");
438 GWEN_Buffer_AppendString(tbuf, "}\n");
439
440 Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
441 GWEN_Buffer_Reset(tbuf);
442
443 vf=Typemaker2_VirtualFn_List_Next(vf);
444 }
445 GWEN_Buffer_free(tbuf);
446 }
447
448 return 0;
449}
450
451
452
453int TM2C_BuildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
454{
455 TYPEMAKER2_VIRTUALFN_LIST *fns;
456 TYPEMAKER2_TYPEMANAGER *tym;
457
458 tym=Typemaker2_Builder_GetTypeManager(tb);
459 fns=Typemaker2_Type_GetVirtualFns(ty);
460
461 assert(fns);
462 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
463 GWEN_BUFFER *tbuf;
464 const char *s;
465 TYPEMAKER2_VIRTUALFN *vf;
466
467 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
468
469 GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
470 vf=Typemaker2_VirtualFn_List_First(fns);
471 while (vf) {
472 int access=Typemaker2_VirtualFn_GetAccess(vf);
473
474 s=Typemaker2_TypeManager_GetApiDeclaration(tym);
475 if (s && *s) {
476 GWEN_Buffer_AppendString(tbuf, s);
477 GWEN_Buffer_AppendString(tbuf, " ");
478 }
479
480 s=Typemaker2_Type_GetIdentifier(ty);
481 GWEN_Buffer_AppendString(tbuf, s);
482 GWEN_Buffer_AppendString(tbuf, "_");
483 s=Typemaker2_VirtualFn_GetName(vf);
484 if (!(s && *s)) {
485 GWEN_Buffer_free(tbuf);
486 return GWEN_ERROR_BAD_DATA;
487 }
488 while (*s)
489 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
490 GWEN_Buffer_AppendString(tbuf, "_FN ");
491
492 s=Typemaker2_Type_GetPrefix(ty);
493 GWEN_Buffer_AppendString(tbuf, s);
494 GWEN_Buffer_AppendString(tbuf, "_Set");
495 s=Typemaker2_VirtualFn_GetName(vf);
496 if (!(s && *s)) {
497 GWEN_Buffer_free(tbuf);
498 return GWEN_ERROR_BAD_DATA;
499 }
500 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
501 GWEN_Buffer_AppendString(tbuf, s+1);
502 GWEN_Buffer_AppendString(tbuf, "Fn(");
503
504 s=Typemaker2_Type_GetIdentifier(ty);
505 GWEN_Buffer_AppendString(tbuf, s);
506 /* created structs are always pointers */
507 GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
508
509 s=Typemaker2_Type_GetIdentifier(ty);
510 GWEN_Buffer_AppendString(tbuf, s);
511 GWEN_Buffer_AppendString(tbuf, "_");
512 s=Typemaker2_VirtualFn_GetName(vf);
513 if (!(s && *s)) {
514 GWEN_Buffer_free(tbuf);
515 return GWEN_ERROR_BAD_DATA;
516 }
517 while (*s)
518 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
519 GWEN_Buffer_AppendString(tbuf, "_FN fn);\n");
520
521 switch (access) {
522 case TypeMaker2_Access_Public:
523 Typemaker2_Builder_AddPublicDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
524 break;
525 case TypeMaker2_Access_Library:
526 Typemaker2_Builder_AddLibraryDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
527 break;
528 case TypeMaker2_Access_Protected:
529 Typemaker2_Builder_AddProtectedDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
530 break;
531 case TypeMaker2_Access_Private:
532 Typemaker2_Builder_AddPrivateDeclaration(tb, GWEN_Buffer_GetStart(tbuf));
533 break;
534 default:
535 DBG_ERROR(GWEN_LOGDOMAIN, "Invalid access type");
536 GWEN_Buffer_free(tbuf);
537 return GWEN_ERROR_BAD_DATA;
538 }
539 GWEN_Buffer_Reset(tbuf);
540
541 vf=Typemaker2_VirtualFn_List_Next(vf);
542 }
543 GWEN_Buffer_free(tbuf);
544 }
545
546 return 0;
547}
548
549
550
551int TM2C_BuildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
552{
553 TYPEMAKER2_VIRTUALFN_LIST *fns;
554
555 fns=Typemaker2_Type_GetVirtualFns(ty);
556
557 assert(fns);
558 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
559 GWEN_BUFFER *tbuf;
560 const char *s;
561 TYPEMAKER2_VIRTUALFN *vf;
562
563 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
564
565 GWEN_Buffer_AppendString(tbuf, "/* setters for virtual functions */\n");
566 vf=Typemaker2_VirtualFn_List_First(fns);
567 while (vf) {
568
569 s=Typemaker2_Type_GetIdentifier(ty);
570 GWEN_Buffer_AppendString(tbuf, s);
571 GWEN_Buffer_AppendString(tbuf, "_");
572
573 s=Typemaker2_VirtualFn_GetName(vf);
574 if (!(s && *s)) {
575 GWEN_Buffer_free(tbuf);
576 return GWEN_ERROR_BAD_DATA;
577 }
578 while (*s)
579 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
580 GWEN_Buffer_AppendString(tbuf, "_FN ");
581
582 s=Typemaker2_Type_GetPrefix(ty);
583 GWEN_Buffer_AppendString(tbuf, s);
584 GWEN_Buffer_AppendString(tbuf, "_Set");
585 s=Typemaker2_VirtualFn_GetName(vf);
586 if (!(s && *s)) {
587 GWEN_Buffer_free(tbuf);
588 return GWEN_ERROR_BAD_DATA;
589 }
590 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
591 GWEN_Buffer_AppendString(tbuf, s+1);
592 GWEN_Buffer_AppendString(tbuf, "Fn(");
593
594 s=Typemaker2_Type_GetIdentifier(ty);
595 GWEN_Buffer_AppendString(tbuf, s);
596 /* created structs are always pointers */
597 GWEN_Buffer_AppendString(tbuf, " *p_struct, ");
598
599 s=Typemaker2_Type_GetIdentifier(ty);
600 GWEN_Buffer_AppendString(tbuf, s);
601 GWEN_Buffer_AppendString(tbuf, "_");
602 s=Typemaker2_VirtualFn_GetName(vf);
603 if (!(s && *s)) {
604 GWEN_Buffer_free(tbuf);
605 return GWEN_ERROR_BAD_DATA;
606 }
607 while (*s)
608 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
609 GWEN_Buffer_AppendString(tbuf, "_FN fn){\n");
610
611 GWEN_Buffer_AppendString(tbuf, " ");
612 s=Typemaker2_Type_GetIdentifier(ty);
613 GWEN_Buffer_AppendString(tbuf, s);
614 GWEN_Buffer_AppendString(tbuf, "_");
615 s=Typemaker2_VirtualFn_GetName(vf);
616 if (!(s && *s)) {
617 GWEN_Buffer_free(tbuf);
618 return GWEN_ERROR_BAD_DATA;
619 }
620 while (*s)
621 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
622 GWEN_Buffer_AppendString(tbuf, "_FN oldFn;\n\n");
623
624 GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
625 GWEN_Buffer_AppendString(tbuf, " oldFn=p_struct->");
626 s=Typemaker2_VirtualFn_GetName(vf);
627 if (!(s && *s)) {
628 GWEN_Buffer_free(tbuf);
629 return GWEN_ERROR_BAD_DATA;
630 }
631 GWEN_Buffer_AppendString(tbuf, s);
632 GWEN_Buffer_AppendString(tbuf, "Fn;\n");
633
634 GWEN_Buffer_AppendString(tbuf, " p_struct->");
635 s=Typemaker2_VirtualFn_GetName(vf);
636 if (!(s && *s)) {
637 GWEN_Buffer_free(tbuf);
638 return GWEN_ERROR_BAD_DATA;
639 }
640 GWEN_Buffer_AppendString(tbuf, s);
641 GWEN_Buffer_AppendString(tbuf, "Fn=fn;\n");
642 GWEN_Buffer_AppendString(tbuf, " return oldFn;\n");
643 GWEN_Buffer_AppendString(tbuf, "}\n");
644
645 Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
646 GWEN_Buffer_Reset(tbuf);
647
648 vf=Typemaker2_VirtualFn_List_Next(vf);
649 }
650 GWEN_Buffer_free(tbuf);
651 }
652
653 return 0;
654}
655
656
657
658int TM2C_BuildProtoGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
659{
660 TYPEMAKER2_VIRTUALFN_LIST *fns;
661 TYPEMAKER2_TYPEMANAGER *tym;
662
663 tym=Typemaker2_Builder_GetTypeManager(tb);
664 fns=Typemaker2_Type_GetVirtualFns(ty);
665
666 assert(fns);
667 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
668 GWEN_BUFFER *tbuf;
669 const char *s;
670 TYPEMAKER2_VIRTUALFN *vf;
671
672 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
673
674 GWEN_Buffer_AppendString(tbuf, "/* getters for virtual functions */\n");
675 vf=Typemaker2_VirtualFn_List_First(fns);
676 while (vf) {
677 int access=Typemaker2_VirtualFn_GetAccess(vf);
678
679 s=Typemaker2_TypeManager_GetApiDeclaration(tym);
680 if (s && *s) {
681 GWEN_Buffer_AppendString(tbuf, s);
682 GWEN_Buffer_AppendString(tbuf, " ");
683 }
684
685 s=Typemaker2_Type_GetIdentifier(ty);
686 GWEN_Buffer_AppendString(tbuf, s);
687 GWEN_Buffer_AppendString(tbuf, "_");
688 s=Typemaker2_VirtualFn_GetName(vf);
689 if (!(s && *s)) {
690 GWEN_Buffer_free(tbuf);
691 return GWEN_ERROR_BAD_DATA;
692 }
693 while (*s)
694 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
695 GWEN_Buffer_AppendString(tbuf, "_FN ");
696
697 s=Typemaker2_Type_GetPrefix(ty);
698 GWEN_Buffer_AppendString(tbuf, s);
699 GWEN_Buffer_AppendString(tbuf, "_Get");
700 s=Typemaker2_VirtualFn_GetName(vf);
701 if (!(s && *s)) {
702 GWEN_Buffer_free(tbuf);
703 return GWEN_ERROR_BAD_DATA;
704 }
705 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
706 GWEN_Buffer_AppendString(tbuf, s+1);
707 GWEN_Buffer_AppendString(tbuf, "Fn(const ");
708
709 s=Typemaker2_Type_GetIdentifier(ty);
710 GWEN_Buffer_AppendString(tbuf, s);
711 /* created structs are always pointers */
712 GWEN_Buffer_AppendString(tbuf, " *p_struct);\n");
713
714 Typemaker2_Builder_AddDeclaration(tb, access, GWEN_Buffer_GetStart(tbuf));
715 GWEN_Buffer_Reset(tbuf);
716
717 vf=Typemaker2_VirtualFn_List_Next(vf);
718 }
719 GWEN_Buffer_free(tbuf);
720 }
721
722 return 0;
723}
724
725
726
727int TM2C_BuildGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
728{
729 TYPEMAKER2_VIRTUALFN_LIST *fns;
730
731 fns=Typemaker2_Type_GetVirtualFns(ty);
732
733 assert(fns);
734 if (Typemaker2_VirtualFn_List_GetCount(fns)) {
735 GWEN_BUFFER *tbuf;
736 const char *s;
737 TYPEMAKER2_VIRTUALFN *vf;
738
739 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
740
741 GWEN_Buffer_AppendString(tbuf, "/* getters for virtual functions */\n");
742 vf=Typemaker2_VirtualFn_List_First(fns);
743 while (vf) {
744
745 s=Typemaker2_Type_GetIdentifier(ty);
746 GWEN_Buffer_AppendString(tbuf, s);
747 GWEN_Buffer_AppendString(tbuf, "_");
748
749 s=Typemaker2_VirtualFn_GetName(vf);
750 if (!(s && *s)) {
751 GWEN_Buffer_free(tbuf);
752 return GWEN_ERROR_BAD_DATA;
753 }
754 while (*s)
755 GWEN_Buffer_AppendByte(tbuf, toupper(*(s++)));
756 GWEN_Buffer_AppendString(tbuf, "_FN ");
757
758 s=Typemaker2_Type_GetPrefix(ty);
759 GWEN_Buffer_AppendString(tbuf, s);
760 GWEN_Buffer_AppendString(tbuf, "_Get");
761 s=Typemaker2_VirtualFn_GetName(vf);
762 if (!(s && *s)) {
763 GWEN_Buffer_free(tbuf);
764 return GWEN_ERROR_BAD_DATA;
765 }
766 GWEN_Buffer_AppendByte(tbuf, toupper(*s));
767 GWEN_Buffer_AppendString(tbuf, s+1);
768 GWEN_Buffer_AppendString(tbuf, "Fn(const ");
769
770 s=Typemaker2_Type_GetIdentifier(ty);
771 GWEN_Buffer_AppendString(tbuf, s);
772 /* created structs are always pointers */
773 GWEN_Buffer_AppendString(tbuf, " *p_struct){\n");
774
775 GWEN_Buffer_AppendString(tbuf, " assert(p_struct);\n");
776 GWEN_Buffer_AppendString(tbuf, " return p_struct->");
777 s=Typemaker2_VirtualFn_GetName(vf);
778 if (!(s && *s)) {
779 GWEN_Buffer_free(tbuf);
780 return GWEN_ERROR_BAD_DATA;
781 }
782 GWEN_Buffer_AppendString(tbuf, s);
783 GWEN_Buffer_AppendString(tbuf, "Fn;\n");
784
785 GWEN_Buffer_AppendString(tbuf, "}\n");
786
787 Typemaker2_Builder_AddCode(tb, GWEN_Buffer_GetStart(tbuf));
788 GWEN_Buffer_Reset(tbuf);
789
790 vf=Typemaker2_VirtualFn_List_Next(vf);
791 }
792 }
793
794 return 0;
795}
796
797
798
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:42
GWEN_Buffer_AppendArgs
int GWEN_Buffer_AppendArgs(GWEN_BUFFER *bf, const char *fmt,...)
Definition: buffer.c:1084
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:650
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:394
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
GWEN_ERROR_BAD_DATA
#define GWEN_ERROR_BAD_DATA
Definition: error.h:121
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition: logger.h:35
tm2c_misc.h
TM2C_BuildDefineVirtualFns
int TM2C_BuildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
Definition: tm2c_virtualfn.c:24
TM2C_BuildProtoVirtualFns
int TM2C_BuildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:129
TM2C_BuildProtoSetterVirtualFns
int TM2C_BuildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:453
TM2C_BuildGetterVirtualFns
int TM2C_BuildGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:727
TM2C_BuildProtoGetterVirtualFns
int TM2C_BuildProtoGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:658
TM2C_BuildSetterVirtualFns
int TM2C_BuildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:551
TM2C_BuildCodeVirtualFns
int TM2C_BuildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:300
tm2c_virtualfn.h
Typemaker2_Builder_AddCode
void Typemaker2_Builder_AddCode(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:204
Typemaker2_Builder_AddPublicDeclaration
void Typemaker2_Builder_AddPublicDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:172
Typemaker2_Builder_AddLibraryDeclaration
void Typemaker2_Builder_AddLibraryDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:180
Typemaker2_Builder_AddProtectedDeclaration
void Typemaker2_Builder_AddProtectedDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:188
Typemaker2_Builder_AddDeclaration
void Typemaker2_Builder_AddDeclaration(TYPEMAKER2_BUILDER *tb, int access, const char *s)
Definition: tm_builder.c:149
Typemaker2_Builder_AddPrivateDeclaration
void Typemaker2_Builder_AddPrivateDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:196
Typemaker2_Builder_GetTypeManager
TYPEMAKER2_TYPEMANAGER * Typemaker2_Builder_GetTypeManager(const TYPEMAKER2_BUILDER *tb)
Definition: tm_builder.c:133
TYPEMAKER2_BUILDER
struct TYPEMAKER2_BUILDER TYPEMAKER2_BUILDER
Definition: tm_builder.h:26
Typemaker2_Type_GetIdentifier
const char * Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:543
Typemaker2_Type_GetVirtualFns
TYPEMAKER2_VIRTUALFN_LIST * Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:695
Typemaker2_Type_GetPrefix
const char * Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:565
TYPEMAKER2_TYPE
struct TYPEMAKER2_TYPE TYPEMAKER2_TYPE
Definition: tm_type.h:21
TYPEMAKER2_FLAGS_CONST
#define TYPEMAKER2_FLAGS_CONST
Definition: tm_type.h:33
TypeMaker2_Access_Private
@ TypeMaker2_Access_Private
Definition: tm_type.h:89
TypeMaker2_Access_Library
@ TypeMaker2_Access_Library
Definition: tm_type.h:88
TypeMaker2_Access_Protected
@ TypeMaker2_Access_Protected
Definition: tm_type.h:87
TypeMaker2_Access_Public
@ TypeMaker2_Access_Public
Definition: tm_type.h:86
TYPEMAKER2_FLAGS_GWEN_CB
#define TYPEMAKER2_FLAGS_GWEN_CB
Definition: tm_type.h:50
Typemaker2_TypeManager_GetApiDeclaration
const char * Typemaker2_TypeManager_GetApiDeclaration(const TYPEMAKER2_TYPEMANAGER *tym)
Definition: tm_typemanager.c:82
TYPEMAKER2_TYPEMANAGER
struct TYPEMAKER2_TYPEMANAGER TYPEMAKER2_TYPEMANAGER
Definition: tm_typemanager.h:19
Typemaker2_VirtualFn_GetName
const char * Typemaker2_VirtualFn_GetName(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:170
Typemaker2_VirtualFn_GetDescr
const char * Typemaker2_VirtualFn_GetDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:218
Typemaker2_VirtualFn_GetDefaultReturnValue
const char * Typemaker2_VirtualFn_GetDefaultReturnValue(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:346
Typemaker2_VirtualFn_GetReturnTypeDescr
const char * Typemaker2_VirtualFn_GetReturnTypeDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:326
Typemaker2_VirtualFn_GetLocation
const char * Typemaker2_VirtualFn_GetLocation(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:194
Typemaker2_VirtualFn_Param_GetDescr
const char * Typemaker2_VirtualFn_Param_GetDescr(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:478
Typemaker2_VirtualFn_Param_GetType
const char * Typemaker2_VirtualFn_Param_GetType(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:458
Typemaker2_VirtualFn_Param_GetName
const char * Typemaker2_VirtualFn_Param_GetName(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:438
Typemaker2_VirtualFn_GetFlags
uint32_t Typemaker2_VirtualFn_GetFlags(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:242
Typemaker2_VirtualFn_GetAccess
int Typemaker2_VirtualFn_GetAccess(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:282
Typemaker2_VirtualFn_GetParamTypeList
TYPEMAKER2_VIRTUALFN_PARAM_LIST * Typemaker2_VirtualFn_GetParamTypeList(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:370
Typemaker2_VirtualFn_GetReturnType
const char * Typemaker2_VirtualFn_GetReturnType(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:302
TYPEMAKER2_VIRTUALFN
struct TYPEMAKER2_VIRTUALFN TYPEMAKER2_VIRTUALFN
Definition: tm_virtualfn.h:21
TYPEMAKER2_VIRTUALFN_PARAM
struct TYPEMAKER2_VIRTUALFN_PARAM TYPEMAKER2_VIRTUALFN_PARAM
Definition: tm_virtualfn.h:24
Generated by doxygen 1.9.5