]> andersk Git - splint.git/blame - src/ctbase.i
andersk / splint.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial revision
[splint.git] / src / ctbase.i
CommitLineData
885824d3 1/* ;-*-C-*-;
2** Copyright (c) Massachusetts Institute of Technology 1994-1998.
3** All Rights Reserved.
4** Unpublished rights reserved under the copyright laws of
5** the United States.
6**
7** THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
8** OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9**
10** This code is distributed freely and may be used freely under the
11** following conditions:
12**
13** 1. This notice may not be removed or altered.
14**
15** 2. Works derived from this code are not distributed for
16** commercial gain without explicit permission from MIT
17** (for permission contact lclint-request@sds.lcs.mit.edu).
18*/
19/*
20** ctbase.i
21**
22** NOTE: This is not a stand-alone source file, but is included in ctype.c.
23** (This is necessary becuase there is no other way in C to have a
24** hidden scope, besides at the file level.)
25*/
26
27/*@access cprim*/
28
29typedef /*@null@*/ struct __ctbase *ctbase;
30
31typedef struct _ctentry {
32 ctkind kind;
33 ctbase ctbase;
34 ctype base; /* type I point to (or element of array) */
35 ctype ptr; /* type of pointer to me */
36 ctype array; /* type of array of me */
37 cstring unparse; /* unparse me, if memoized */
38} *ctentry ;
39
40typedef /*@only@*/ ctentry o_ctentry;
41
42typedef struct _cttable {
43 int size;
44 int nspace;
45 /*@relnull@*/ /*@only@*/ o_ctentry *entries;
46 /* memoize matches...maybe in context? */
47} cttable ;
48
49extern bool ctentry_isBogus (/*@sef@*/ ctentry p_c) /*@*/;
50# define ctentry_isBogus(c) \
51 ((c)->kind == CTK_INVALID || (c)->kind == CTK_DNE)
52
53static cttable cttab = { 0, 0, NULL };
54
55static /*@notnull@*/ /*@only@*/ ctbase ctbase_createAbstract (typeId p_u);
56static /*@observer@*/ cstring ctentry_doUnparse (ctentry p_c) /*@modifies p_c@*/;
57static /*@only@*/ ctentry
58 ctentry_make (ctkind p_ctk, /*@keep@*/ ctbase p_c, ctype p_base,
59 ctype p_ptr, ctype p_array, /*@keep@*/ cstring p_unparse);
60static /*@only@*/ ctentry ctentry_makeNew (ctkind p_ctk, /*@only@*/ ctbase p_c);
61static /*@only@*/ cstring ctentry_unparse (ctentry p_c) /*@*/ ;
62
63static void cttable_grow (void);
64static ctype cttable_addDerived (ctkind p_ctk, /*@keep@*/ ctbase p_cnew, ctype p_base);
65static ctype cttable_addFull (/*@keep@*/ ctentry p_cnew);
66static bool ctentry_isInteresting (ctentry p_c) /*@*/;
67static /*@notnull@*/ /*@only@*/ ctbase ctbase_makeFixedArray (ctype p_b, long p_size) /*@*/ ;
68
69/*
70** These are file-static macros (used in ctype.c). No way to
71** declare them as static in C.
72*/
73
74/*@-allmacros@*/ /*@-macrospec@*/ /*@-namechecks@*/
75# define ctentry_getBase(c) ((c)->base)
76# define ctentry_getKind(c) ((c)->kind)
77# define ctentry_getArray(c) ((c)->array)
78# define ctentry_getPtr(c) ((c)->ptr)
79# define ctentry_isArray(c) ((c)->kind == CTK_ARRAY)
80# define ctentry_isComplex(c) ((c)->kind == CTK_COMPLEX)
81# define ctentry_isPlain(c) ((c)->kind == CTK_PLAIN)
82# define ctentry_isPointer(c) ((c)->kind == CTK_PTR)
83# define ctentry_setArray(c,b) ((c)->array = (b))
84# define ctentry_setPtr(c,b) ((c)->ptr = (b))
85
86# define ctbase_fixUser(c) (c = ctbase_realType(c))
87/*@=allmacros@*/ /*@=macrospec@*/ /*@=namechecks@*/
88
89static ctype cttable_addComplex (/*@notnull@*/ /*@only@*/ ctbase p_cnew);
90static /*@observer@*/ ctbase ctype_getCtbase (ctype p_c) /*@*/ ;
91static ctype ctype_makeConjAux (ctype p_c1, ctype p_c2, bool p_isExplicit) /*@*/ ;
92static /*@notnull@*/ /*@observer@*/ ctbase ctype_getCtbaseSafe (ctype p_c) /*@*/ ;
93static /*@observer@*/ ctentry ctype_getCtentry (ctype p_c) /*@*/ ;
94static /*@observer@*/ /*@notnull@*/ ctbase
95 ctbase_realType (/*@notnull@*/ ctbase p_c) /*@*/ ;
96static bool ctbase_isPointer (/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
97static bool ctbase_isEitherArray (/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
98static /*@observer@*/ enumNameList ctbase_elist (ctbase p_c) /*@*/ ;
99static /*@only@*/ cstring ctbase_unparse (ctbase p_c) /*@*/ ;
100static /*@only@*/ cstring ctbase_unparseDeep (ctbase p_c) /*@*/ ;
101static /*@only@*/ /*@notnull@*/ ctbase ctbase_copy (/*@notnull@*/ ctbase p_c) /*@*/ ;
102static void ctbase_free (/*@only@*/ ctbase p_c);
103static /*@notnull@*/ /*@only@*/ ctbase ctbase_createPrim (cprim p_p) /*@*/ ;
104static /*@notnull@*/ /*@only@*/ ctbase ctbase_createBool (void) /*@*/ ;
105static /*@notnull@*/ /*@observer@*/ ctbase ctbase_getBool (void) /*@*/ ;
106static /*@notnull@*/ /*@only@*/ ctbase ctbase_createUser (typeId p_u) /*@*/ ;
107
108static /*@notnull@*/ /*@only@*/ ctbase
109 ctbase_createStruct (/*@only@*/ cstring p_n, /*@only@*/ uentryList p_f);
110
111static /*@notnull@*/ /*@only@*/ ctbase
112 ctbase_createUnion (/*@keep@*/ cstring p_n, /*@only@*/ uentryList p_f);
113static /*@notnull@*/ /*@only@*/ ctbase ctbase_createEnum (/*@keep@*/ cstring p_etag, /*@keep@*/ enumNameList p_emembers);
114static /*@notnull@*/ /*@only@*/ ctbase ctbase_createUnknown (void);
115static bool ctbase_match (ctbase p_c1, ctbase p_c2) /*@modifies nothing@*/;
116static bool ctbase_matchDef (ctbase p_c1, ctbase p_c2) /*@modifies nothing@*/;
117static bool ctbase_genMatch (ctbase p_c1, ctbase p_c2, bool p_force, bool p_arg, bool p_def);
118static bool ctbase_isAbstract (/*@notnull@*/ ctbase p_c) /*@*/ ;
119static /*@notnull@*/ /*@only@*/ ctbase ctbase_makePointer (ctype p_b) /*@*/ ;
120static /*@notnull@*/ /*@only@*/ ctbase ctbase_makeArray (ctype p_b) /*@*/ ;
121static /*@notnull@*/ ctype
122 ctbase_makeFunction (ctype p_b, /*@only@*/ uentryList p_p) /*@*/ ;
123static /*@notnull@*/ /*@only@*/ ctbase
124 ctbase_makeRealFunction (ctype p_b, /*@dependent@*/ uentryList p_p) /*@*/ ;
125static /*@notnull@*/ /*@observer@*/ ctbase
126 ctbase_realFunction (/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
127static ctype ctbase_baseArrayPtr (/*@notnull@*/ ctbase p_c) /*@*/ ;
128static ctype ctbase_baseFunction (/*@notnull@*/ ctbase p_c) /*@*/ ;
129static /*@observer@*/ uentryList ctbase_argsFunction (/*@notnull@*/ ctbase p_c) /*@*/ ;
130static /*@observer@*/ uentryList ctbase_getuentryList (/*@notnull@*/ ctbase p_c) /*@*/ ;
131static ctype ctbase_newBase (ctype p_c, ctype p_p) /*@*/ ;
132static ctype ctbase_newBaseExpFcn (ctype p_c, ctype p_p) /*@*/ ;
133static bool ctbase_isFixedArray (/*@notnull@*/ ctbase p_c) /*@*/ ;
134
135/*@-macroundef@*/
136extern int cttable_lastIndex();
137# define cttable_lastIndex() (cttab.size - 1)
138/*@=macroundef@*/
139
140typedef struct _cfcn
141{
142 ctype rval;
143 /*@dependent@*/ uentryList params; /* params are owned if liveparams is TRUE */
144 bool liveparams;
145} *cfcn;
146
147typedef struct _tsu
148{
149 cstring name;
150 uentryList fields;
151} *tsu;
152
153typedef struct _tconj
154{
155 ctype a;
156 ctype b;
157 bool isExplicit;
158} *tconj;
159
160typedef struct _tenum
161{
162 cstring tag;
163 enumNameList members;
164} *tenum;
165
166typedef struct _tfixed
167{
168 ctype base;
169 long size;
170} *tfixed;
171
172typedef union _uconts
173{
174 cprim prim; /* primitive */
175 typeId tid; /* abstract, user */
176 ctype base; /* ptr, array */
177 cfcn fcn; /* function */
178 tsu su; /* struct union */
179 tenum cenum; /* enum */
180 tconj conj; /* conj */
181 tfixed farray; /* fixed array */
182} uconts;
183
184struct __ctbase
185{
186 ctuid type;
187 uconts contents;
188} ;
189
190static /*@falsenull@*/ bool ctbase_isUA (ctbase p_c) /*@*/ ;
191static bool ctbase_isBaseUA(ctbase p_c) /*@*/ ;
192static typeId ctbase_typeBaseUid(ctbase p_c) /*@*/ ;
193static bool ctbase_isKind (/*@notnull@*/ ctbase p_c, ctuid p_kind) /*@*/ ;
194static bool ctbase_isKind2 (/*@notnull@*/ ctbase p_c, ctuid p_kind1, ctuid p_kind2) /*@*/ ;
195static /*@only@*/ /*@notnull@*/ ctbase
196 ctbase_getBaseType (/*@notnull@*/ ctbase p_c) /*@*/ ;
197
198static /*@falsenull@*/ bool ctbase_isFunction(ctbase p_c) /*@*/ ;
199
200/*@constant null ctbase ctbase_undefined; @*/
201# define ctbase_undefined ((ctbase)0)
202
203static /*@owned@*/ ctbase ctbase_bool = ctbase_undefined;
204static /*@owned@*/ ctbase ctbase_unknown = ctbase_undefined;
205
206static /*@falsenull@*/ bool ctbase_isDefined (ctbase c) /*@*/
207{
208 return ((c) != ctbase_undefined);
209}
210
211static /*@truenull@*/ bool ctbase_isUndefined (ctbase c)
212{
213 return ((c) == ctbase_undefined);
214}
215
216static ctkind ctype_getCtKind (ctype c)
217{
218 ctentry ce = ctype_getCtentry (c);
219
220 return ctentry_getKind (ce);
221}
222
223static bool ctbase_isUser (ctbase c)
224{
225 if (ctbase_isDefined (c))
226 {
227 return (ctbase_isKind (c, CT_USER));
228 }
229 else
230 {
231 return FALSE;
232 }
233}
234
235static bool ctbase_isEnum (ctbase c)
236{
237 if (ctbase_isDefined (c))
238 {
239 return (ctbase_isKind (c, CT_ENUM));
240 }
241 else
242 {
243 return FALSE;
244 }
245}
246
247static bool ctbase_isExpFcn (ctbase c)
248{
249 if (ctbase_isDefined (c))
250 {
251 return (c->type == CT_EXPFCN);
252 }
253 else
254 {
255 return FALSE;
256 }
257}
258
259static /*@falsenull@*/ bool ctbase_isConj (ctbase c)
260{
261 if (ctbase_isDefined (c))
262 {
263 return (c->type == CT_CONJ);
264 }
265 else
266 {
267 return FALSE;
268 }
269}
270
271static bool ctuid_isAP (ctuid c) /*@*/
272{
273 return (c == CT_ARRAY || c == CT_PTR);
274}
275
276static typeId ctbase_typeId (ctbase p_c);
277static /*@only@*/ cstring ctbase_dump (ctbase p_c);
278static /*@only@*/ ctbase ctbase_undump (char **p_c);
279static int ctbase_compare (ctbase p_c1, ctbase p_c2, bool p_strict);
280static bool ctbase_matchArg (ctbase p_c1, ctbase p_c2);
281static /*@notnull@*/ /*@only@*/ ctbase
282 ctbase_makeConj (ctype p_c1, ctype p_c2, bool p_isExplicit) /*@*/ ;
283static ctype ctbase_getConjA (/*@notnull@*/ ctbase p_c) /*@*/ ;
284static ctype ctbase_getConjB (/*@notnull@*/ ctbase p_c) /*@*/ ;
285static bool ctbase_isExplicitConj (/*@notnull@*/ ctbase p_c) /*@*/ ;
286static bool ctbase_forceMatch (ctbase p_c1, ctbase p_c2);
287static /*@notnull@*/ /*@only@*/ ctbase ctbase_expectFunction (ctype p_c);
288static bool ctbase_isVoidPointer(/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
289static bool ctbase_isUnion (/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
290static bool ctbase_isStruct (/*@notnull@*/ /*@dependent@*/ ctbase p_c) /*@*/ ;
291static /*@observer@*/ cstring ctbase_enumTag (/*@notnull@*/ ctbase p_ct) /*@*/ ;
292static /*@only@*/ cstring ctbase_unparseNotypes (ctbase p_c) /*@*/ ;
293
294static /*@out@*/ /*@notnull@*/ /*@only@*/ ctbase ctbase_new (void) /*@*/ ;
295static int nctbases = 0;
296
297static /*@notnull@*/ /*@only@*/
298 ctbase ctbase_makeLiveFunction (ctype p_b, /*@owned@*/ uentryList p_p);
299
300static /*@observer@*/ ctbase ctbase_realType (ctbase c)
301{
302 if (ctbase_isUA (c))
303 {
304 typeId uid = ctbase_typeId (c);
305
306 if (usymtab_isBoolType (uid))
307 {
308 return ctbase_getBool ();
309 }
310 else
311 {
312 ctbase ret = ctype_getCtbase
313 (uentry_getRealType (usymtab_getTypeEntry (ctbase_typeId (c))));
314
315 llassert (ret != ctbase_undefined);
316 return ret;
317 }
318 }
319 else
320 {
321 return c;
322 }
323}
324
325static bool
326ctbase_isVoidPointer (/*@dependent@*/ /*@notnull@*/ ctbase c)
327{
328 ctbase r = ctbase_realType (c);
329
330 return (ctbase_isKind (r, CT_PTR) &&
331 ctype_isVoid (r->contents.base));
332}
333
334static bool
335ctbase_isPointer (/*@notnull@*/ /*@dependent@*/ ctbase c)
336{
337 ctbase r = ctbase_realType (c);
338
339 return (ctbase_isKind (r, CT_PTR));
340}
341
342static bool
343ctbase_isEitherArray (/*@notnull@*/ ctbase c)
344{
345 ctbase r = ctbase_realType (c);
346
347 return (ctbase_isKind (r, CT_ARRAY)
348 || ctbase_isKind (r, CT_FIXEDARRAY));
349}
350
351static bool
352ctbase_isFixedArray (/*@notnull@*/ ctbase c)
353{
354 ctbase r = ctbase_realType (c);
355
356 return (ctbase_isKind (r, CT_FIXEDARRAY));
357}
358
359static bool
360ctbase_isStruct (/*@notnull@*/ ctbase c)
361{
362 ctbase r = ctbase_realType (c);
363
364 return (ctbase_isKind (r, CT_STRUCT));
365}
366
367static bool
368ctbase_isUnion (/*@notnull@*/ /*@dependent@*/ ctbase c)
369{
370 ctbase r = ctbase_realType (c);
371
372 return (ctbase_isKind (r, CT_UNION));
373}
374
375/*
376** clean this up -> typeTable should store ctype
377*/
378
379static typeId
380ctbase_typeBaseUid (ctbase c)
381{
382 ctuid ct;
383
384 if (ctbase_isDefined (c))
385 {
386 ct = c->type;
387
388 if (ctuid_isAP (ct))
389 {
390 return ctbase_typeBaseUid (ctype_getCtbase (c->contents.base));
391 }
392 else if (ct == CT_USER || ct == CT_ABST)
393 {
394 return c->contents.tid;
395 }
396 else if (ct == CT_FIXEDARRAY)
397 {
398 return ctbase_typeBaseUid (ctype_getCtbase (c->contents.farray->base));
399 }
400 else
401 {
402 llcontbuglit ("ctbase_typeBaseUid: bad call");
403 return typeId_invalid;
404 }
405 }
406 return typeId_invalid;
407}
408
409static bool
410ctbase_isBaseUA (ctbase c)
411{
412 ctuid ct;
413
414 if (ctbase_isDefined (c))
415 {
416 ct = c->type;
417
418 if (ctuid_isAP (ct))
419 {
420 return ctbase_isBaseUA (ctype_getCtbase (c->contents.base));
421 }
422 else if (ct == CT_FIXEDARRAY)
423 {
424 return ctbase_isBaseUA (ctype_getCtbase (c->contents.farray->base));
425 }
426 else
427 return (ct == CT_USER || ct == CT_ABST);
428 }
429 return FALSE;
430}
431
432static typeId
433ctbase_typeId (ctbase c)
434{
435 if (ctbase_isUA (c))
436 {
437 return c->contents.tid;
438 }
439 else
440 {
441 llcontbug (message ("ctbase_typeId: bad call: %q", ctbase_unparse (c)));
442 return typeId_invalid;
443 }
444}
445
446static /*@only@*/ cstring
447ctbase_unparse (ctbase c)
448{
449 if (ctbase_isUndefined (c)) {
450 return cstring_makeLiteral ("<<undef>>");
451 }
452
453 switch (c->type)
454 {
455 case CT_UNKNOWN:
456 return cstring_makeLiteral ("?");
457 case CT_BOOL:
458 return cstring_copy (context_printBoolName ());
459 case CT_PRIM:
460 return (cprim_unparse (c->contents.prim));
461 case CT_USER:
462 return (usymtab_getTypeEntryName (c->contents.tid));
463 case CT_ABST:
464 return (usymtab_getTypeEntryName (c->contents.tid));
465 case CT_EXPFCN:
466 return (message ("<expf: %t>", c->contents.base));
467 case CT_PTR:
468 /* no spaces for multiple pointers */
469
470 if (ctype_isPointer (c->contents.base))
471 {
472 return (cstring_appendChar (cstring_copy (ctype_unparse (c->contents.base)), '*'));
473 }
474 else
475 {
476 return (message ("%t *", c->contents.base));
477 }
478 case CT_FIXEDARRAY:
479 return (message ("%t [%d]", c->contents.farray->base,
480 (int) c->contents.farray->size));
481 case CT_ARRAY:
482 return (message ("%t []", c->contents.base));
483 case CT_FCN:
484 return (message ("[function (%q) returns %t]",
485 uentryList_unparseParams (c->contents.fcn->params),
486 c->contents.fcn->rval));
487 case CT_STRUCT:
488 if (cstring_isDefined (c->contents.su->name) &&
489 !cstring_isEmpty (c->contents.su->name) &&
490 !isFakeTag (c->contents.su->name))
491 {
492 return (message ("struct %s", c->contents.su->name));
493 }
494 else
495 {
496 return (message ("struct { %q }", uentryList_unparseAbbrev (c->contents.su->fields)));
497 }
498 case CT_UNION:
499 if (cstring_isDefined (c->contents.su->name) &&
500 !cstring_isEmpty (c->contents.su->name) &&
501 !isFakeTag (c->contents.su->name))
502 {
503 return (message ("union %s", c->contents.su->name));
504 }
505 else
506 {
507 return (message ("union { %q }",
508 uentryList_unparseAbbrev (c->contents.su->fields)));
509 }
510 case CT_ENUM:
511 if (isFakeTag (c->contents.cenum->tag))
512 {
513 return (message ("enum { %q }",
514 enumNameList_unparseBrief (c->contents.cenum->members)));
515 }
516 else
517 {
518 return (message ("enum %s { %q }",
519 c->contents.cenum->tag,
520 enumNameList_unparseBrief (c->contents.cenum->members)));
521 }
522 case CT_CONJ:
523 if (c->contents.conj->isExplicit || context_getFlag (FLG_SHOWALLCONJS))
524 {
525 if (!ctype_isSimple (c->contents.conj->a) ||
526 !ctype_isSimple (c->contents.conj->b))
527 {
528 return (message ("<%t> | <%t>", c->contents.conj->a, c->contents.conj->b));
529 }
530 else
531 {
532 return (message ("%t | %t", c->contents.conj->a, c->contents.conj->b));
533 }
534 }
535 else
536 {
537 return (cstring_copy (ctype_unparse (c->contents.conj->a)));
538 }
539 BADDEFAULT;
540 }
541 BADEXIT;
542}
543
544static /*@only@*/ cstring
545 ctbase_unparseDeep (ctbase c)
546{
547 if (ctbase_isUndefined (c))
548 {
549 return cstring_makeLiteral ("<<undef>>");
550 }
551
552 switch (c->type)
553 {
554 case CT_UNKNOWN:
555 return cstring_makeLiteral ("?");
556 case CT_BOOL:
557 return cstring_copy (context_printBoolName ());
558 case CT_PRIM:
559 return (cprim_unparse (c->contents.prim));
560 case CT_ENUM:
561 if (cstring_isNonEmpty (c->contents.cenum->tag))
562 {
563 return (message ("enum %s { %q }",
564 c->contents.cenum->tag,
565 enumNameList_unparse (c->contents.cenum->members)));
566 }
567 else
568 {
569 return (message ("enum { %q }",
570 enumNameList_unparse (c->contents.cenum->members)));
571 }
572 case CT_USER:
573 return (usymtab_getTypeEntryName (c->contents.tid));
574 case CT_ABST:
575 return (usymtab_getTypeEntryName (c->contents.tid));
576 case CT_EXPFCN:
577 return (message ("<expf: %t>", c->contents.base));
578 case CT_PTR:
579 return (message ("%t *", c->contents.base));
580 case CT_FIXEDARRAY:
581 return (message ("%t [%d]", c->contents.farray->base,
582 (int) c->contents.farray->size));
583 case CT_ARRAY:
584 return (message ("%t []", c->contents.base));
585 case CT_FCN:
586 return (message ("[function (%q) returns %t]",
587 uentryList_unparse (c->contents.fcn->params),
588 c->contents.fcn->rval));
589 case CT_STRUCT:
590 return (message ("struct %s { ... } ", c->contents.su->name));
591 case CT_UNION:
592 return (message ("union %s { ... }", c->contents.su->name));
593 case CT_CONJ:
594 return (message ("%t", c->contents.conj->a));
595 BADDEFAULT;
596 }
597 BADEXIT;
598}
599
600static /*@only@*/ cstring
601ctbase_unparseNotypes (ctbase c)
602{
603 llassert (ctbase_isDefined (c));
604
605 switch (c->type)
606 {
607 case CT_UNKNOWN:
608 return cstring_makeLiteral ("?");
609 case CT_BOOL:
610 return cstring_copy (context_printBoolName ());
611 case CT_PRIM:
612 return (cprim_unparse (c->contents.prim));
613 case CT_ENUM:
614 if (typeId_isInvalid (c->contents.tid))
615 {
616 return cstring_makeLiteral ("enum");
617 }
618 else
619 {
620 return (message ("T#%d", c->contents.tid));
621 }
622 case CT_USER:
623 return (message ("uT#%d", c->contents.tid));
624 case CT_ABST:
625 return (message ("aT#%d", c->contents.tid));
626 case CT_EXPFCN:
627 return (message ("<expf: %q >", ctbase_unparseNotypes (ctype_getCtbase (c->contents.base))));
628 case CT_PTR:
629 return (message ("%q *", ctbase_unparseNotypes (ctype_getCtbase (c->contents.base))));
630 case CT_ARRAY:
631 return (message ("%q []", ctbase_unparseNotypes (ctype_getCtbase (c->contents.base))));
632 case CT_FCN:
633 return (message ("[function (%d) returns %q]", uentryList_size (c->contents.fcn->params),
634 ctbase_unparseNotypes (ctype_getCtbase (c->contents.fcn->rval))));
635 case CT_STRUCT:
636 return (message ("struct %s", c->contents.su->name));
637 case CT_UNION:
638 return (message ("union %s", c->contents.su->name));
639 case CT_ENUMLIST:
640 return (message ("[enumlist]"));
641 case CT_CONJ:
642 return (message ("%q/%q",
643 ctbase_unparseNotypes (ctype_getCtbase (c->contents.conj->a)),
644 ctbase_unparseNotypes (ctype_getCtbase (c->contents.conj->b))));
645 BADDEFAULT;
646 }
647 BADEXIT;
648}
649
650static /*@only@*/ cstring
651ctbase_unparseDeclaration (ctbase c, /*@only@*/ cstring name) /*@*/
652{
653 if (ctbase_isUndefined (c))
654 {
655 return name;
656 }
657
658 switch (c->type)
659 {
660 case CT_UNKNOWN:
661 return (message ("? %q", name));
662 case CT_BOOL:
663 return (message ("%s %q", context_printBoolName (), name));
664 case CT_PRIM:
665 return (message ("%q %q", cprim_unparse (c->contents.prim), name));
666 case CT_USER:
667 case CT_ABST:
668 return (message ("%q %q", usymtab_getTypeEntryName (c->contents.tid), name));
669 case CT_EXPFCN:
670 llcontbuglit ("ctbase_unparseDeclaration: expfcn");
671 return name;
672 case CT_PTR:
673 if (ctype_isFunction (c->contents.base))
674 {
675 return ctbase_unparseDeclaration (ctype_getCtbase (c->contents.base), name);
676 }
677 else
678 {
679 cstring s = cstring_prependChar ('*', name);
680 cstring ret = ctbase_unparseDeclaration (ctype_getCtbase (c->contents.base), s);
681 cstring_free (name);
682 return (ret);
683 }
684 case CT_FIXEDARRAY:
685 return (message ("%q[%d]",
686 ctbase_unparseDeclaration (ctype_getCtbase (c->contents.farray->base), name),
687 (int) c->contents.farray->size));
688 case CT_ARRAY:
689 return (message ("%q[]",
690 ctbase_unparseDeclaration (ctype_getCtbase (c->contents.base), name)));
691 case CT_FCN:
692 {
693 cstring s = message ("%q(%q)", name,
694 uentryList_unparseParams (c->contents.fcn->params));
695
696 return (ctbase_unparseDeclaration
697 (ctype_getCtbase (c->contents.fcn->rval), s));
698 }
699 case CT_STRUCT:
700 if (cstring_isDefined (c->contents.su->name) &&
701 !cstring_isEmpty (c->contents.su->name) &&
702 !isFakeTag (c->contents.su->name))
703 {
704 return (message ("struct %s %q", c->contents.su->name, name));
705 }
706 else
707 {
708 return (message ("struct { %q } %q",
709 uentryList_unparseAbbrev (c->contents.su->fields),
710 name));
711 }
712 case CT_UNION:
713 if (cstring_isDefined (c->contents.su->name) &&
714 !cstring_isEmpty (c->contents.su->name) &&
715 !isFakeTag (c->contents.su->name))
716 {
717 return (message ("union %s %q", c->contents.su->name, name));
718 }
719 else
720 {
721 return (message ("union { %q } %q",
722 uentryList_unparseAbbrev (c->contents.su->fields),
723 name));
724 }
725 case CT_ENUM:
726 if (isFakeTag (c->contents.cenum->tag))
727 {
728 return (message ("enum { %q } %q",
729 enumNameList_unparseBrief (c->contents.cenum->members),
730 name));
731 }
732 else
733 {
734 return (message ("enum %s { %q } %q",
735 c->contents.cenum->tag,
736 enumNameList_unparseBrief (c->contents.cenum->members),
737 name));
738 }
739 case CT_CONJ:
740 if (c->contents.conj->isExplicit || context_getFlag (FLG_SHOWALLCONJS))
741 {
742 if (!ctype_isSimple (c->contents.conj->a) ||
743 !ctype_isSimple (c->contents.conj->b))
744 {
745 cstring name1 = cstring_copy (name);
746
747 return
748 (message
749 ("<%q> | <%q>",
750 ctbase_unparseDeclaration
751 (ctype_getCtbase (c->contents.conj->a), name1),
752 ctbase_unparseDeclaration
753 (ctype_getCtbase (c->contents.conj->b), name)));
754 }
755 else
756 {
757 cstring s1 = ctbase_unparseDeclaration (ctype_getCtbase (c->contents.conj->a),
758 cstring_copy (name));
759 return
760 (message ("%q | %q", s1,
761 ctbase_unparseDeclaration (ctype_getCtbase (c->contents.conj->b),
762 name)));
763 }
764 }
765 else
766 {
767 cstring_free (name);
768 return (cstring_copy (ctype_unparse (c->contents.conj->a)));
769 }
770 BADDEFAULT;
771 }
772 BADEXIT;
773}
774
775static ctbase ctbase_undump (d_char *c)
776{
777 ctbase res;
778 char p = **c;
779
780 (*c)++;
781
782 switch (p)
783 {
784 case '?':
785 return (ctbase_undefined);
786 case 'u':
787 return (ctbase_createUnknown ());
788 case 'b':
789 return (ctbase_createBool ());
790 case 'p':
791 res = ctbase_createPrim (cprim_fromInt (getInt (c)));
792 checkChar (c, '|');
793 return res;
794 case 's':
795 res = ctbase_createUser (typeId_fromInt (getInt (c)));
796 checkChar (c, '|');
797 return res;
798 case 'a':
799 res = ctbase_createAbstract (typeId_fromInt (getInt (c)));
800 checkChar (c, '|');
801 return res;
802 case 't':
803 res = ctbase_makePointer (ctype_undump (c));
804 checkChar (c, '|');
805 return res;
806 case 'y':
807 res = ctbase_makeArray (ctype_undump (c));
808 checkChar (c, '|');
809 return res;
810 case 'F':
811 {
812 ctype ct = ctype_undump (c);
813 int size;
814
815 checkChar (c, '/');
816 size = getInt (c);
817 checkChar (c, '|');
818 return (ctbase_makeFixedArray (ct, size));
819 }
820 case 'f':
821 {
822 ctype ct;
823 char *lp = strchr (*c, '(');
824
825 llassertfatal (lp != NULL);
826
827 *lp = '\0';
828 ct = ctype_undump (c);
829 *c = lp + 1;
830
831 return (ctbase_makeLiveFunction (ct, uentryList_undump (c)));
832 }
833 case 'S':
834 {
835 uentryList fields;
836 ctbase ctb;
837 char *sname;
838 char *lc = strchr (*c, '{');
839
840 llassert (lc != NULL);
841 *lc = '\0';
842
843 sname = mstring_copy (*c);
844
845 *c = lc + 1;
846
847 if (*sname == '!')
848 {
849 unsigned int i;
850
851 i = (unsigned) atoi (sname + 1);
852
853 setTagNo (i);
854 }
855
856 fields = uentryList_undumpFields (c, g_currentloc);
857
858 ctb = ctbase_createStruct (cstring_fromCharsO (sname), fields);
859 return ctb;
860 }
861 case 'U':
862 {
863 char *sname;
864 char *lc = strchr (*c, '{');
865
866 llassert (lc != NULL);
867
868 *lc = '\0';
869 sname = mstring_copy (*c);
870 llassert (sname != NULL);
871
872 *c = lc + 1;
873
874 if (*sname == '!')
875 {
876 unsigned int i;
877
878 i = (unsigned) atoi (sname + 1);
879 setTagNo (i);
880 }
881
882 return (ctbase_createUnion (cstring_fromCharsO (sname),
883 uentryList_undumpFields (c, g_currentloc)));
884 }
885 case 'e':
886 {
887 ctbase ret;
888 char *sname;
889 char *lc = strchr (*c, '{');
890
891 llassert (lc != NULL);
892
893 *lc = '\0';
894 sname = mstring_copy (*c);
895 *c = lc + 1;
896
897 if (*sname == '!')
898 {
899 unsigned int i;
900
901 i = (unsigned) atoi (sname + 1);
902 setTagNo (i);
903 }
904
905 ret = ctbase_createEnum (cstring_fromCharsO (sname),
906 enumNameList_undump (c));
907 return ret;
908 }
909 case 'C':
910 {
911 bool isExplicit;
912 ctype c1, c2;
913
914 isExplicit = bool_fromInt (getInt (c));
915 checkChar (c, '.');
916 c1 = ctype_undump (c);
917 checkChar (c, '/');
918 c2 = ctype_undump (c);
919 checkChar (c, '|');
920
921 return (ctbase_makeConj (c1, c2, isExplicit));
922 }
923
924 default:
925 (*c)--;
926 llerror (FLG_SYNTAX,
927 message ("Bad Library line (type): %s", cstring_fromChars (*c)));
928
929 while (**c != '\0')
930 {
931 (*c)++;
932 }
933
934 return ctbase_createUnknown ();
935 }
936}
937
938/* first letter of c encodes type: */
939/* u unknown */
940/* b bool */
941/* p prim */
942/* e enum */
943/* l enumList */
944/* s uSer */
945/* a abstract */
946/* t poinTer */
947/* y arraY */
948/* F Fixed array */
949/* f function */
950/* S structure */
951/* U union */
952/* C conj */
953
954static /*@only@*/ cstring
955ctbase_dump (ctbase c)
956{
957 if (!ctbase_isDefined (c))
958 {
959 return cstring_makeLiteral ("?");
960 }
961
962 switch (c->type)
963 {
964 case CT_UNKNOWN:
965 return cstring_makeLiteral ("u");
966 case CT_BOOL:
967 return cstring_makeLiteral ("b");
968 case CT_PRIM:
969 return (message ("p%d|", c->contents.prim));
970 case CT_USER:
971 return (message ("s%d|",
972 usymtab_convertId (c->contents.tid)));
973 case CT_ABST:
974 return (message ("a%d|", usymtab_convertId (c->contents.tid)));
975 case CT_PTR:
976 return (message ("t%q|", ctype_dump (c->contents.base)));
977 case CT_ARRAY:
978 return (message ("y%q|", ctype_dump (c->contents.base)));
979 case CT_FIXEDARRAY:
980 return (message ("F%q/%d|",
981 ctype_dump (c->contents.farray->base),
982 (int) c->contents.farray->size));
983 case CT_FCN:
984 return (message ("f%q (%q)", ctype_dump (c->contents.fcn->rval),
985 uentryList_dumpParams (c->contents.fcn->params)));
986 case CT_STRUCT:
987 return (message ("S%s{%q}", c->contents.su->name,
988 uentryList_dumpFields (c->contents.su->fields)));
989 case CT_UNION:
990 return (message ("U%s{%q}", c->contents.su->name,
991 uentryList_dumpFields (c->contents.su->fields)));
992 case CT_ENUM:
993 {
994 cstring s;
995
996 if (cstring_isNonEmpty (c->contents.cenum->tag))
997 {
998 s = message ("e%s{%q}",
999 c->contents.cenum->tag,
1000 enumNameList_dump (c->contents.cenum->members));
1001 }
1002 else
1003 {
1004 s = message ("e{%q}",
1005 enumNameList_dump (c->contents.cenum->members));
1006 }
1007 return (s);
1008 }
1009 case CT_CONJ:
1010 return (message ("C%d.%q/%q|",
1011 bool_toInt (c->contents.conj->isExplicit),
1012 ctype_dump (c->contents.conj->a),
1013 ctype_dump (c->contents.conj->b)));
1014 case CT_EXPFCN:
1015 /* should clean them up! */
1016 return (cstring_makeLiteral ("?"));
1017 case CT_ENUMLIST:
1018 llcontbug (message ("Cannot dump: %q", ctbase_unparse (c)));
1019 return (message ("u"));
1020 BADDEFAULT;
1021 }
1022
1023 BADEXIT;
1024}
1025
1026static /*@only@*/ ctbase
1027ctbase_copy (/*@notnull@*/ ctbase c)
1028{
1029 switch (c->type)
1030 {
1031 case CT_UNKNOWN:
1032 return (ctbase_createUnknown ());
1033 case CT_BOOL:
1034 return (ctbase_createBool ());
1035 case CT_ENUM:
1036 return (ctbase_createEnum (cstring_copy (c->contents.cenum->tag),
1037 enumNameList_copy (c->contents.cenum->members)));
1038 case CT_PRIM:
1039 return (ctbase_createPrim (c->contents.prim));
1040 case CT_USER:
1041 return (ctbase_createUser (c->contents.tid));
1042 case CT_ABST:
1043 return (ctbase_createAbstract (c->contents.tid));
1044 case CT_EXPFCN:
1045 return (ctbase_expectFunction (c->contents.base));
1046 case CT_PTR:
1047 return (ctbase_makePointer (c->contents.base));
1048 case CT_ARRAY:
1049 return (ctbase_makeArray (c->contents.base));
1050 case CT_FCN:
1051 return (ctbase_makeLiveFunction (c->contents.fcn->rval,
1052 uentryList_copy (c->contents.fcn->params)));
1053 case CT_STRUCT:
1054 return (ctbase_createStruct (cstring_copy (c->contents.su->name),
1055 uentryList_copy (c->contents.su->fields)));
1056 case CT_UNION:
1057 return (ctbase_createUnion (cstring_copy (c->contents.su->name),
1058 uentryList_copy (c->contents.su->fields)));
1059 case CT_CONJ:
1060 /*@i@*/ return (c); /* not a real copy for conj's */
1061 default:
1062 llbug (message ("ctbase_copy: %q", ctbase_unparse (c)));
1063 }
1064
1065 BADEXIT;
1066}
1067
1068static enumNameList
1069ctbase_elist (ctbase c)
1070{
1071 llassert (ctbase_isDefined (c));
1072 llassert (c->type == CT_ENUM);
1073
1074 return (c->contents.cenum->members);
1075}
1076
1077static void
1078ctbase_free (/*@only@*/ ctbase c)
1079{
1080 if (c == ctbase_bool || c == ctbase_unknown)
1081 {
1082 /*@-mustfree@*/ return; /*@=mustfree@*/
1083 }
1084
1085 --nctbases;
1086
1087
1088 if (ctbase_isDefined (c))
1089 {
1090 switch (c->type)
1091 {
1092 case CT_UNKNOWN:
1093 sfree (c);
1094 break;
1095 case CT_PRIM:
1096 sfree (c);
1097 break;
1098 case CT_ENUM:
1099 sfree (c);
1100 break;
1101 case CT_ENUMLIST:
1102 /* sfree list? */
1103 sfree (c);
1104 break;
1105 case CT_USER:
1106 sfree (c);
1107 break;
1108 case CT_ABST:
1109 sfree (c);
1110 break;
1111 case CT_PTR:
1112 case CT_ARRAY:
1113 sfree (c);
1114 break;
1115 case CT_FCN:
1116
1117 if (c->contents.fcn->liveparams)
1118 {
1119 /* Because of liveparams, we know this can be released. */
1120
1121 /*@-dependenttrans@*/ /*@-unqualifiedtrans@*/
1122 uentryList_free (c->contents.fcn->params);
1123 c->contents.fcn->params = NULL;
1124 /*@=dependenttrans@*/ /*@=unqualifiedtrans@*/
1125 }
1126
1127 sfree (c);
1128 break;
1129 case CT_STRUCT:
1130 case CT_UNION:
1131 cstring_free (c->contents.su->name);
1132 uentryList_free (c->contents.su->fields);
1133 sfree (c);
1134 break;
1135 case CT_CONJ:
1136 /* Don't bree conj's, */
1137 break;
1138 default:
1139 sfree (c);
1140 break;
1141 }
1142 }
1143}
1144
1145/*
1146** c should be * <unknown>
1147*/
1148
1149static /*@only@*/ ctbase
1150ctbase_expectFunction (ctype c)
1151{
1152 ctbase f = ctbase_new ();
1153
1154 f->type = CT_EXPFCN;
1155 f->contents.base = c;
1156
1157 return (f);
1158}
1159
1160static bool
1161ctbase_genMatch (ctbase c1, ctbase c2, bool force, bool arg, bool def)
1162{
1163 ctuid c1tid, c2tid;
1164
1165 /* undefined types never match */
1166
1167 if (ctbase_isUndefined (c1) || ctbase_isUndefined (c2))
1168 return FALSE;
1169
1170 /* abstract types match user types of same name */
1171
1172 c1 = ctbase_realType (c1);
1173 c2 = ctbase_realType (c2);
1174
1175 c1tid = c1->type;
1176 c2tid = c2->type;
1177
1178 if (c1tid == CT_CONJ)
1179 {
1180 return (ctbase_genMatch (ctype_getCtbase (c1->contents.conj->a), c2,
1181 force, arg, def)
1182 || ctbase_genMatch (ctype_getCtbase (c1->contents.conj->b), c2,
1183 force, arg, def));
1184 }
1185
1186 if (c2tid == CT_CONJ)
1187 {
1188 return (ctbase_genMatch (c1, ctype_getCtbase (c2->contents.conj->a),
1189 force, arg, def)
1190 || ctbase_genMatch (c1, ctype_getCtbase (c2->contents.conj->b),
1191 force, arg, def));
1192 }
1193
1194 /*
1195 ** if the types don't match, there are some special cases...
1196 */
1197
1198 if (c1tid != c2tid)
1199 {
1200 /* unknowns match anything */
1201
1202 if (c1tid == CT_UNKNOWN || c2tid == CT_UNKNOWN)
1203 {
1204 return TRUE;
1205 }
1206
1207 if (c1tid == CT_FIXEDARRAY
1208 && (c2tid == CT_ARRAY || (!def && c2tid == CT_PTR)))
1209 {
1210 if (ctype_isVoid (c2->contents.base))
1211 {
1212 return (context_getFlag (FLG_ABSTVOIDP) ||
1213 (!(ctype_isRealAbstract (c1->contents.farray->base)) &&
1214 !(ctype_isRealAbstract (c2->contents.base))));
1215 }
1216
1217 return (ctbase_genMatch (ctype_getCtbase (c1->contents.farray->base),
1218 ctype_getCtbase (c2->contents.base),
1219 force, arg, def));
1220 }
1221
1222
1223 if (c2tid == CT_FIXEDARRAY
1224 && (c1tid == CT_ARRAY || (!def && c1tid == CT_PTR)))
1225 {
1226 if (ctype_isVoid (c1->contents.base))
1227 {
1228 return (context_getFlag (FLG_ABSTVOIDP) ||
1229 (!(ctype_isRealAbstract (c2->contents.farray->base)) &&
1230 !(ctype_isRealAbstract (c1->contents.base))));
1231 }
1232
1233 return (ctbase_genMatch (ctype_getCtbase (c1->contents.base),
1234 ctype_getCtbase (c2->contents.farray->base),
1235 force, arg, def));
1236 }
1237
1238 /* in most cases, bool and int are matched if FLG_BOOLINT */
1239
1240 if ((c1tid == CT_BOOL
1241 && (c2tid == CT_PRIM && cprim_isInt (c2->contents.prim))) ||
1242 (c2tid == CT_BOOL
1243 && (c1tid == CT_PRIM && cprim_isInt (c1->contents.prim))))
1244 {
1245 return (context_msgBoolInt ());
1246 }
1247
1248 if ((c1tid == CT_ENUM
1249 && (c2tid == CT_PRIM && cprim_isInt (c2->contents.prim))) ||
1250 (c2tid == CT_ENUM
1251 && (c1tid == CT_PRIM && cprim_isInt (c1->contents.prim))))
1252 {
1253 return (context_msgEnumInt ());
1254 }
1255
1256 /*
1257 ** arrays and pointers...yuk!
1258 **
1259 ** Considered equivalent except in definitions.
1260 ** (e.g., function parameters are equivalent)
1261 **
1262 */
1263
1264 if (!def)
1265 {
1266 if (ctuid_isAP (c1tid) && ctuid_isAP (c2tid))
1267 {
1268 c2tid = c1tid;
1269 }
1270 }
1271
1272 /*
1273 ** Function pointers can be removed.
1274 **
1275 ** [function ..] is equivalent to [function ..] *
1276 */
1277
1278 if (c1tid == CT_PTR && c2tid == CT_FCN)
1279 {
1280 if (ctype_isFunction (ctype_realType (c1->contents.base)))
1281 {
1282 c1 = ctbase_realType (ctype_getCtbaseSafe (c1->contents.base));
1283 c1tid = c1->type;
1284 }
1285 }
1286
1287 if (c2tid == CT_PTR && c1tid == CT_FCN)
1288 {
1289 if (ctype_isFunction (ctype_realType (c2->contents.base)))
1290 {
1291 c2 = ctbase_realType (ctype_getCtbaseSafe (c2->contents.base));
1292 c2tid = c2->type;
1293 }
1294 }
1295
1296 /*
1297 ** we allow forward declarations to structures like,
1298 **
1299 ** typedef struct _t *t;
1300 **
1301 ** to allow,
1302 ** struct _t * to match t
1303 */
1304
1305 if (context_getFlag (FLG_FORWARDDECL))
1306 {
1307 if (c1tid == CT_ABST || c1tid == CT_USER)
1308 {
1309 if (ctuid_isAP (c2tid))
1310 {
1311 ctype ts = c2->contents.base;
1312
1313 if (ctype_isUA (ts))
1314 {
1315 typeId ttid = ctype_typeId (ts);
1316 typeId ctid = c1->contents.tid ;
1317
1318 if (usymtab_matchForwardStruct (ctid, ttid))
1319 {
1320 return TRUE;
1321 }
1322 }
1323 }
1324 }
1325
1326 if (c2tid == CT_ABST || c2tid == CT_USER)
1327 {
1328 if (ctuid_isAP (c1tid))
1329 {
1330 ctype ts = c1->contents.base;
1331
1332 if (ctype_isUA (ts))
1333 {
1334 typeId ttid = ctype_typeId (ts);
1335 typeId ctid = c2->contents.tid ;
1336
1337 if (usymtab_matchForwardStruct (ctid, ttid))
1338 {
1339 return TRUE;
1340 }
1341 }
1342 }
1343 }
1344 }
1345 }
1346
1347 if (c1tid != c2tid)
1348 return FALSE;
1349
1350 switch (c1tid)
1351 {
1352 case CT_UNKNOWN:
1353 return (TRUE);
1354 case CT_PRIM:
1355 return (cprim_closeEnough (c1->contents.prim, c2->contents.prim));
1356 case CT_BOOL:
1357 return (TRUE);
1358 case CT_ABST:
1359 return (typeId_equal (c1->contents.tid, c2->contents.tid));
1360 case CT_USER:
1361 return (typeId_equal (c1->contents.tid, c2->contents.tid));
1362 case CT_ENUM:
1363 return (cstring_equal (c1->contents.cenum->tag, c2->contents.cenum->tag));
1364 case CT_PTR:
1365 if (ctype_isVoid (c1->contents.base)
1366 || (ctype_isVoid (c2->contents.base)))
1367 {
1368 if (ctype_isFunction (ctype_realType (c1->contents.base))
1369 || ctype_isFunction (ctype_realType (c2->contents.base)))
1370 {
1371 return (!context_getFlag (FLG_CASTFCNPTR));
1372 }
1373 else
1374 {
1375 return (context_getFlag (FLG_ABSTVOIDP) ||
1376 (!(ctype_isRealAbstract (c1->contents.base)) &&
1377 !(ctype_isRealAbstract (c2->contents.base))));
1378 }
1379 }
1380 else
1381 {
1382 /* Only allow one implicit function pointer. */
1383
1384 if (!bool_equal (ctype_isRealPointer (c1->contents.base),
1385 ctype_isRealPointer (c2->contents.base))
1386 && (ctype_isRealFunction (c1->contents.base)
1387 || ctype_isRealFunction (c2->contents.base)))
1388 {
1389 return FALSE;
1390 }
1391
1392 return (ctype_genMatch (c1->contents.base,
1393 c2->contents.base, force, arg, def));
1394 }
1395 case CT_FIXEDARRAY:
1396 if (ctype_isVoid (c1->contents.farray->base)
1397 || ctype_isVoid (c2->contents.farray->base))
1398 return TRUE;
1399 return (ctype_genMatch (c1->contents.farray->base,
1400 c2->contents.farray->base,
1401 force, arg, def));
1402 case CT_ARRAY:
1403 if (ctype_isVoid (c1->contents.base) || ctype_isVoid (c2->contents.base))
1404 return TRUE;
1405 return (ctype_genMatch (c1->contents.base, c2->contents.base, force, arg, def));
1406 case CT_FCN:
1407 return (ctype_genMatch (c1->contents.fcn->rval,
1408 c2->contents.fcn->rval,
1409 force, arg, def)
1410 && uentryList_matchParams (c1->contents.fcn->params,
1411 c2->contents.fcn->params,
1412 force, TRUE));
1413 case CT_STRUCT:
1414 case CT_UNION:
1415 if (!cstring_isEmpty (c1->contents.su->name))
1416 {
1417 return (cstring_equal (c1->contents.su->name, c2->contents.su->name));
1418 }
1419 else
1420 {
1421 if (!cstring_isEmpty (c2->contents.su->name))
1422 {
1423 return FALSE;
1424 }
1425
1426 llcontbuglit ("ctbase_genMatch: match fields");
1427 return (FALSE);
1428 }
1429 default:
1430 llcontbug (message ("ctbase_genMatch: unknown type: %d\n", (int)c1tid));
1431 return (FALSE);
1432 }
1433}
1434
1435/*
1436** like ctbase_match, except for conjuncts:
1437** modifies conjuncts to match only
1438*/
1439
1440static bool
1441ctbase_forceMatch (ctbase c1, ctbase c2)
1442{
1443 /*
1444 ** modifies c1, c2
1445 */
1446
1447 return (ctbase_genMatch (c1, c2, TRUE, FALSE, FALSE));
1448}
1449
1450static bool
1451ctbase_match (ctbase c1, ctbase c2) /*@modifies nothing@*/
1452{
1453 return (ctbase_genMatch (c1, c2, FALSE, FALSE, FALSE));
1454}
1455
1456static bool
1457ctbase_matchDef (ctbase c1, ctbase c2) /*@modifies nothing@*/
1458{
1459 return (ctbase_genMatch (c1, c2, FALSE, FALSE, TRUE));
1460}
1461
1462static bool
1463ctbase_matchArg (ctbase c1, ctbase c2)
1464{
1465 return (ctbase_genMatch (c1, c2, FALSE, TRUE, FALSE));
1466}
1467
1468static /*@out@*/ /*@only@*/ /*@notnull@*/ ctbase
1469ctbase_new ()
1470{
1471 ctbase c = (ctbase) dmalloc (sizeof (*c));
1472
1473 nctbases++;
1474 /*
1475 if (nctbases % 100 == 0 && nctbases > lastnc)
1476 {
1477 llmsg (message ("ctbases: %d", nctbases));
1478 lastnc = nctbases;
1479 }
1480 */
1481 return (c);
1482}
1483
1484static /*@only@*/ ctbase
1485ctbase_createPrim (cprim p)
1486{
1487 ctbase c = ctbase_new ();
1488
1489 c->type = CT_PRIM;
1490 c->contents.prim = p;
1491
1492 return (c);
1493}
1494
1495static /*@observer@*/ ctbase
1496ctbase_getBool (void)
1497{
1498 /*@i@*/ return ctbase_createBool ();
1499}
1500
1501static ctbase
1502ctbase_createBool ()
1503{
1504 if (!ctbase_isDefined (ctbase_bool))
1505 {
1506 ctbase_bool = ctbase_new ();
1507 ctbase_bool->type = CT_BOOL;
1508 ctbase_bool->contents.prim = CTX_BOOL;
1509 }
1510
1511 /*@-retalias@*/ /*@-globstate@*/
1512 return ctbase_bool;
1513 /*@=retalias@*/ /*@=globstate@*/
1514}
1515
1516static /*@only@*/ ctbase
1517ctbase_createUser (typeId u)
1518{
1519 ctbase c = ctbase_new ();
1520
1521 c->type = CT_USER;
1522 c->contents.tid = u;
1523
1524 llassert (typeId_isValid (u));
1525
1526 return (c);
1527}
1528
1529static /*@only@*/ ctbase
1530ctbase_createEnum (/*@keep@*/ cstring etag, /*@keep@*/ enumNameList emembers)
1531{
1532 ctbase c = ctbase_new ();
1533
1534 c->type = CT_ENUM;
1535
1536 if (cstring_isUndefined (etag))
1537 {
1538 llcontbuglit ("Undefined enum tag!");
1539 etag = fakeTag ();
1540 }
1541
1542 c->contents.cenum = (tenum) dmalloc (sizeof (*c->contents.cenum));
1543 c->contents.cenum->tag = etag;
1544 c->contents.cenum->members = emembers;
1545
1546 return (c);
1547}
1548
1549static /*@observer@*/ cstring
1550ctbase_enumTag (/*@notnull@*/ ctbase ct)
1551{
1552 return (ct->contents.cenum->tag);
1553}
1554
1555static /*@only@*/ ctbase
1556ctbase_createAbstract (typeId u)
1557{
1558 ctbase c = ctbase_new ();
1559
1560 c->type = CT_ABST;
1561 c->contents.tid = u;
1562
1563 /* also check its abstract? */
1564
1565 llassert (typeId_isValid (c->contents.tid));
1566
1567 return (c);
1568}
1569
1570static /*@only@*/ ctbase
1571ctbase_createUnknown (void)
1572{
1573 if (!ctbase_isDefined (ctbase_unknown))
1574 {
1575 ctbase_unknown = ctbase_new ();
1576 ctbase_unknown->type = CT_UNKNOWN;
1577 ctbase_unknown->contents.prim = CTX_UNKNOWN;
1578 }
1579
1580 /*@-retalias@*/ /*@-globstate@*/
1581 return ctbase_unknown;
1582 /*@=retalias@*/ /*@=globstate@*/
1583}
1584
1585/*
1586** requires: result is not assigned to b
1587** (should copy, but no way to reclaim storage)
1588*/
1589
1590static /*@only@*/ ctbase
1591ctbase_makePointer (ctype b)
1592{
1593 ctbase c = ctbase_new ();
1594
1595 c->type = CT_PTR;
1596 c->contents.base = b;
1597
1598 return (c);
1599}
1600
1601static /*@only@*/ ctbase
1602ctbase_makeArray (ctype b)
1603{
1604 ctbase c = ctbase_new ();
1605
1606 c->type = CT_ARRAY;
1607 c->contents.base = b;
1608
1609 return (c);
1610}
1611
1612static /*@notnull@*/ /*@only@*/ ctbase
1613ctbase_makeFixedArray (ctype b, long size)
1614{
1615 ctbase c = ctbase_new ();
1616
1617 c->type = CT_FIXEDARRAY;
1618
1619 c->contents.farray = (tfixed) dmalloc (sizeof (*c->contents.farray));
1620 c->contents.farray->base = b;
1621 c->contents.farray->size = size;
1622
1623 return (c);
1624}
1625
1626static ctype
1627ctbase_makeFunction (ctype b, /*@only@*/ uentryList p)
1628{
1629 ctbase c = ctbase_new ();
1630 ctype ct;
1631
1632 c->type = CT_FCN;
1633 c->contents.fcn = (cfcn) dmalloc (sizeof (*c->contents.fcn));
1634
1635 if (ctype_isFunction (b)) /* was: && ctype_isPointer (b)) */
1636 {
1637 ctbase ctb;
1638 ctype rval;
1639
1640 if (ctype_isPointer (b))
1641 {
1642 ctb = ctype_getCtbase (ctype_baseArrayPtr (b));
1643 }
1644 else
1645 {
1646 ctb = ctype_getCtbase (b);
1647 }
1648
1649 llassert (ctbase_isDefined (ctb));
1650 llassert (ctb->type == CT_FCN);
1651
1652 rval = ctype_makeFunction (ctb->contents.fcn->rval, p);
1653
1654 c->contents.fcn->rval = rval;
1655 c->contents.fcn->params = ctb->contents.fcn->params;
1656 c->contents.fcn->liveparams = FALSE;
1657 }
1658 else
1659 {
1660 c->contents.fcn->rval = b;
1661 /*@i@*/ c->contents.fcn->params = p;
1662 c->contents.fcn->liveparams = TRUE;
1663 /*@-branchstate@*/ /* p is really released on this branch */
1664 }
1665 /*@=branchstate@*/
1666
1667 ct = cttable_addComplex (c);
1668 return (ct); /* was: ctype_makePointer (ct)); */
1669}
1670
1671static ctype
1672ctbase_makeNFFunction (ctype b, /*@only@*/ uentryList p)
1673{
1674 ctbase c = ctbase_new ();
1675 ctype ct;
1676
1677 c->type = CT_FCN;
1678 c->contents.fcn = (cfcn) dmalloc (sizeof (*c->contents.fcn));
1679
1680 if (ctype_isFunction (b)) /* was && ctype_isPointer (b)) */
1681 {
1682 ctbase ctb;
1683 ctype rval;
1684
1685 if (ctype_isPointer (b))
1686 {
1687 ctb = ctype_getCtbase (ctype_baseArrayPtr (b));
1688 }
1689 else
1690 {
1691 ctb = ctype_getCtbase (b);
1692 }
1693
1694 llassert (ctbase_isDefined (ctb));
1695 llassert (ctb->type == CT_FCN);
1696
1697 rval = ctype_makeNFParamsFunction (ctb->contents.fcn->rval, p);
1698
1699 c->contents.fcn->rval = rval;
1700 c->contents.fcn->params = ctb->contents.fcn->params;
1701 c->contents.fcn->liveparams = FALSE;
1702 }
1703 else
1704 {
1705 c->contents.fcn->rval = b;
1706 /*@i@*/ c->contents.fcn->params = p;
1707 c->contents.fcn->liveparams = TRUE;
1708
1709 /*@-branchstate@*/
1710 }
1711 /*@=branchstate@*/
1712
1713 ct = cttable_addComplex (c);
1714 return (ct); /* was: ctype_makePointer (ct)); */
1715}
1716
1717static /*@only@*/ ctbase
1718 ctbase_makeLiveFunction (ctype b, /*@owned@*/ uentryList p)
1719{
1720 ctbase c = ctbase_new ();
1721
1722 c->type = CT_FCN;
1723
1724 c->contents.fcn = (cfcn) dmalloc (sizeof (*c->contents.fcn));
1725 c->contents.fcn->rval = b;
1726 c->contents.fcn->params = p;
1727 c->contents.fcn->liveparams = TRUE;
1728
1729 /*@-mustfree@*/ return (c); /*@=mustfree@*/
1730}
1731
1732static /*@only@*/ ctbase
1733 ctbase_makeRealFunction (ctype b, /*@dependent@*/ uentryList p)
1734{
1735 ctbase c = ctbase_new ();
1736
1737 c->type = CT_FCN;
1738
1739 c->contents.fcn = (cfcn) dmalloc (sizeof (*c->contents.fcn));
1740 c->contents.fcn->rval = b;
1741 c->contents.fcn->params = p;
1742 c->contents.fcn->liveparams = FALSE;
1743
1744 return (c);
1745}
1746
1747static /*@observer@*/ /*@notnull@*/ ctbase
1748ctbase_realFunction (/*@dependent@*/ /*@notnull@*/ ctbase c)
1749{
1750 ctbase res;
1751
1752 if (c->type == CT_FCN)
1753 {
1754 return c;
1755 }
1756
1757 llassert (ctbase_isFunction (c));
1758
1759 res = ctype_getCtbase (c->contents.base);
1760
1761 llassert (ctbase_isDefined (res));
1762
1763 return (res);
1764}
1765
1766static bool
1767ctbase_isFunction (ctbase c)
1768{
1769 llassert (c != ctbase_undefined);
1770
1771 if (c->type == CT_FCN)
1772 {
1773 return TRUE;
1774 }
1775 else
1776 {
1777 if (c->type == CT_PTR)
1778 {
1779 ctbase fcn = ctype_getCtbase (ctbase_baseArrayPtr (c));
1780
1781 return (ctbase_isDefined (fcn) && fcn->type == CT_FCN);
1782 }
1783
1784 return FALSE;
1785 }
1786}
1787
1788/* doesn't copy c1 and c2 */
1789
1790static /*@only@*/ ctbase
1791 ctbase_makeConj (ctype c1, ctype c2, bool isExplicit)
1792{
1793 ctbase c = ctbase_new ();
1794
1795 c->type = CT_CONJ;
1796
1797 c->contents.conj = (tconj) dmalloc (sizeof (*c->contents.conj));
1798 c->contents.conj->a = c1;
1799 c->contents.conj->b = c2;
1800 c->contents.conj->isExplicit = isExplicit;
1801
1802 return (c);
1803}
1804
1805static ctype
1806ctbase_getConjA (/*@notnull@*/ ctbase c)
1807{
1808 llassert (c->type == CT_CONJ);
1809 return (c->contents.conj->a);
1810}
1811
1812static ctype
1813ctbase_getConjB (/*@notnull@*/ ctbase c)
1814{
1815 llassert (c->type == CT_CONJ);
1816 return (c->contents.conj->b);
1817}
1818
1819static bool
1820ctbase_isExplicitConj (/*@notnull@*/ ctbase c)
1821{
1822 llassert (c->type == CT_CONJ);
1823 return (c->contents.conj->isExplicit);
1824}
1825
1826static /*@only@*/ ctbase
1827ctbase_createStruct (/*@only@*/ cstring n, /*@only@*/ uentryList f)
1828{
1829 ctbase c = ctbase_new ();
1830
1831 c->type = CT_STRUCT;
1832
1833 c->contents.su = (tsu) dmalloc (sizeof (*c->contents.su));
1834 c->contents.su->name = n;
1835 c->contents.su->fields = f;
1836
1837 return (c);
1838}
1839
1840static /*@observer@*/ uentryList
1841ctbase_getuentryList (/*@notnull@*/ ctbase c)
1842{
1843 c = ctbase_realType (c);
1844
1845 if (!(c->type == CT_STRUCT || c->type == CT_UNION))
1846 llfatalbug (message ("ctbase_getuentryList: bad invocation: %q", ctbase_unparse (c)));
1847
1848 return (c->contents.su->fields);
1849}
1850
1851static ctbase
1852ctbase_createUnion (/*@keep@*/ cstring n, /*@only@*/ uentryList f)
1853{
1854 ctbase c = ctbase_new ();
1855
1856 c->type = CT_UNION;
1857
1858 c->contents.su = (tsu) dmalloc (sizeof (*c->contents.su));
1859 c->contents.su->name = n;
1860 c->contents.su->fields = f;
1861
1862 return (c);
1863}
1864
1865static ctype
1866ctbase_baseArrayPtr (/*@notnull@*/ ctbase c)
1867{
1868 ctuid ct;
1869 c = ctbase_realType (c);
1870 ct = c->type;
1871
1872 if (ct == CT_FIXEDARRAY)
1873 {
1874 return c->contents.farray->base;
1875 }
1876 else
1877 {
1878 llassert (ctuid_isAP (ct));
1879
1880 return c->contents.base;
1881 }
1882}
1883
1884static ctype
1885ctbase_baseFunction (/*@notnull@*/ ctbase c)
1886{
1887 ctbase_fixUser (c);
1888 c = ctbase_realFunction (c);
1889
1890 if (c->type != CT_FCN)
1891 {
1892 llfatalbug (message ("ctbase_baseFunction: bad call: %q", ctbase_unparse (c)));
1893 }
1894
1895 return (c->contents.fcn->rval);
1896}
1897
1898static uentryList
1899ctbase_argsFunction (/*@notnull@*/ ctbase c)
1900{
1901 ctbase_fixUser (c);
1902 c = ctbase_realFunction (c);
1903
1904 if (c->type != CT_FCN)
1905 {
1906 llfatalbug (message ("ctbase_argsFunction: bad call: %q",
1907 ctbase_unparse (c)));
1908 }
1909 return (c->contents.fcn->params);
1910}
1911
1912static bool
1913ctbase_baseisExpFcn (ctype c)
1914{
1915 ctbase cb;
1916 c = ctype_removePointers (c);
1917
1918 cb = ctype_getCtbase (c);
1919 llassert (ctbase_isDefined (cb));
1920
1921 if (cb->type == CT_FCN)
1922 {
1923 c = ctype_removePointers (ctype_returnValue (c));
1924
1925 cb = ctype_getCtbase (c);
1926 llassert (ctbase_isDefined (cb));
1927
1928 return (cb->type == CT_EXPFCN);
1929 }
1930 return FALSE;
1931}
1932
1933/*
1934** ctbase_newBase behaves specially when p is a CONJ:
1935**
1936** c -> conj (newBase (c, p.a), p.b)
1937*/
1938
1939static ctype
1940ctbase_newBase (ctype c, ctype p)
1941{
1942 ctbase cb;
1943
1944 DPRINTF (("New base: %s / %s", ctype_unparse (c), ctype_unparse (p)));
1945
1946 cb = ctype_getCtbase (c);
1947
1948 if (ctype_isUndefined (c))
1949 {
1950 return p;
1951 }
1952
1953 if (ctype_isConj (p))
1954 {
1955 ctbase pb = ctype_getCtbase (p);
1956
1957 llassert (ctbase_isDefined (pb));
1958
1959 if (pb->contents.conj->isExplicit)
1960 {
1961 return (ctype_makeExplicitConj (ctype_newBase (c, pb->contents.conj->a),
1962 pb->contents.conj->b));
1963
1964 }
1965 else
1966 {
1967 return (ctype_makeConj (ctype_newBase (c, pb->contents.conj->a),
1968 pb->contents.conj->b));
1969
1970 }
1971 }
1972
1973 if (ctbase_baseisExpFcn (c))
1974 {
1975 return (ctbase_newBaseExpFcn (c, p));
1976 }
1977
1978 llassert (ctbase_isDefined (cb));
1979
1980 switch (cb->type)
1981 {
1982 case CT_UNKNOWN:
1983 case CT_PRIM:
1984 case CT_USER:
1985 case CT_ENUM:
1986 case CT_ABST:
1987 case CT_STRUCT:
1988 case CT_UNION:
1989 case CT_EXPFCN:
1990 return (p);
1991
1992 case CT_PTR:
1993 {
1994 ctype ret;
1995 ctype cbn;
1996
1997 cbn = ctbase_newBase (cb->contents.base, p);
1998 ret = ctype_makePointer (cbn);
1999
2000 return ret;
2001 }
2002 case CT_FIXEDARRAY:
2003 return (ctype_makeFixedArray (ctbase_newBase (cb->contents.farray->base, p),
2004 cb->contents.farray->size));
2005 case CT_ARRAY:
2006 return (ctype_makeArray (ctbase_newBase (cb->contents.base, p)));
2007 case CT_FCN:
2008 return (ctype_makeRealFunction (ctbase_newBase (cb->contents.fcn->rval, p),
2009 cb->contents.fcn->params));
2010 case CT_CONJ:
2011 return (ctype_makeConjAux (ctbase_newBase (cb->contents.conj->a, p),
2012 ctbase_newBase (cb->contents.conj->b, p),
2013 cb->contents.conj->isExplicit));
2014 default:
2015 llcontbug (message ("ctbase_newBase: bad ctbase: %q", ctbase_unparse (cb)));
2016 return (p);
2017 }
2018 BADEXIT;
2019}
2020
2021static ctype
2022ctbase_newBaseExpFcn (ctype c, ctype p)
2023{
2024 ctbase cb = ctype_getCtbase (c);
2025 ctbase tcb;
2026 ctype ret, tmpct;
2027 ctype fp = ctype_unknown;
2028 uentryList ctargs = ctype_argsFunction (c);
2029
2030 /*
2031 ** okay, this is really ugly...
2032 **
2033 ** pointers inside <expf> mean pointers to the function;
2034 ** pointers outside <expf> are pointers to the return value;
2035 ** because its a function there is one superfluous pointer.
2036 */
2037
2038 /*
2039 ** bf is a ctype, used to derived structure of cb
2040 */
2041
2042 if (!ctbase_isFunction (cb))
2043 llbuglit ("ctbase_newBaseExpFcn: expFcn -> not a function");
2044
2045 tmpct = ctype_getBaseType (ctype_returnValue (c));
2046
2047 /*
2048 ** pointers before expfcn -> p are pointers to function, not result
2049 **
2050 */
2051
2052 tcb = ctype_getCtbase (tmpct);
2053
2054 llassert (ctbase_isDefined (tcb));
2055 tmpct = tcb->contents.base;
2056
2057 /*
2058 ** record pointers to base in fp
2059 */
2060
2061 while (!ctype_isUnknown (tmpct))
2062 {
2063 if (ctype_isExpFcn (tmpct)) {
2064 ctbase ttcb = ctype_getCtbase (tmpct);
2065
2066 /*
2067 ** evs 2000-05-16: This is necessary to deal with function pointers in parens.
2068 ** The whole function pointer parsing is a major kludge, but it seems to work,
2069 ** and I'm only embarrassed by it when I haven't look at the C spec recently...
2070 */
2071
2072 llassert (ctbase_isDefined (ttcb));
2073 tmpct = ttcb->contents.base;
2074 llassert (!ctype_isUnknown (tmpct));
2075 }
2076
2077 switch (ctype_getCtKind (tmpct))
2078 {
2079 case CTK_PTR:
2080 fp = ctype_makePointer (fp);
2081 /*@switchbreak@*/ break;
2082 case CTK_ARRAY:
2083 fp = ctype_makeArray (fp);
2084 /*@switchbreak@*/ break;
2085 case CTK_COMPLEX:
2086 {
2087 ctbase fbase = ctype_getCtbase (tmpct);
2088
2089 if (ctbase_isFunction (fbase))
2090 {
2091 fp = ctype_makeFunction (fp, uentryList_copy (ctargs));
2092 ctargs = ctbase_argsFunction (fbase);
2093 }
2094 else
2095 {
2096 llbug
2097 (message
2098 ("ctbase_newBaseExpFcn: fixing expfunction: bad complex type: %s [base: %q]",
2099 ctype_unparse (tmpct), ctbase_unparse (fbase)));
2100 }
2101 goto exitLoop;
2102 }
2103 default:
2104 {
2105 llcontbug
2106 (message ("ctbase_newBaseExpFcn: fixing expfunction: bad type: %s",
2107 ctype_unparse (tmpct)));
2108 goto exitLoop;
2109 }
2110 }
2111 tmpct = ctype_baseArrayPtr (tmpct);
2112 }
2113
2114 exitLoop:
2115 tmpct = ctype_returnValue (c);
2116
2117 /*
2118 ** pointers to expf are pointers to return value
2119 */
2120
2121 while (!ctype_isExpFcn (tmpct))
2122 {
2123 switch (ctype_getCtKind (tmpct))
2124 {
2125 case CTK_PTR:
2126 p = ctype_makePointer (p);
2127 /*@switchbreak@*/ break;
2128 case CTK_ARRAY:
2129 p = ctype_makeArray (p);
2130 /*@switchbreak@*/ break;
2131 case CTK_COMPLEX:
2132 {
2133 ctbase fbase = ctype_getCtbase (tmpct);
2134
2135 if (ctbase_isFunction (fbase))
2136 {
2137 p = ctype_makeFunction (p, uentryList_copy (ctbase_argsFunction (fbase)));
2138 }
2139 else
2140 {
2141 llbug
2142 (message
2143 ("ctbase_newBaseExpFcn: fixing expfunction: bad complex type: %s",
2144 ctype_unparse (tmpct)));
2145 }
2146 goto exitLoop2;
2147 }
2148
2149 default:
2150 {
2151 llcontbug
2152 (message ("ctbase_newBaseExpFcn: fixing expfunction2: bad type: %t",
2153 tmpct));
2154 goto exitLoop2;
2155 }
2156 }
2157 tmpct = ctype_baseArrayPtr (tmpct);
2158 }
2159
2160 exitLoop2:
2161
2162 /*
2163 ** pointers to fp are pointers to function type
2164 */
2165
2166 ret = ctype_makeRealFunction (p, ctargs);
2167
2168 while (ctype_getCtKind (fp) > CTK_PLAIN)
2169 {
2170 switch (ctype_getCtKind (fp))
2171 {
2172 case CTK_PTR:
2173 ret = ctype_makePointer (ret);
2174 /*@switchbreak@*/ break;
2175 case CTK_ARRAY:
2176 ret = ctype_makeArray (ret);
2177 /*@switchbreak@*/ break;
2178 case CTK_COMPLEX:
2179 {
2180 ctbase fbase = ctype_getCtbase (fp);
2181
2182 if (ctbase_isFunction (fbase))
2183 {
2184 ret =
2185 ctype_makeFunction (ret,
2186 uentryList_copy (ctbase_argsFunction (fbase)));
2187 }
2188 else
2189 {
2190 BADBRANCH;
2191 }
2192 goto exitLoop3;
2193 }
2194
2195 default:
2196 {
2197 llcontbug (message ("post-fixing expfunction: bad type: %t", fp));
2198 goto exitLoop3;
2199 }
2200 }
2201 fp = ctype_baseArrayPtr (fp);
2202 }
2203
2204 exitLoop3:
2205 return (ret);
2206}
2207
2208/*
2209** returns lowest level base of c: plain type
2210*/
2211
2212static /*@notnull@*/ /*@only@*/ ctbase
2213ctbase_getBaseType (/*@notnull@*/ ctbase c)
2214{
2215 switch (c->type)
2216 {
2217 case CT_UNKNOWN:
2218 case CT_PRIM:
2219 case CT_USER:
2220 case CT_ENUM:
2221 case CT_ENUMLIST:
2222 case CT_BOOL:
2223 case CT_ABST:
2224 case CT_FCN:
2225 case CT_STRUCT:
2226 case CT_UNION:
2227 return (ctbase_copy (c));
2228
2229 case CT_PTR:
2230 case CT_ARRAY:
2231 return (ctbase_getBaseType (ctype_getCtbaseSafe (c->contents.base)));
2232
2233 case CT_FIXEDARRAY:
2234 return (ctbase_getBaseType (ctype_getCtbaseSafe (c->contents.farray->base)));
2235 case CT_CONJ: /* base type of A conj branch? */
2236 return (ctbase_getBaseType (ctype_getCtbaseSafe (c->contents.conj->a)));
2237 case CT_EXPFCN:
2238 return (ctbase_copy (c));
2239
2240 default:
2241 llfatalbug (message ("ctbase_getBaseType: bad ctbase: %q", ctbase_unparse (c)));
2242 }
2243
2244 BADEXIT;
2245}
2246
2247static int
2248ctbase_compare (ctbase c1, ctbase c2, bool strict)
2249{
2250 ctuid c1tid, c2tid;
2251
2252 if (ctbase_isUndefined (c1) || ctbase_isUndefined (c2))
2253 {
2254 llcontbuglit ("ctbase_compare: undefined ctbase");
2255 return -1;
2256 }
2257
2258 c1tid = c1->type;
2259 c2tid = c2->type;
2260
2261 if (c1tid < c2tid)
2262 return -1;
2263 if (c1tid > c2tid)
2264 return 1;
2265
2266 switch (c1tid)
2267 {
2268 case CT_UNKNOWN:
2269 return 0;
2270 case CT_PRIM:
2271 return (int_compare (c1->contents.prim, c2->contents.prim));
2272 case CT_BOOL:
2273 return 0;
2274 case CT_USER:
2275 return (int_compare (c1->contents.tid, c2->contents.tid));
2276 case CT_ENUMLIST:
2277 return 1;
2278 case CT_ENUM: /* for now, keep like abstract */
2279 case CT_ABST:
2280 return (int_compare (c1->contents.tid, c2->contents.tid));
2281 case CT_PTR:
2282 return (ctype_compare (c1->contents.base, c2->contents.base));
2283 case CT_FIXEDARRAY:
2284 INTCOMPARERETURN (c1->contents.farray->size, c2->contents.farray->size);
2285
2286 return (ctype_compare (c1->contents.farray->base,
2287 c2->contents.farray->base));
2288 case CT_ARRAY:
2289 return (ctype_compare (c1->contents.base, c2->contents.base));
2290 case CT_FCN:
2291 {
2292 COMPARERETURN (ctype_compare (c1->contents.fcn->rval, c2->contents.fcn->rval));
2293
2294 if (strict)
2295 {
2296 return (uentryList_compareStrict (c1->contents.fcn->params,
2297 c2->contents.fcn->params));
2298 }
2299 else
2300 {
2301 return (uentryList_compareParams (c1->contents.fcn->params,
2302 c2->contents.fcn->params));
2303 }
2304 }
2305 case CT_EXPFCN:
2306 return (ctype_compare (c1->contents.base, c2->contents.base));
2307 case CT_STRUCT:
2308 case CT_UNION:
2309 return (uentryList_compareFields (c1->contents.su->fields,
2310 c2->contents.su->fields));
2311 case CT_CONJ:
2312 {
2313 COMPARERETURN (ctype_compare (c1->contents.conj->a,
2314 c2->contents.conj->a));
2315 COMPARERETURN (ctype_compare (c1->contents.conj->b,
2316 c2->contents.conj->b));
2317 return (bool_compare (c1->contents.conj->isExplicit,
2318 c2->contents.conj->isExplicit));
2319 }
2320 }
2321 BADEXIT;
2322}
2323
2324static int
2325ctbase_compareStrict (/*@notnull@*/ ctbase c1, /*@notnull@*/ ctbase c2)
2326{
2327 return (ctbase_compare (c1, c2, TRUE));
2328}
2329
2330static bool ctbase_equivStrict (/*@notnull@*/ ctbase c1, /*@notnull@*/ ctbase c2)
2331{
2332 return (ctbase_compareStrict (c1,c2) == 0);
2333}
2334
2335static bool ctbase_equiv (/*@notnull@*/ ctbase c1, /*@notnull@*/ ctbase c2)
2336{
2337 return (ctbase_compare (c1, c2, FALSE) == 0);
2338}
2339
2340static bool
2341ctbase_isKind (/*@notnull@*/ ctbase c, ctuid kind)
2342{
2343 ctuid ck = c->type;
2344
2345 if (ck == kind)
2346 return TRUE;
2347
2348 if (ck == CT_CONJ)
2349 return (ctbase_isKind (ctype_getCtbaseSafe (c->contents.conj->a), kind) ||
2350 ctbase_isKind (ctype_getCtbaseSafe (c->contents.conj->b), kind));
2351
2352 return FALSE;
2353}
2354
2355static bool
2356ctbase_isKind2 (/*@notnull@*/ ctbase c, ctuid kind1, ctuid kind2)
2357{
2358 ctuid ck = c->type;
2359
2360 if (ck == kind1 || ck == kind2)
2361 return TRUE;
2362
2363 if (ck == CT_CONJ)
2364 return (ctbase_isKind2 (ctype_getCtbaseSafe (c->contents.conj->a), kind1, kind2) ||
2365 ctbase_isKind2 (ctype_getCtbaseSafe (c->contents.conj->b), kind1, kind2));
2366
2367 return FALSE;
2368}
2369
2370static bool
2371ctbase_isAbstract (/*@notnull@*/ ctbase c)
2372{
2373 return (c->type == CT_ABST);
2374}
2375
2376static bool ctbase_isUA (ctbase c)
2377{
2378 return (ctbase_isDefined (c) && ((c)->type == CT_USER || (c)->type == CT_ABST));
2379}
2380
2381static bool
2382ctbase_almostEqual (ctbase c1, ctbase c2)
2383{
2384 ctuid c1tid, c2tid;
2385
2386 /* undefined types never match */
2387
2388 if (ctbase_isUndefined (c1) || ctbase_isUndefined (c2))
2389 return FALSE;
2390
2391 c1tid = c1->type;
2392 c2tid = c2->type;
2393
2394 if (c1tid == CT_FIXEDARRAY && c2tid == CT_ARRAY)
2395 {
2396 return (ctbase_almostEqual (ctype_getCtbase (c1->contents.farray->base),
2397 ctype_getCtbase (c2->contents.base)));
2398 }
2399
2400 if (c2tid == CT_FIXEDARRAY && c1tid == CT_ARRAY)
2401 {
2402 return (ctbase_almostEqual (ctype_getCtbase (c1->contents.base),
2403 ctype_getCtbase (c2->contents.farray->base)));
2404 }
2405
2406 if (c1tid != c2tid)
2407 return FALSE;
2408
2409 switch (c1tid)
2410 {
2411 case CT_UNKNOWN:
2412 return TRUE;
2413 case CT_PRIM:
2414 return (cprim_equal (c1->contents.prim, c2->contents.prim));
2415 case CT_BOOL:
2416 return TRUE;
2417 case CT_ABST:
2418 return (typeId_equal (c1->contents.tid, c2->contents.tid));
2419 case CT_USER:
2420 return (typeId_equal (c1->contents.tid, c2->contents.tid));
2421 case CT_ENUM:
2422 return (cstring_equal (c1->contents.cenum->tag, c2->contents.cenum->tag));
2423 case CT_PTR:
2424 return (ctype_almostEqual (c1->contents.base, c2->contents.base));
2425 case CT_FIXEDARRAY:
2426 return (ctype_almostEqual (c1->contents.farray->base,
2427 c2->contents.farray->base));
2428 case CT_ARRAY:
2429 return (ctype_almostEqual (c1->contents.base, c2->contents.base));
2430 case CT_FCN:
2431 return (ctype_almostEqual (c1->contents.fcn->rval, c2->contents.fcn->rval)
2432 && uentryList_matchParams (c1->contents.fcn->params,
2433 c2->contents.fcn->params, FALSE, TRUE));
2434 case CT_STRUCT:
2435 case CT_UNION:
2436 if (!cstring_isEmpty (c1->contents.su->name))
2437 {
2438 return (cstring_equal (c1->contents.su->name, c2->contents.su->name));
2439 }
2440 else
2441 {
2442 if (!cstring_isEmpty (c2->contents.su->name))
2443 {
2444 return FALSE;
2445 }
2446
2447 llcontbuglit ("ctbase_almostEqual: match fields");
2448 return (FALSE);
2449 }
2450 default:
2451 llcontbug (message ("ctbase_almostEqual: unknown type: %d\n", (int)c1tid));
2452 return (FALSE);
2453 }
2454}
git-cvsimport mirror of splint
This page took 0.371401 seconds and 5 git commands to generate.