1 /***************************************************************************
2 begin : Wed Jul 01 2009
3 copyright : (C) 2009 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 "tm_type_p.h"
16 #include "tm_util.h"
17
18 #include <gwenhywfar/debug.h>
19 #include <gwenhywfar/misc.h>
20
21 #include <assert.h>
22
23
24
25
26 GWEN_LIST_FUNCTIONS(TYPEMAKER2_TYPE, Typemaker2_Type);
27 GWEN_LIST2_FUNCTIONS(TYPEMAKER2_TYPE, Typemaker2_Type);
28
29
30
31
Typemaker2_Type_new()32 TYPEMAKER2_TYPE *Typemaker2_Type_new()
33 {
34 TYPEMAKER2_TYPE *ty;
35
36 GWEN_NEW_OBJECT(TYPEMAKER2_TYPE, ty);
37 ty->refCount=1;
38 GWEN_LIST_INIT(TYPEMAKER2_TYPE, ty);
39
40 ty->headers=Typemaker2_Header_List_new();
41 ty->enums=Typemaker2_Enum_List_new();
42 ty->defines=Typemaker2_Define_List_new();
43 ty->codeDefs=Typemaker2_Code_List_new();
44 ty->inlines=Typemaker2_Inline_List_new();
45 ty->virtualFns=Typemaker2_VirtualFn_List_new();
46 ty->signals=Typemaker2_Signal_List_new();
47 ty->slots=Typemaker2_Slot_List_new();
48
49 ty->structIncludes=GWEN_StringList_new();
50 ty->privateIncludes=GWEN_StringList_new();
51 ty->libraryIncludes=GWEN_StringList_new();
52 ty->publicIncludes=GWEN_StringList_new();
53 ty->codeIncludes=GWEN_StringList_new();
54
55 ty->members=Typemaker2_Member_List_new();
56
57 ty->groupTree=Typemaker2_Group_Tree_new();
58
59
60 return ty;
61 }
62
63
64
Typemaker2_Type_free(TYPEMAKER2_TYPE * ty)65 void Typemaker2_Type_free(TYPEMAKER2_TYPE *ty)
66 {
67 if (ty) {
68 assert(ty->refCount);
69 if (ty->refCount==1) {
70 GWEN_LIST_FINI(TYPEMAKER2_TYPE, ty);
71 free(ty->name);
72 free(ty->extends);
73 free(ty->baseType);
74 free(ty->inherits);
75 free(ty->identifier);
76 free(ty->prefix);
77
78 free(ty->defaultValue);
79 free(ty->presetValue);
80
81 free(ty->aqdb_type);
82 free(ty->baseFileName);
83
84 free(ty->freeHook);
85
86 free(ty->descr);
87
88 Typemaker2_Header_List_free(ty->headers);
89 Typemaker2_Enum_List_free(ty->enums);
90 Typemaker2_Define_List_free(ty->defines);
91 Typemaker2_Code_List_free(ty->codeDefs);
92 Typemaker2_Inline_List_free(ty->inlines);
93 Typemaker2_VirtualFn_List_free(ty->virtualFns);
94 Typemaker2_Signal_List_free(ty->signals);
95 Typemaker2_Slot_List_free(ty->slots);
96
97 GWEN_StringList_free(ty->structIncludes);
98 GWEN_StringList_free(ty->privateIncludes);
99 GWEN_StringList_free(ty->libraryIncludes);
100 GWEN_StringList_free(ty->publicIncludes);
101 GWEN_StringList_free(ty->codeIncludes);
102
103 Typemaker2_Member_List_free(ty->members);
104 Typemaker2_Group_Tree_free(ty->groupTree);
105
106 free(ty->fieldCountId);
107
108 ty->refCount=0;
109 GWEN_FREE_OBJECT(ty);
110 }
111 else
112 ty->refCount--;
113 }
114 }
115
116
117
Typemaker2_Type_Attach(TYPEMAKER2_TYPE * ty)118 void Typemaker2_Type_Attach(TYPEMAKER2_TYPE *ty)
119 {
120 assert(ty);
121 assert(ty->refCount);
122 ty->refCount++;
123 }
124
125
126
Typemaker2_Type_GetName(const TYPEMAKER2_TYPE * ty)127 const char *Typemaker2_Type_GetName(const TYPEMAKER2_TYPE *ty)
128 {
129 assert(ty);
130 assert(ty->refCount);
131 return ty->name;
132 }
133
134
135
Typemaker2_Type_SetName(TYPEMAKER2_TYPE * ty,const char * s)136 void Typemaker2_Type_SetName(TYPEMAKER2_TYPE *ty, const char *s)
137 {
138 assert(ty);
139 assert(ty->refCount);
140 free(ty->name);
141 if (s && *s)
142 ty->name=strdup(s);
143 else
144 ty->name=NULL;
145 }
146
147
148
Typemaker2_Type_GetDescription(const TYPEMAKER2_TYPE * ty)149 const char *Typemaker2_Type_GetDescription(const TYPEMAKER2_TYPE *ty)
150 {
151 assert(ty);
152 assert(ty->refCount);
153 return ty->descr;
154 }
155
156
157
Typemaker2_Type_SetDescription(TYPEMAKER2_TYPE * ty,const char * s)158 void Typemaker2_Type_SetDescription(TYPEMAKER2_TYPE *ty, const char *s)
159 {
160 assert(ty);
161 assert(ty->refCount);
162 free(ty->descr);
163 if (s && *s)
164 ty->descr=strdup(s);
165 else
166 ty->descr=NULL;
167 }
168
169
170
Typemaker2_Type_GetType(const TYPEMAKER2_TYPE * ty)171 int Typemaker2_Type_GetType(const TYPEMAKER2_TYPE *ty)
172 {
173 assert(ty);
174 assert(ty->refCount);
175
176 /* nothing here? ask extended type */
177 if (ty->type==TypeMaker2_Type_Unknown &&
178 ty->extendsPtr)
179 return Typemaker2_Type_GetType(ty->extendsPtr);
180
181 return ty->type;
182 }
183
184
185
Typemaker2_Type_SetType(TYPEMAKER2_TYPE * ty,int i)186 void Typemaker2_Type_SetType(TYPEMAKER2_TYPE *ty, int i)
187 {
188 assert(ty);
189 assert(ty->refCount);
190 ty->type=i;
191 }
192
193
194
Typemaker2_Type_GetAqDbType(const TYPEMAKER2_TYPE * ty)195 const char *Typemaker2_Type_GetAqDbType(const TYPEMAKER2_TYPE *ty)
196 {
197 assert(ty);
198 assert(ty->refCount);
199
200 if (ty->aqdb_type==NULL && ty->extendsPtr)
201 return Typemaker2_Type_GetAqDbType(ty->extendsPtr);
202
203 return ty->aqdb_type;
204 }
205
206
207
Typemaker2_Type_SetAqDbType(TYPEMAKER2_TYPE * ty,const char * s)208 void Typemaker2_Type_SetAqDbType(TYPEMAKER2_TYPE *ty, const char *s)
209 {
210 assert(ty);
211 assert(ty->refCount);
212 free(ty->aqdb_type);
213 if (s && *s)
214 ty->aqdb_type=strdup(s);
215 else
216 ty->aqdb_type=NULL;
217 }
218
219
220
Typemaker2_Type_GetBaseFileName(const TYPEMAKER2_TYPE * ty)221 const char *Typemaker2_Type_GetBaseFileName(const TYPEMAKER2_TYPE *ty)
222 {
223 assert(ty);
224 assert(ty->refCount);
225
226 return ty->baseFileName;
227 }
228
229
230
Typemaker2_Type_SetBaseFileName(TYPEMAKER2_TYPE * ty,const char * s)231 void Typemaker2_Type_SetBaseFileName(TYPEMAKER2_TYPE *ty, const char *s)
232 {
233 assert(ty);
234 assert(ty->refCount);
235 free(ty->baseFileName);
236 if (s && *s)
237 ty->baseFileName=strdup(s);
238 else
239 ty->baseFileName=NULL;
240 }
241
242
243
Typemaker2_Type_GetFreeHook(const TYPEMAKER2_TYPE * ty)244 const char *Typemaker2_Type_GetFreeHook(const TYPEMAKER2_TYPE *ty)
245 {
246 assert(ty);
247 assert(ty->refCount);
248
249 return ty->freeHook;
250 }
251
252
253
Typemaker2_Type_SetFreeHook(TYPEMAKER2_TYPE * ty,const char * s)254 void Typemaker2_Type_SetFreeHook(TYPEMAKER2_TYPE *ty, const char *s)
255 {
256 assert(ty);
257 assert(ty->refCount);
258 free(ty->freeHook);
259 if (s && *s)
260 ty->freeHook=strdup(s);
261 else
262 ty->freeHook=NULL;
263 }
264
265
266
Typemaker2_Type_GetExtends(const TYPEMAKER2_TYPE * ty)267 const char *Typemaker2_Type_GetExtends(const TYPEMAKER2_TYPE *ty)
268 {
269 assert(ty);
270 assert(ty->refCount);
271 return ty->extends;
272 }
273
274
275
Typemaker2_Type_SetExtends(TYPEMAKER2_TYPE * ty,const char * s)276 void Typemaker2_Type_SetExtends(TYPEMAKER2_TYPE *ty, const char *s)
277 {
278 assert(ty);
279 assert(ty->refCount);
280 free(ty->extends);
281 if (s && *s)
282 ty->extends=strdup(s);
283 else
284 ty->extends=NULL;
285 }
286
287
288
Typemaker2_Type_GetBaseType(const TYPEMAKER2_TYPE * ty)289 const char *Typemaker2_Type_GetBaseType(const TYPEMAKER2_TYPE *ty)
290 {
291 assert(ty);
292 assert(ty->refCount);
293
294 if (ty->baseType==NULL && ty->extendsPtr)
295 return Typemaker2_Type_GetBaseType(ty->extendsPtr);
296
297 return ty->baseType;
298 }
299
300
301
Typemaker2_Type_SetBaseType(TYPEMAKER2_TYPE * ty,const char * s)302 void Typemaker2_Type_SetBaseType(TYPEMAKER2_TYPE *ty, const char *s)
303 {
304 assert(ty);
305 assert(ty->refCount);
306 free(ty->baseType);
307 if (s && *s)
308 ty->baseType=strdup(s);
309 else
310 ty->baseType=NULL;
311 }
312
313
314
Typemaker2_Type_GetInherits(const TYPEMAKER2_TYPE * ty)315 const char *Typemaker2_Type_GetInherits(const TYPEMAKER2_TYPE *ty)
316 {
317 assert(ty);
318 assert(ty->refCount);
319
320 if (ty->inherits==NULL && ty->extendsPtr)
321 return Typemaker2_Type_GetInherits(ty->extendsPtr);
322
323 return ty->inherits;
324 }
325
326
327
Typemaker2_Type_SetInherits(TYPEMAKER2_TYPE * ty,const char * s)328 void Typemaker2_Type_SetInherits(TYPEMAKER2_TYPE *ty, const char *s)
329 {
330 assert(ty);
331 assert(ty->refCount);
332 free(ty->inherits);
333 if (s && *s)
334 ty->inherits=strdup(s);
335 else
336 ty->inherits=NULL;
337 }
338
339
340
Typemaker2_Type_GetFlags(const TYPEMAKER2_TYPE * ty)341 uint32_t Typemaker2_Type_GetFlags(const TYPEMAKER2_TYPE *ty)
342 {
343 assert(ty);
344 assert(ty->refCount);
345
346 if (ty->flags==0 && ty->extendsPtr)
347 return Typemaker2_Type_GetFlags(ty->extendsPtr);
348
349 return ty->flags;
350 }
351
352
353
Typemaker2_Type_SetFlags(TYPEMAKER2_TYPE * ty,uint32_t i)354 void Typemaker2_Type_SetFlags(TYPEMAKER2_TYPE *ty, uint32_t i)
355 {
356 assert(ty);
357 assert(ty->refCount);
358 ty->flags=i;
359 }
360
361
362
Typemaker2_Type_GetSetFlags(const TYPEMAKER2_TYPE * ty)363 uint32_t Typemaker2_Type_GetSetFlags(const TYPEMAKER2_TYPE *ty)
364 {
365 assert(ty);
366 assert(ty->refCount);
367
368 if (ty->setFlags==0 && ty->extendsPtr)
369 return Typemaker2_Type_GetSetFlags(ty->extendsPtr);
370
371 return ty->setFlags;
372 }
373
374
375
Typemaker2_Type_SetSetFlags(TYPEMAKER2_TYPE * ty,uint32_t i)376 void Typemaker2_Type_SetSetFlags(TYPEMAKER2_TYPE *ty, uint32_t i)
377 {
378 assert(ty);
379 assert(ty->refCount);
380 ty->setFlags=i;
381 }
382
383
384
Typemaker2_Type_GetGetFlags(const TYPEMAKER2_TYPE * ty)385 uint32_t Typemaker2_Type_GetGetFlags(const TYPEMAKER2_TYPE *ty)
386 {
387 assert(ty);
388 assert(ty->refCount);
389
390 if (ty->getFlags==0 && ty->extendsPtr)
391 return Typemaker2_Type_GetGetFlags(ty->extendsPtr);
392
393 return ty->getFlags;
394 }
395
396
397
Typemaker2_Type_SetGetFlags(TYPEMAKER2_TYPE * ty,uint32_t i)398 void Typemaker2_Type_SetGetFlags(TYPEMAKER2_TYPE *ty, uint32_t i)
399 {
400 assert(ty);
401 assert(ty->refCount);
402 ty->getFlags=i;
403 }
404
405
406
Typemaker2_Type_GetDupFlags(const TYPEMAKER2_TYPE * ty)407 uint32_t Typemaker2_Type_GetDupFlags(const TYPEMAKER2_TYPE *ty)
408 {
409 assert(ty);
410 assert(ty->refCount);
411
412 if (ty->dupFlags==0 && ty->extendsPtr)
413 return Typemaker2_Type_GetDupFlags(ty->extendsPtr);
414
415 return ty->dupFlags;
416 }
417
418
419
Typemaker2_Type_SetDupFlags(TYPEMAKER2_TYPE * ty,uint32_t i)420 void Typemaker2_Type_SetDupFlags(TYPEMAKER2_TYPE *ty, uint32_t i)
421 {
422 assert(ty);
423 assert(ty->refCount);
424 ty->dupFlags=i;
425 }
426
427
428
Typemaker2_Type_GetCopyFlags(const TYPEMAKER2_TYPE * ty)429 uint32_t Typemaker2_Type_GetCopyFlags(const TYPEMAKER2_TYPE *ty)
430 {
431 assert(ty);
432 assert(ty->refCount);
433
434 if (ty->copyFlags==0 && ty->extendsPtr)
435 return Typemaker2_Type_GetCopyFlags(ty->extendsPtr);
436
437 return ty->copyFlags;
438 }
439
440
441
Typemaker2_Type_SetCopyFlags(TYPEMAKER2_TYPE * ty,uint32_t i)442 void Typemaker2_Type_SetCopyFlags(TYPEMAKER2_TYPE *ty, uint32_t i)
443 {
444 assert(ty);
445 assert(ty->refCount);
446 ty->copyFlags=i;
447 }
448
449
450
Typemaker2_Type_GetAccess(const TYPEMAKER2_TYPE * ty)451 int Typemaker2_Type_GetAccess(const TYPEMAKER2_TYPE *ty)
452 {
453 assert(ty);
454 assert(ty->refCount);
455
456 if (ty->access==TypeMaker2_Access_Unknown && ty->extendsPtr)
457 return Typemaker2_Type_GetAccess(ty->extendsPtr);
458
459 return ty->access;
460 }
461
462
463
Typemaker2_Type_SetAccess(TYPEMAKER2_TYPE * ty,int i)464 void Typemaker2_Type_SetAccess(TYPEMAKER2_TYPE *ty, int i)
465 {
466 assert(ty);
467 assert(ty->refCount);
468 ty->access=i;
469 }
470
471
472
Typemaker2_Type_GetUsePrivateConstructor(const TYPEMAKER2_TYPE * ty)473 int Typemaker2_Type_GetUsePrivateConstructor(const TYPEMAKER2_TYPE *ty)
474 {
475 assert(ty);
476 assert(ty->refCount);
477 return ty->usePrivateConstructor;
478 }
479
480
481
Typemaker2_Type_SetUsePrivateConstructor(TYPEMAKER2_TYPE * ty,int i)482 void Typemaker2_Type_SetUsePrivateConstructor(TYPEMAKER2_TYPE *ty, int i)
483 {
484 assert(ty);
485 assert(ty->refCount);
486 ty->usePrivateConstructor=i;
487 }
488
489
490
Typemaker2_Type_GetDefaultValue(const TYPEMAKER2_TYPE * ty)491 const char *Typemaker2_Type_GetDefaultValue(const TYPEMAKER2_TYPE *ty)
492 {
493 assert(ty);
494 assert(ty->refCount);
495
496 if (ty->defaultValue==NULL && ty->extendsPtr)
497 return Typemaker2_Type_GetDefaultValue(ty->extendsPtr);
498
499 return ty->defaultValue;
500 }
501
502
503
Typemaker2_Type_SetDefaultValue(TYPEMAKER2_TYPE * ty,const char * s)504 void Typemaker2_Type_SetDefaultValue(TYPEMAKER2_TYPE *ty, const char *s)
505 {
506 assert(ty);
507 assert(ty->refCount);
508 free(ty->defaultValue);
509 if (s && *s)
510 ty->defaultValue=strdup(s);
511 else
512 ty->defaultValue=NULL;
513 }
514
515
516
Typemaker2_Type_GetPresetValue(const TYPEMAKER2_TYPE * ty)517 const char *Typemaker2_Type_GetPresetValue(const TYPEMAKER2_TYPE *ty)
518 {
519 assert(ty);
520 assert(ty->refCount);
521
522 if (ty->presetValue==NULL && ty->extendsPtr)
523 return Typemaker2_Type_GetPresetValue(ty->extendsPtr);
524
525 return ty->presetValue;
526 }
527
528
529
Typemaker2_Type_SetPresetValue(TYPEMAKER2_TYPE * ty,const char * s)530 void Typemaker2_Type_SetPresetValue(TYPEMAKER2_TYPE *ty, const char *s)
531 {
532 assert(ty);
533 assert(ty->refCount);
534 free(ty->presetValue);
535 if (s && *s)
536 ty->presetValue=strdup(s);
537 else
538 ty->presetValue=NULL;
539 }
540
541
542
Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE * ty)543 const char *Typemaker2_Type_GetIdentifier(const TYPEMAKER2_TYPE *ty)
544 {
545 assert(ty);
546 assert(ty->refCount);
547 return ty->identifier;
548 }
549
550
551
Typemaker2_Type_SetIdentifier(TYPEMAKER2_TYPE * ty,const char * s)552 void Typemaker2_Type_SetIdentifier(TYPEMAKER2_TYPE *ty, const char *s)
553 {
554 assert(ty);
555 assert(ty->refCount);
556 free(ty->identifier);
557 if (s && *s)
558 ty->identifier=strdup(s);
559 else
560 ty->identifier=NULL;
561 }
562
563
564
Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE * ty)565 const char *Typemaker2_Type_GetPrefix(const TYPEMAKER2_TYPE *ty)
566 {
567 assert(ty);
568 assert(ty->refCount);
569 return ty->prefix;
570 }
571
572
573
Typemaker2_Type_SetPrefix(TYPEMAKER2_TYPE * ty,const char * s)574 void Typemaker2_Type_SetPrefix(TYPEMAKER2_TYPE *ty, const char *s)
575 {
576 assert(ty);
577 assert(ty->refCount);
578 free(ty->prefix);
579 if (s && *s)
580 ty->prefix=strdup(s);
581 else
582 ty->prefix=NULL;
583 }
584
585
586
Typemaker2_Type_GetExtendsPtr(const TYPEMAKER2_TYPE * ty)587 TYPEMAKER2_TYPE *Typemaker2_Type_GetExtendsPtr(const TYPEMAKER2_TYPE *ty)
588 {
589 assert(ty);
590 assert(ty->refCount);
591 return ty->extendsPtr;
592 }
593
594
595
Typemaker2_Type_SetExtendsPtr(TYPEMAKER2_TYPE * ty,TYPEMAKER2_TYPE * p)596 void Typemaker2_Type_SetExtendsPtr(TYPEMAKER2_TYPE *ty, TYPEMAKER2_TYPE *p)
597 {
598 assert(ty);
599 assert(ty->refCount);
600 ty->extendsPtr=p;
601 }
602
603
604
Typemaker2_Type_GetInheritsPtr(const TYPEMAKER2_TYPE * ty)605 TYPEMAKER2_TYPE *Typemaker2_Type_GetInheritsPtr(const TYPEMAKER2_TYPE *ty)
606 {
607 assert(ty);
608 assert(ty->refCount);
609 return ty->inheritsPtr;
610 }
611
612
613
Typemaker2_Type_SetInheritsPtr(TYPEMAKER2_TYPE * ty,TYPEMAKER2_TYPE * p)614 void Typemaker2_Type_SetInheritsPtr(TYPEMAKER2_TYPE *ty, TYPEMAKER2_TYPE *p)
615 {
616 assert(ty);
617 assert(ty->refCount);
618 ty->inheritsPtr=p;
619 }
620
621
622
Typemaker2_Type_GetBaseTypePtr(const TYPEMAKER2_TYPE * ty)623 TYPEMAKER2_TYPE *Typemaker2_Type_GetBaseTypePtr(const TYPEMAKER2_TYPE *ty)
624 {
625 assert(ty);
626 assert(ty->refCount);
627 return ty->baseTypePtr;
628 }
629
630
631
Typemaker2_Type_SetBaseTypePtr(TYPEMAKER2_TYPE * ty,TYPEMAKER2_TYPE * p)632 void Typemaker2_Type_SetBaseTypePtr(TYPEMAKER2_TYPE *ty, TYPEMAKER2_TYPE *p)
633 {
634 assert(ty);
635 assert(ty->refCount);
636 ty->baseTypePtr=p;
637 }
638
639
640
Typemaker2_Type_GetMembers(const TYPEMAKER2_TYPE * ty)641 TYPEMAKER2_MEMBER_LIST *Typemaker2_Type_GetMembers(const TYPEMAKER2_TYPE *ty)
642 {
643 assert(ty);
644 assert(ty->refCount);
645 return ty->members;
646 }
647
648
649
Typemaker2_Type_GetHeaders(const TYPEMAKER2_TYPE * ty)650 TYPEMAKER2_HEADER_LIST *Typemaker2_Type_GetHeaders(const TYPEMAKER2_TYPE *ty)
651 {
652 assert(ty);
653 assert(ty->refCount);
654 return ty->headers;
655 }
656
657
658
Typemaker2_Type_GetEnums(const TYPEMAKER2_TYPE * ty)659 TYPEMAKER2_ENUM_LIST *Typemaker2_Type_GetEnums(const TYPEMAKER2_TYPE *ty)
660 {
661 assert(ty);
662 assert(ty->refCount);
663 return ty->enums;
664 }
665
666
667
Typemaker2_Type_GetDefines(const TYPEMAKER2_TYPE * ty)668 TYPEMAKER2_DEFINE_LIST *Typemaker2_Type_GetDefines(const TYPEMAKER2_TYPE *ty)
669 {
670 assert(ty);
671 assert(ty->refCount);
672 return ty->defines;
673 }
674
675
676
Typemaker2_Type_GetCodeDefs(const TYPEMAKER2_TYPE * ty)677 TYPEMAKER2_CODE_LIST *Typemaker2_Type_GetCodeDefs(const TYPEMAKER2_TYPE *ty)
678 {
679 assert(ty);
680 assert(ty->refCount);
681 return ty->codeDefs;
682 }
683
684
685
Typemaker2_Type_GetInlines(const TYPEMAKER2_TYPE * ty)686 TYPEMAKER2_INLINE_LIST *Typemaker2_Type_GetInlines(const TYPEMAKER2_TYPE *ty)
687 {
688 assert(ty);
689 assert(ty->refCount);
690 return ty->inlines;
691 }
692
693
694
Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE * ty)695 TYPEMAKER2_VIRTUALFN_LIST *Typemaker2_Type_GetVirtualFns(const TYPEMAKER2_TYPE *ty)
696 {
697 assert(ty);
698 assert(ty->refCount);
699 return ty->virtualFns;
700 }
701
702
703
Typemaker2_Type_GetSignals(const TYPEMAKER2_TYPE * ty)704 TYPEMAKER2_SIGNAL_LIST *Typemaker2_Type_GetSignals(const TYPEMAKER2_TYPE *ty)
705 {
706 assert(ty);
707 assert(ty->refCount);
708 return ty->signals;
709 }
710
711
712
Typemaker2_Type_GetSlots(const TYPEMAKER2_TYPE * ty)713 TYPEMAKER2_SLOT_LIST *Typemaker2_Type_GetSlots(const TYPEMAKER2_TYPE *ty)
714 {
715 assert(ty);
716 assert(ty->refCount);
717 return ty->slots;
718 }
719
720
721
Typemaker2_Type_GetGroupTree(const TYPEMAKER2_TYPE * ty)722 TYPEMAKER2_GROUP_TREE *Typemaker2_Type_GetGroupTree(const TYPEMAKER2_TYPE *ty)
723 {
724 assert(ty);
725 assert(ty->refCount);
726 return ty->groupTree;
727 }
728
729
730
Typemaker2_Type_GetNonVolatileMemberCount(const TYPEMAKER2_TYPE * ty)731 int Typemaker2_Type_GetNonVolatileMemberCount(const TYPEMAKER2_TYPE *ty)
732 {
733 assert(ty);
734 assert(ty->refCount);
735 return ty->nonVolatileMemberCount;
736 }
737
738
739
Typemaker2_Type_SetNonVolatileMemberCount(TYPEMAKER2_TYPE * ty,int i)740 void Typemaker2_Type_SetNonVolatileMemberCount(TYPEMAKER2_TYPE *ty, int i)
741 {
742 assert(ty);
743 assert(ty->refCount);
744 ty->nonVolatileMemberCount=i;
745 }
746
747
748
Typemaker2_Type_GetFieldCountId(const TYPEMAKER2_TYPE * ty)749 const char *Typemaker2_Type_GetFieldCountId(const TYPEMAKER2_TYPE *ty)
750 {
751 assert(ty);
752 assert(ty->refCount);
753 return ty->fieldCountId;
754 }
755
756
757
Typemaker2_Type_SetFieldCountId(TYPEMAKER2_TYPE * ty,const char * s)758 void Typemaker2_Type_SetFieldCountId(TYPEMAKER2_TYPE *ty, const char *s)
759 {
760 assert(ty);
761 assert(ty->refCount);
762 free(ty->fieldCountId);
763 if (s)
764 ty->fieldCountId=strdup(s);
765 else
766 ty->fieldCountId=NULL;
767 }
768
769
770
771
Typemaker2_Type_readMembersAndGroupsXml(TYPEMAKER2_TYPE * ty,GWEN_XMLNODE * node,TYPEMAKER2_GROUP * parentGroup,const char * wantedLang)772 int Typemaker2_Type_readMembersAndGroupsXml(TYPEMAKER2_TYPE *ty, GWEN_XMLNODE *node, TYPEMAKER2_GROUP *parentGroup,
773 const char *wantedLang)
774 {
775 GWEN_XMLNODE *n;
776
777 /* read members */
778 n=GWEN_XMLNode_GetFirstTag(node);
779 while (n) {
780 const char *s;
781
782 /* get tag name */
783 s=GWEN_XMLNode_GetData(n);
784 if (s) {
785 if (strcasecmp(s, "member")==0) {
786 TYPEMAKER2_MEMBER *tm;
787 int rv;
788
789 tm=Typemaker2_Member_new();
790 rv=Typemaker2_Member_readXml(tm, n, wantedLang);
791 if (rv<0) {
792 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
793 Typemaker2_Member_free(tm);
794 return rv;
795 }
796 /* set current parentGroup as group */
797 Typemaker2_Member_SetGroupPtr(tm, parentGroup);
798
799 Typemaker2_Member_List_Add(tm, ty->members);
800 }
801 else if (strcasecmp(s, "group")==0) {
802 TYPEMAKER2_GROUP *group;
803 int rv;
804
805 /* create and read group */
806 group=Typemaker2_Group_new();
807 rv=Typemaker2_Group_readXml(group, n, wantedLang);
808 if (rv<0) {
809 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
810 Typemaker2_Group_free(group);
811 return rv;
812 }
813 Typemaker2_Group_Tree_AddChild(parentGroup, group);
814
815 /* read sub-groups and -members */
816 rv=Typemaker2_Type_readMembersAndGroupsXml(ty, n, group, wantedLang);
817 if (rv<0) {
818 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
819 return rv;
820 }
821 }
822 }
823
824 n=GWEN_XMLNode_GetNextTag(n);
825 }
826
827 return 0;
828 }
829
830
831
832
Typemaker2_Type_readXml(TYPEMAKER2_TYPE * ty,GWEN_XMLNODE * node,const char * wantedLang)833 int Typemaker2_Type_readXml(TYPEMAKER2_TYPE *ty, GWEN_XMLNODE *node, const char *wantedLang)
834 {
835 GWEN_XMLNODE *langNode=NULL;
836 GWEN_XMLNODE *n;
837 const char *s;
838 TYPEMAKER2_GROUP *rootGroup=NULL;
839
840 /* parse type */
841 s=GWEN_XMLNode_GetProperty(node, "type", "opaque");
842 if (strcasecmp(s, "opaque")==0)
843 Typemaker2_Type_SetType(ty, TypeMaker2_Type_Opaque);
844 else if (strcasecmp(s, "pointer")==0)
845 Typemaker2_Type_SetType(ty, TypeMaker2_Type_Pointer);
846 else if (strcasecmp(s, "array")==0)
847 Typemaker2_Type_SetType(ty, TypeMaker2_Type_Array);
848 else {
849 DBG_ERROR(GWEN_LOGDOMAIN, "Unknown type [%s]", s);
850 return GWEN_ERROR_BAD_DATA;
851 }
852
853 s=GWEN_XMLNode_GetProperty(node, "id", NULL);
854 Typemaker2_Type_SetName(ty, s);
855
856 s=GWEN_XMLNode_GetProperty(node, "extends", NULL);
857 Typemaker2_Type_SetExtends(ty, s);
858
859 s=GWEN_XMLNode_GetProperty(node, "basetype", NULL);
860 Typemaker2_Type_SetBaseType(ty, s);
861
862 if (wantedLang)
863 langNode=GWEN_XMLNode_FindFirstTag(node, "lang", "id", wantedLang);
864 if (langNode==NULL)
865 langNode=node;
866
867 /* read identifier and prefix */
868 s=GWEN_XMLNode_GetCharValue(langNode, "identifier", NULL);
869 Typemaker2_Type_SetIdentifier(ty, s);
870
871 s=GWEN_XMLNode_GetCharValue(langNode, "prefix", NULL);
872 Typemaker2_Type_SetPrefix(ty, s);
873
874 s=GWEN_XMLNode_GetCharValue(langNode, "aqdb_type", NULL);
875 Typemaker2_Type_SetAqDbType(ty, s);
876
877 /* read base file name (used to derive other output filenames) */
878 s=GWEN_XMLNode_GetCharValue(langNode, "basefilename", NULL);
879 Typemaker2_Type_SetBaseFileName(ty, s);
880
881 s=GWEN_XMLNode_GetCharValue(langNode, "freeHook", NULL);
882 Typemaker2_Type_SetFreeHook(ty, s);
883
884 /* read flags. this element exists for <type> elements.
885 * For <typedef> elements the flags are stored in the <defaults> group. */
886 s=GWEN_XMLNode_GetCharValue(langNode, "flags", NULL);
887 if (s && *s)
888 Typemaker2_Type_SetFlags(ty, Typemaker2_TypeFlagsFromString(s));
889
890 /* read headers */
891 n=GWEN_XMLNode_FindFirstTag(langNode, "headers", NULL, NULL);
892 if (n) {
893 GWEN_XMLNODE *nn;
894
895 nn=GWEN_XMLNode_FindFirstTag(n, "header", NULL, NULL);
896 while (nn) {
897 TYPEMAKER2_HEADER *th;
898 int rv;
899
900 th=Typemaker2_Header_new();
901 rv=Typemaker2_Header_readXml(th, nn);
902 if (rv<0) {
903 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
904 Typemaker2_Header_free(th);
905 return rv;
906 }
907 Typemaker2_Header_List_Add(th, ty->headers);
908 nn=GWEN_XMLNode_FindNextTag(nn, "header", NULL, NULL);
909 }
910 }
911
912 /* read description */
913 n=GWEN_XMLNode_FindFirstTag(node, "descr", NULL, NULL);
914 if (n) {
915 GWEN_BUFFER *tbuf;
916 int rv;
917
918 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
919 rv=GWEN_XMLNode_toBuffer(n, tbuf, GWEN_XML_FLAGS_SIMPLE | GWEN_XML_FLAGS_HANDLE_COMMENTS);
920 if (rv<0) {
921 DBG_ERROR(0, "here (%d)", rv);
922 }
923 else {
924 Typemaker2_Type_SetDescription(ty, GWEN_Buffer_GetStart(tbuf));
925 }
926 GWEN_Buffer_free(tbuf);
927 }
928
929 /* create and add root group */
930 Typemaker2_Group_Tree_Clear(ty->groupTree);
931 rootGroup=Typemaker2_Group_new();
932 Typemaker2_Group_SetTitle(rootGroup, Typemaker2_Type_GetName(ty));
933 Typemaker2_Group_SetDescription(rootGroup, Typemaker2_Type_GetDescription(ty));
934
935 Typemaker2_Group_Tree_Add(ty->groupTree, rootGroup);
936
937 /* read members */
938 n=GWEN_XMLNode_FindFirstTag(node, "members", NULL, NULL);
939 if (n) {
940 int rv;
941
942 rv=Typemaker2_Type_readMembersAndGroupsXml(ty, n, rootGroup, wantedLang);
943 if (rv<0) {
944 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
945 return rv;
946 }
947 }
948
949 /* read codedefs */
950 n=GWEN_XMLNode_FindFirstTag(langNode, "codedefs", NULL, NULL);
951 if (n) {
952 GWEN_XMLNODE *nn;
953
954 nn=GWEN_XMLNode_FindFirstTag(n, "codedef", NULL, NULL);
955 while (nn) {
956 TYPEMAKER2_CODE *tc;
957
958 tc=Typemaker2_Code_fromXml(nn);
959 if (tc) {
960 const char *s;
961
962 s=Typemaker2_Code_GetMemberFlagsMask(tc);
963 if (s && *s)
964 Typemaker2_Code_SetMemberFlagsMaskInt(tc, Typemaker2_FlagsFromString(s));
965
966 s=Typemaker2_Code_GetMemberFlagsValue(tc);
967 if (s && *s)
968 Typemaker2_Code_SetMemberFlagsValueInt(tc, Typemaker2_FlagsFromString(s));
969 }
970
971 Typemaker2_Code_List_Add(tc, ty->codeDefs);
972 nn=GWEN_XMLNode_FindNextTag(nn, "codedef", NULL, NULL);
973 }
974 }
975
976 /* read inlines */
977 n=GWEN_XMLNode_FindFirstTag(langNode, "inlines", NULL, NULL);
978 if (n) {
979 GWEN_XMLNODE *nn;
980
981 nn=GWEN_XMLNode_FindFirstTag(n, "inline", NULL, NULL);
982 while (nn) {
983 TYPEMAKER2_INLINE *ti;
984
985 ti=Typemaker2_Inline_fromXml(nn);
986 Typemaker2_Inline_List_Add(ti, ty->inlines);
987 nn=GWEN_XMLNode_FindNextTag(nn, "inline", NULL, NULL);
988 }
989 }
990
991 /* read enums */
992 n=GWEN_XMLNode_FindFirstTag(node, "enums", NULL, NULL);
993 if (n) {
994 GWEN_XMLNODE *nn;
995
996 nn=GWEN_XMLNode_FindFirstTag(n, "enum", NULL, NULL);
997 while (nn) {
998 TYPEMAKER2_ENUM *te;
999 GWEN_XMLNODE *nnn;
1000
1001 te=Typemaker2_Enum_fromXml(nn);
1002
1003 /* read items */
1004 nnn=GWEN_XMLNode_FindFirstTag(nn, "item", NULL, NULL);
1005 while (nnn) {
1006 TYPEMAKER2_ITEM *ti;
1007
1008 ti=Typemaker2_Item_fromXml(nnn);
1009 Typemaker2_Item_List_Add(ti, Typemaker2_Enum_GetItems(te));
1010 nnn=GWEN_XMLNode_FindNextTag(nnn, "item", NULL, NULL);
1011 }
1012
1013 Typemaker2_Enum_List_Add(te, ty->enums);
1014 nn=GWEN_XMLNode_FindNextTag(nn, "enum", NULL, NULL);
1015 }
1016 }
1017
1018 /* read defines */
1019 n=GWEN_XMLNode_FindFirstTag(node, "defines", NULL, NULL);
1020 if (n) {
1021 GWEN_XMLNODE *nn;
1022
1023 nn=GWEN_XMLNode_FindFirstTag(n, "define", NULL, NULL);
1024 while (nn) {
1025 TYPEMAKER2_DEFINE *td;
1026 GWEN_XMLNODE *nnn;
1027
1028 td=Typemaker2_Define_fromXml(nn);
1029
1030 /* read items */
1031 nnn=GWEN_XMLNode_FindFirstTag(nn, "item", NULL, NULL);
1032 while (nnn) {
1033 TYPEMAKER2_ITEM *ti;
1034
1035 ti=Typemaker2_Item_fromXml(nnn);
1036 Typemaker2_Item_List_Add(ti, Typemaker2_Define_GetItems(td));
1037 nnn=GWEN_XMLNode_FindNextTag(nnn, "item", NULL, NULL);
1038 }
1039
1040 Typemaker2_Define_List_Add(td, ty->defines);
1041 nn=GWEN_XMLNode_FindNextTag(nn, "define", NULL, NULL);
1042 }
1043 }
1044
1045 /* read virtual functions */
1046 n=GWEN_XMLNode_FindFirstTag(node, "virtualFns", NULL, NULL);
1047 if (n) {
1048 GWEN_XMLNODE *nn;
1049
1050 nn=GWEN_XMLNode_FindFirstTag(n, "fn", NULL, NULL);
1051 while (nn) {
1052 TYPEMAKER2_VIRTUALFN *vf;
1053 int rv;
1054
1055 vf=Typemaker2_VirtualFn_new();
1056 rv=Typemaker2_VirtualFn_readXml(vf, nn);
1057 if (rv<0) {
1058 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1059 Typemaker2_VirtualFn_free(vf);
1060 return rv;
1061 }
1062 Typemaker2_VirtualFn_List_Add(vf, ty->virtualFns);
1063 nn=GWEN_XMLNode_FindNextTag(nn, "fn", NULL, NULL);
1064 }
1065 }
1066
1067 /* read signals */
1068 n=GWEN_XMLNode_FindFirstTag(node, "signals", NULL, NULL);
1069 if (n) {
1070 GWEN_XMLNODE *nn;
1071
1072 nn=GWEN_XMLNode_FindFirstTag(n, "signal", NULL, NULL);
1073 while (nn) {
1074 TYPEMAKER2_SIGNAL *sig;
1075 GWEN_XMLNODE *nnn;
1076 int i;
1077
1078 s=GWEN_XMLNode_GetProperty(nn, "name", NULL);
1079 if (!(s && *s)) {
1080 DBG_ERROR(GWEN_LOGDOMAIN, "Unnamed signal");
1081 return GWEN_ERROR_INVALID;
1082 }
1083 sig=Typemaker2_Signal_new();
1084 Typemaker2_Signal_SetName(sig, s);
1085 Typemaker2_Signal_SetParamType1(sig, "none");
1086 Typemaker2_Signal_SetParamType2(sig, "none");
1087
1088 i=GWEN_XMLNode_GetIntProperty(nn, "useParam3", 0);
1089 if (i)
1090 Typemaker2_Signal_AddFlags(sig, TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM3);
1091 i=GWEN_XMLNode_GetIntProperty(nn, "useParam4", 0);
1092 if (i)
1093 Typemaker2_Signal_AddFlags(sig, TYPEMAKER2_SIGNAL_FLAGS_USE_PARAM4);
1094
1095 nnn=GWEN_XMLNode_FindFirstTag(nn, "params", NULL, NULL);
1096 if (nnn) {
1097 GWEN_XMLNODE *nnnn;
1098 int i;
1099
1100 nnnn=GWEN_XMLNode_FindFirstTag(nnn, "param", NULL, NULL);
1101 i=1;
1102 while (nnnn && i<3) {
1103 const char *s;
1104
1105 s=GWEN_XMLNode_GetProperty(nnnn, "type", "none");
1106 if (i==1)
1107 Typemaker2_Signal_SetParamType1(sig, s);
1108 else
1109 Typemaker2_Signal_SetParamType2(sig, s);
1110 i++;
1111 nnnn=GWEN_XMLNode_FindNextTag(nnnn, "param", NULL, NULL);
1112 }
1113 }
1114 Typemaker2_Signal_List_Add(sig, ty->signals);
1115 nn=GWEN_XMLNode_FindNextTag(nn, "signal", NULL, NULL);
1116 }
1117 }
1118
1119
1120 /* read slots */
1121 n=GWEN_XMLNode_FindFirstTag(node, "slots", NULL, NULL);
1122 if (n) {
1123 GWEN_XMLNODE *nn;
1124
1125 nn=GWEN_XMLNode_FindFirstTag(n, "slot", NULL, NULL);
1126 while (nn) {
1127 TYPEMAKER2_SLOT *slot;
1128 GWEN_XMLNODE *nnn;
1129 int i;
1130
1131 s=GWEN_XMLNode_GetProperty(nn, "name", NULL);
1132 if (!(s && *s)) {
1133 DBG_ERROR(GWEN_LOGDOMAIN, "Unnamed slot");
1134 return GWEN_ERROR_INVALID;
1135 }
1136 slot=Typemaker2_Slot_new();
1137 Typemaker2_Slot_SetName(slot, s);
1138 Typemaker2_Slot_SetParamType1(slot, "none");
1139 Typemaker2_Slot_SetParamType2(slot, "none");
1140
1141 i=GWEN_XMLNode_GetIntProperty(nn, "useParam3", 0);
1142 if (i)
1143 Typemaker2_Slot_AddFlags(slot, TYPEMAKER2_SLOT_FLAGS_USE_PARAM3);
1144 i=GWEN_XMLNode_GetIntProperty(nn, "useParam4", 0);
1145 if (i)
1146 Typemaker2_Slot_AddFlags(slot, TYPEMAKER2_SLOT_FLAGS_USE_PARAM4);
1147
1148
1149 nnn=GWEN_XMLNode_FindFirstTag(nn, "params", NULL, NULL);
1150 if (nnn) {
1151 GWEN_XMLNODE *nnnn;
1152 int i;
1153
1154 nnnn=GWEN_XMLNode_FindFirstTag(nnn, "param", NULL, NULL);
1155 i=1;
1156 while (nnnn && i<3) {
1157 const char *s;
1158
1159 s=GWEN_XMLNode_GetProperty(nnnn, "type", "none");
1160 if (i==1)
1161 Typemaker2_Slot_SetParamType1(slot, s);
1162 else
1163 Typemaker2_Slot_SetParamType2(slot, s);
1164 i++;
1165 nnnn=GWEN_XMLNode_FindNextTag(nnnn, "param", NULL, NULL);
1166 }
1167 }
1168 Typemaker2_Slot_List_Add(slot, ty->slots);
1169 nn=GWEN_XMLNode_FindNextTag(nn, "slot", NULL, NULL);
1170 }
1171 }
1172
1173
1174 /* read defaults */
1175 n=GWEN_XMLNode_FindFirstTag(langNode, "defaults", NULL, NULL);
1176 if (n) {
1177 s=GWEN_XMLNode_GetCharValue(n, "default", NULL);
1178 Typemaker2_Type_SetDefaultValue(ty, s);
1179
1180 s=GWEN_XMLNode_GetCharValue(n, "preset", NULL);
1181 Typemaker2_Type_SetPresetValue(ty, s);
1182
1183 /* read flags */
1184 s=GWEN_XMLNode_GetCharValue(n, "flags", NULL);
1185 if (s && *s)
1186 Typemaker2_Type_SetFlags(ty, Typemaker2_TypeFlagsFromString(s));
1187
1188 /* read setflags */
1189 s=GWEN_XMLNode_GetCharValue(n, "setflags", NULL);
1190 if (s && *s)
1191 Typemaker2_Type_SetSetFlags(ty, Typemaker2_FlagsFromString(s));
1192
1193 /* read getflags */
1194 s=GWEN_XMLNode_GetCharValue(n, "getflags", NULL);
1195 if (s && *s)
1196 Typemaker2_Type_SetGetFlags(ty, Typemaker2_FlagsFromString(s));
1197
1198 /* read dupflags */
1199 s=GWEN_XMLNode_GetCharValue(n, "dupflags", NULL);
1200 if (s && *s)
1201 Typemaker2_Type_SetDupFlags(ty, Typemaker2_FlagsFromString(s));
1202
1203 /* read copyflags */
1204 s=GWEN_XMLNode_GetCharValue(n, "copyflags", NULL);
1205 if (s && *s)
1206 Typemaker2_Type_SetCopyFlags(ty, Typemaker2_FlagsFromString(s));
1207
1208 /* read access */
1209 s=GWEN_XMLNode_GetCharValue(n, "access", NULL);
1210 if (s && *s) {
1211 int i=Typemaker2_AccessFromString(s);
1212 if (i==TypeMaker2_Access_Unknown) {
1213 DBG_ERROR(GWEN_LOGDOMAIN, "Unknown access type [%s]", s);
1214 return GWEN_ERROR_BAD_DATA;
1215 }
1216 Typemaker2_Type_SetAccess(ty, i);
1217 }
1218 }
1219
1220 s=GWEN_XMLNode_GetProperty(langNode, "usePrivateConstructor", "0");
1221 if (s && *s)
1222 Typemaker2_Type_SetUsePrivateConstructor(ty, atoi(s));
1223
1224 return 0;
1225 }
1226
1227
1228
Typemaker2_Type_Dump(TYPEMAKER2_TYPE * ty,FILE * f,int indent)1229 void Typemaker2_Type_Dump(TYPEMAKER2_TYPE *ty, FILE *f, int indent)
1230 {
1231 if (ty) {
1232 int i;
1233 TYPEMAKER2_MEMBER *tm;
1234 const char *s1, *s2;
1235
1236 for (i=0; i<indent; i++)
1237 fprintf(f, " ");
1238 fprintf(f, "Type\n");
1239
1240 for (i=0; i<indent+2; i++)
1241 fprintf(f, " ");
1242 fprintf(f, "Name : %s\n", (ty->name)?(ty->name):"<null>");
1243
1244 for (i=0; i<indent+2; i++)
1245 fprintf(f, " ");
1246 fprintf(f, "Identifier: %s\n", (ty->identifier)?(ty->identifier):"<null>");
1247
1248 for (i=0; i<indent+2; i++)
1249 fprintf(f, " ");
1250 fprintf(f, "AEDB Type : %s\n", (ty->aqdb_type)?(ty->aqdb_type):"<null>");
1251
1252 for (i=0; i<indent+2; i++)
1253 fprintf(f, " ");
1254 fprintf(f, "Extends : %s\n", (ty->extends)?(ty->extends):"<null>");
1255
1256 for (i=0; i<indent+2; i++)
1257 fprintf(f, " ");
1258 s1=ty->inherits;
1259 s2=Typemaker2_Type_GetInherits(ty);
1260 fprintf(f, "Inherits : %s [%s]\n", s1?s1:"<null>", s2?s2:"<null>");
1261
1262 for (i=0; i<indent+2; i++)
1263 fprintf(f, " ");
1264 fprintf(f, "BaseType : %s\n", (ty->baseType)?(ty->baseType):"<null>");
1265
1266 for (i=0; i<indent+2; i++)
1267 fprintf(f, " ");
1268 fprintf(f, "Prefix : %s\n", (ty->prefix)?(ty->prefix):"<null>");
1269
1270 for (i=0; i<indent+2; i++)
1271 fprintf(f, " ");
1272 fprintf(f, "Access : %d [%d]\n", ty->access, Typemaker2_Type_GetAccess(ty));
1273
1274 for (i=0; i<indent+2; i++)
1275 fprintf(f, " ");
1276 fprintf(f, "Flags : %08x [%08x]\n", ty->flags, Typemaker2_Type_GetFlags(ty));
1277
1278 for (i=0; i<indent+2; i++)
1279 fprintf(f, " ");
1280 fprintf(f, "SetFlags : %08x [%08x]\n", ty->setFlags, Typemaker2_Type_GetSetFlags(ty));
1281
1282 for (i=0; i<indent+2; i++)
1283 fprintf(f, " ");
1284 fprintf(f, "GetFlags : %08x [%08x]\n", ty->getFlags, Typemaker2_Type_GetGetFlags(ty));
1285
1286 for (i=0; i<indent+2; i++)
1287 fprintf(f, " ");
1288 fprintf(f, "DupFlags : %08x [%08x]\n", ty->dupFlags, Typemaker2_Type_GetDupFlags(ty));
1289
1290 for (i=0; i<indent+2; i++)
1291 fprintf(f, " ");
1292 fprintf(f, "CopyFlags : %08x [%08x]\n", ty->copyFlags, Typemaker2_Type_GetCopyFlags(ty));
1293
1294 for (i=0; i<indent+2; i++)
1295 fprintf(f, " ");
1296 s1=ty->defaultValue;
1297 s2=Typemaker2_Type_GetDefaultValue(ty);
1298 fprintf(f, "Default : %s [%s]\n", s1?s1:"<null>", s2?s2:"<null>");
1299
1300 for (i=0; i<indent+2; i++)
1301 fprintf(f, " ");
1302 s1=ty->presetValue;
1303 s2=Typemaker2_Type_GetPresetValue(ty);
1304 fprintf(f, "Preset : %s [%s]\n", s1?s1:"<null>", s2?s2:"<null>");
1305
1306 for (i=0; i<indent+2; i++)
1307 fprintf(f, " ");
1308 fprintf(f, "Members\n");
1309 tm=Typemaker2_Member_List_First(ty->members);
1310 if (tm==NULL) {
1311 for (i=0; i<indent+4; i++)
1312 fprintf(f, " ");
1313 fprintf(f, "none\n");
1314 }
1315 else {
1316 while (tm) {
1317 Typemaker2_Member_Dump(tm, f, indent+4);
1318 tm=Typemaker2_Member_List_Next(tm);
1319 }
1320 }
1321 for (i=0; i<indent+2; i++)
1322 fprintf(f, " ");
1323 fprintf(f, "Field Count Id: %s\n", (ty->fieldCountId)?(ty->fieldCountId):"<null>");
1324
1325 for (i=0; i<indent+2; i++)
1326 fprintf(f, " ");
1327 fprintf(f, "Descript. : %s\n", (ty->descr)?(ty->descr):"<null>");
1328
1329 }
1330 }
1331
1332
1333
Typemaker2_Type_FindEnum(TYPEMAKER2_TYPE * ty,const char * s)1334 TYPEMAKER2_ENUM *Typemaker2_Type_FindEnum(TYPEMAKER2_TYPE *ty, const char *s)
1335 {
1336 TYPEMAKER2_ENUM *te;
1337
1338 assert(ty);
1339 te=Typemaker2_Enum_List_First(ty->enums);
1340 while (te) {
1341 const char *n;
1342
1343 n=Typemaker2_Enum_GetId(te);
1344 if (n && strcasecmp(s, n)==0)
1345 break;
1346 te=Typemaker2_Enum_List_Next(te);
1347 }
1348
1349 return te;
1350 }
1351
1352
1353
Typemaker2_Type_FindCodeForMember(const TYPEMAKER2_TYPE * ty,const TYPEMAKER2_MEMBER * tm,const char * id)1354 TYPEMAKER2_CODE *Typemaker2_Type_FindCodeForMember(const TYPEMAKER2_TYPE *ty,
1355 const TYPEMAKER2_MEMBER *tm,
1356 const char *id)
1357 {
1358 TYPEMAKER2_CODE *tc=NULL;
1359 uint32_t flags=0;
1360
1361 if (tm)
1362 flags=Typemaker2_Member_GetFlags(tm);
1363
1364 /* try code within member definition first, if any */
1365 if (tm) {
1366 tc=Typemaker2_Code_List_First(Typemaker2_Member_GetCodeDefs(tm));
1367 while (tc) {
1368 const char *s;
1369
1370 s=Typemaker2_Code_GetId(tc);
1371 if (s && strcasecmp(s, id)==0) {
1372 if ((flags & Typemaker2_Code_GetMemberFlagsMaskInt(tc))==Typemaker2_Code_GetMemberFlagsValueInt(tc))
1373 return tc;
1374 }
1375 tc=Typemaker2_Code_List_Next(tc);
1376 }
1377 }
1378
1379 while (ty) {
1380 tc=Typemaker2_Code_List_First(ty->codeDefs);
1381 while (tc) {
1382 const char *s;
1383
1384 s=Typemaker2_Code_GetId(tc);
1385 if (s && strcasecmp(s, id)==0) {
1386 if ((flags & Typemaker2_Code_GetMemberFlagsMaskInt(tc))==Typemaker2_Code_GetMemberFlagsValueInt(tc))
1387 return tc;
1388 }
1389 tc=Typemaker2_Code_List_Next(tc);
1390 }
1391
1392 ty=ty->extendsPtr;
1393 }
1394
1395 return NULL;
1396 }
1397
1398
1399
1400
1401
1402