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 
24 int 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 
129 int 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 
300 int 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 
453 int 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 
551 int 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 
658 int 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 
727 int 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 
Typemaker2_VirtualFn_GetReturnTypeDescr
const char * Typemaker2_VirtualFn_GetReturnTypeDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:326
Typemaker2_Builder_GetTypeManager
TYPEMAKER2_TYPEMANAGER * Typemaker2_Builder_GetTypeManager(const TYPEMAKER2_BUILDER *tb)
Definition: tm_builder.c:133
Typemaker2_Type_GetVirtualFns
TYPEMAKER2_VIRTUALFN_LIST * Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:695
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
TypeMaker2_Access_Library
Definition: tm_type.h:88
Typemaker2_VirtualFn_GetParamTypeList
TYPEMAKER2_VIRTUALFN_PARAM_LIST * Typemaker2_VirtualFn_GetParamTypeList(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:370
TYPEMAKER2_VIRTUALFN_PARAM
struct TYPEMAKER2_VIRTUALFN_PARAM TYPEMAKER2_VIRTUALFN_PARAM
Definition: tm_virtualfn.h:24
TM2C_BuildSetterVirtualFns
int TM2C_BuildSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:551
Typemaker2_VirtualFn_Param_GetDescr
const char * Typemaker2_VirtualFn_Param_GetDescr(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:478
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition: logger.h:35
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:42
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:650
Typemaker2_Builder_AddPrivateDeclaration
void Typemaker2_Builder_AddPrivateDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:196
TM2C_BuildCodeVirtualFns
int TM2C_BuildCodeVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:300
TYPEMAKER2_VIRTUALFN
struct TYPEMAKER2_VIRTUALFN TYPEMAKER2_VIRTUALFN
Definition: tm_virtualfn.h:21
GWEN_ERROR_BAD_DATA
#define GWEN_ERROR_BAD_DATA
Definition: error.h:121
Typemaker2_VirtualFn_Param_GetType
const char * Typemaker2_VirtualFn_Param_GetType(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:458
TM2C_BuildProtoSetterVirtualFns
int TM2C_BuildProtoSetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:453
TYPEMAKER2_FLAGS_GWEN_CB
#define TYPEMAKER2_FLAGS_GWEN_CB
Definition: tm_type.h:50
Typemaker2_Builder_AddDeclaration
void Typemaker2_Builder_AddDeclaration(TYPEMAKER2_BUILDER *tb, int access, const char *s)
Definition: tm_builder.c:149
Typemaker2_VirtualFn_GetReturnType
const char * Typemaker2_VirtualFn_GetReturnType(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:302
TM2C_BuildDefineVirtualFns
int TM2C_BuildDefineVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty, const char *loc)
Definition: tm2c_virtualfn.c:24
Typemaker2_VirtualFn_GetDescr
const char * Typemaker2_VirtualFn_GetDescr(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:218
Typemaker2_Type_GetIdentifier
const char * Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:543
Typemaker2_Builder_AddProtectedDeclaration
void Typemaker2_Builder_AddProtectedDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:188
GWEN_Buffer_AppendArgs
int GWEN_Buffer_AppendArgs(GWEN_BUFFER *bf, const char *fmt,...)
Definition: buffer.c:1084
Typemaker2_VirtualFn_GetLocation
const char * Typemaker2_VirtualFn_GetLocation(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:194
GWEN_Buffer_AppendByte
int GWEN_Buffer_AppendByte(GWEN_BUFFER *bf, char c)
Definition: buffer.c:394
Typemaker2_VirtualFn_GetDefaultReturnValue
const char * Typemaker2_VirtualFn_GetDefaultReturnValue(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:346
TYPEMAKER2_FLAGS_CONST
#define TYPEMAKER2_FLAGS_CONST
Definition: tm_type.h:33
TYPEMAKER2_BUILDER
struct TYPEMAKER2_BUILDER TYPEMAKER2_BUILDER
Definition: tm_builder.h:26
TM2C_BuildProtoGetterVirtualFns
int TM2C_BuildProtoGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:658
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
Typemaker2_VirtualFn_Param_GetName
const char * Typemaker2_VirtualFn_Param_GetName(const TYPEMAKER2_VIRTUALFN_PARAM *prm)
Definition: tm_virtualfn.c:438
Typemaker2_Builder_AddCode
void Typemaker2_Builder_AddCode(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:204
TypeMaker2_Access_Private
Definition: tm_type.h:89
TypeMaker2_Access_Public
Definition: tm_type.h:86
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
TYPEMAKER2_TYPE
struct TYPEMAKER2_TYPE TYPEMAKER2_TYPE
Definition: tm_type.h:21
Typemaker2_Builder_AddPublicDeclaration
void Typemaker2_Builder_AddPublicDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:172
TYPEMAKER2_TYPEMANAGER
struct TYPEMAKER2_TYPEMANAGER TYPEMAKER2_TYPEMANAGER
Definition: tm_typemanager.h:19
tm2c_misc.h
TM2C_BuildGetterVirtualFns
int TM2C_BuildGetterVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:727
TypeMaker2_Access_Protected
Definition: tm_type.h:87
Typemaker2_Builder_AddLibraryDeclaration
void Typemaker2_Builder_AddLibraryDeclaration(TYPEMAKER2_BUILDER *tb, const char *s)
Definition: tm_builder.c:180
Typemaker2_Type_GetPrefix
const char * Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE *ty)
Definition: tm_type.c:565
Typemaker2_TypeManager_GetApiDeclaration
const char * Typemaker2_TypeManager_GetApiDeclaration(const TYPEMAKER2_TYPEMANAGER *tym)
Definition: tm_typemanager.c:82
Typemaker2_VirtualFn_GetFlags
uint32_t Typemaker2_VirtualFn_GetFlags(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:242
tm2c_virtualfn.h
Typemaker2_VirtualFn_GetName
const char * Typemaker2_VirtualFn_GetName(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:170
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
TM2C_BuildProtoVirtualFns
int TM2C_BuildProtoVirtualFns(TYPEMAKER2_BUILDER *tb, TYPEMAKER2_TYPE *ty)
Definition: tm2c_virtualfn.c:129
Typemaker2_VirtualFn_GetAccess
int Typemaker2_VirtualFn_GetAccess(const TYPEMAKER2_VIRTUALFN *vf)
Definition: tm_virtualfn.c:282
Generated by   doxygen 1.8.14