1 /*
2 * Copyright © 1988-2004 Keith Packard and Bart Massey.
3 * All Rights Reserved. See the file COPYING in this directory
4 * for licensing information.
5 */
6
7 /*
8 * type.c
9 *
10 * manage datatype
11 */
12
13 #include "nickle.h"
14 #include "gram.h"
15
16 Type *typePoly;
17 Type *typeRefPoly;
18 Type *typeArrayInt;
19 Type *typePrim[rep_void + 1];
20
21 static void
TypeNameMark(void * object)22 TypeNameMark (void *object)
23 {
24 TypeName *tn = object;
25
26 MemReference (tn->name);
27 }
28
29 static void
TypeRefMark(void * object)30 TypeRefMark (void *object)
31 {
32 TypeRef *tr = object;
33
34 MemReference (tr->ref);
35 }
36
37 static void
ArgTypeMark(void * object)38 ArgTypeMark (void *object)
39 {
40 ArgType *at = object;
41
42 MemReference (at->type);
43 MemReference (at->next);
44 }
45
46 static void
TypeFuncMark(void * object)47 TypeFuncMark (void *object)
48 {
49 TypeFunc *tf = object;
50
51 MemReference (tf->ret);
52 MemReference (tf->args);
53 }
54
55 static void
TypeArrayMark(void * object)56 TypeArrayMark (void *object)
57 {
58 TypeArray *ta = object;
59
60 MemReference (ta->type);
61 MemReference (ta->dimensions);
62 switch (ta->storage) {
63 case DimStorageNone:
64 break;
65 case DimStorageGlobal:
66 MemReference (ta->u.global);
67 break;
68 case DimStorageStatic:
69 case DimStorageAuto:
70 MemReference (ta->u.frame.code);
71 break;
72 }
73 }
74
75 static void
TypeHashMark(void * object)76 TypeHashMark (void *object)
77 {
78 TypeHash *th = object;
79
80 MemReference (th->type);
81 MemReference (th->keyType);
82 }
83
84 static void
TypeStructMark(void * object)85 TypeStructMark (void *object)
86 {
87 TypeStruct *ts = object;
88
89 MemReference (ts->structs);
90 MemReference (ts->left);
91 MemReference (ts->right);
92 }
93
94 static void
TypeTypesMark(void * object)95 TypeTypesMark (void *object)
96 {
97 TypeTypes *type = object;
98 MemReference (type->elt);
99 }
100
101 DataType TypePrimType = { 0, 0, "TypePrimType" };
102 DataType TypeNameType = { TypeNameMark, 0, "TypeNameType" };
103 DataType TypeRefType = { TypeRefMark, 0, "TypeRefType" };
104 DataType ArgTypeType = { ArgTypeMark, 0, "ArgTypeType" };
105 DataType TypeFuncType = { TypeFuncMark, 0, "TypeFuncType" };
106 DataType TypeArrayType = { TypeArrayMark, 0, "TypeArrayType" };
107 DataType TypeHashType = { TypeHashMark, 0, "TypeHashType" };
108 DataType TypeStructType = { TypeStructMark, 0, "TypeStructType" };
109 DataType TypeUnitType = { 0, 0, "TypeUnitType" };
110 DataType TypeTypesType = { TypeTypesMark, 0, "TypeTypesType" };
111
112 static Type *
NewTypePrim(Rep prim)113 NewTypePrim (Rep prim)
114 {
115 ENTER ();
116 Type *t;
117
118 t = ALLOCATE (&TypePrimType, sizeof (TypePrim));
119 t->base.tag = type_prim;
120 t->prim.prim = prim;
121 RETURN (t);
122 }
123
124 Type *
NewTypeName(ExprPtr expr,Symbol * name)125 NewTypeName (ExprPtr expr, Symbol *name)
126 {
127 ENTER ();
128 Type *t;
129
130 t = ALLOCATE (&TypeNameType, sizeof (TypeName));
131 t->base.tag = type_name;
132 t->name.expr = expr;
133 t->name.name = name;
134 RETURN (t);
135 }
136
137 Type *
NewTypeRef(Type * ref,Bool pointer)138 NewTypeRef (Type *ref, Bool pointer)
139 {
140 ENTER ();
141 Type *t;
142
143 if (!ref)
144 RETURN (0);
145 t = ALLOCATE (&TypeRefType, sizeof (TypeRef));
146 t->base.tag = type_ref;
147 t->ref.ref = ref;
148 t->ref.pointer = pointer;
149 RETURN (t);
150 }
151
152 ArgType *
NewArgType(Type * type,Bool varargs,Atom name,SymbolPtr symbol,ArgType * next)153 NewArgType (Type *type, Bool varargs, Atom name, SymbolPtr symbol, ArgType *next)
154 {
155 ENTER ();
156 ArgType *a;
157
158 a = ALLOCATE (&ArgTypeType, sizeof (ArgType));
159 a->type = type;
160 a->varargs = varargs;
161 a->name = name;
162 a->symbol = symbol;
163 a->next = next;
164 RETURN (a);
165 }
166
167 Type *
NewTypeFunc(Type * ret,ArgType * args)168 NewTypeFunc (Type *ret, ArgType *args)
169 {
170 ENTER ();
171 Type *t;
172
173 t = ALLOCATE (&TypeFuncType, sizeof (TypeFunc));
174 t->base.tag = type_func;
175 t->func.ret = ret;
176 t->func.args = args;
177 RETURN (t);
178 }
179
180 Type *
NewTypeArray(Type * type,Expr * dimensions,Bool resizable)181 NewTypeArray (Type *type, Expr *dimensions, Bool resizable)
182 {
183 ENTER ();
184 Type *t;
185
186 t = ALLOCATE (&TypeArrayType, sizeof (TypeArray));
187 t->base.tag = type_array;
188 t->array.type = type;
189 t->array.dimensions = dimensions;
190 t->array.storage = DimStorageNone;
191 t->array.resizable = resizable;
192 RETURN (t);
193 }
194
195 Type *
NewTypeHash(Type * type,Type * keyType)196 NewTypeHash (Type *type, Type *keyType)
197 {
198 ENTER ();
199 Type *t;
200
201 t = ALLOCATE (&TypeHashType, sizeof (TypeHash));
202 t->base.tag = type_hash;
203 t->hash.type = type;
204 t->hash.keyType = keyType;
205 RETURN (t);
206 }
207
208 Type *
NewTypeStruct(StructType * structs)209 NewTypeStruct (StructType *structs)
210 {
211 ENTER ();
212 Type *t;
213
214 t = ALLOCATE (&TypeStructType, sizeof (TypeStruct));
215 t->base.tag = type_struct;
216 t->structs.structs = structs;
217 t->structs.enumeration = False;
218 t->structs.left = NULL;
219 t->structs.right = NULL;
220 RETURN (t);
221 }
222
223 Type *
NewTypeUnion(StructType * structs,Bool enumeration)224 NewTypeUnion (StructType *structs, Bool enumeration)
225 {
226 ENTER ();
227 Type *t;
228
229 t = ALLOCATE (&TypeStructType, sizeof (TypeStruct));
230 t->base.tag = type_union;
231 t->structs.structs = structs;
232 t->structs.enumeration = enumeration;
233 t->structs.left = NULL;
234 t->structs.right = NULL;
235 RETURN (t);
236 }
237
238 static Type *
TypePlusPart(Type * type)239 TypePlusPart (Type *type)
240 {
241 type = TypeCanon (type);
242 switch (type->base.tag) {
243 case type_struct:
244 case type_union:
245 break;
246 default:
247 ParseError ("Type '%T' not struct or union", type);
248 return NULL;
249 }
250 return type;
251 }
252
253 static int
AddPlusType(StructType * new,StructType * old,int pos)254 AddPlusType (StructType *new, StructType *old, int pos)
255 {
256 int i;
257
258 for (i = 0; i < old->nelements; i++) {
259 AddBoxType (&new->types, BoxTypesElements (old->types)[i]);
260 StructTypeAtoms (new)[pos] = StructTypeAtoms (old)[i];
261 pos++;
262 }
263 return pos;
264 }
265
266 Type *
NewTypePlus(Type * left,Type * right)267 NewTypePlus (Type *left, Type *right)
268 {
269 ENTER ();
270 Type *t, *l, *r;;
271 StructType *st;
272 int i;
273
274 l = TypePlusPart (left);
275 r = TypePlusPart (right);
276 if (!l || !r)
277 RETURN (NULL);
278 if (l->base.tag != r->base.tag) {
279 ParseError ("'%T' and '%T' are not the same type", left, right);
280 RETURN (NULL);
281 }
282
283 st = NewStructType (l->structs.structs->nelements + r->structs.structs->nelements);
284 i = AddPlusType (st, l->structs.structs, 0);
285 if (i < 0)
286 RETURN (NULL);
287 i = AddPlusType (st, r->structs.structs, i);
288 if (i < 0)
289 RETURN (NULL);
290
291 t = ALLOCATE (&TypeStructType, sizeof (TypeStruct));
292 t->base.tag = l->base.tag;
293 t->structs.structs = st;
294 t->structs.enumeration = l->structs.enumeration && r->structs.enumeration;
295 t->structs.left = left;
296 t->structs.right = right;
297 RETURN (t);
298 }
299
300
301 Type *
NewTypeTypes(TypeElt * elt)302 NewTypeTypes (TypeElt *elt)
303 {
304 ENTER ();
305 Type *t;
306
307 t = ALLOCATE (&TypeTypesType, sizeof (TypeTypes));
308 t->base.tag = type_types;
309 t->types.elt = elt;
310 RETURN (t);
311 }
312
313 SymbolPtr
TypeNameName(Type * t)314 TypeNameName (Type *t)
315 {
316 ExprPtr e;
317 if (t->base.tag == type_name)
318 {
319 e = t->name.expr;
320 if (e->base.tag == COLONCOLON)
321 e = e->tree.right;
322 return e->atom.symbol;
323 }
324 return 0;
325 }
326
327 Bool
TypeNumeric(Type * t)328 TypeNumeric (Type *t)
329 {
330 if (t->base.tag != type_prim)
331 return False;
332 if (Numericp (t->prim.prim))
333 return True;
334 return False;
335 }
336
337 Bool
TypeIntegral(Type * t)338 TypeIntegral (Type *t)
339 {
340 if (t->base.tag != type_prim)
341 return False;
342 if (Integralp (t->prim.prim))
343 return True;
344 return False;
345 }
346
347 int
TypeCountDimensions(ExprPtr dims)348 TypeCountDimensions (ExprPtr dims)
349 {
350 int ndim = 0;
351 while (dims)
352 {
353 ndim++;
354 dims = dims->tree.right;
355 }
356 return ndim;
357 }
358
359 StackObject *TypeCheckStack;
360 int TypeCheckLevel;
361
362 /*
363 * Return True if sup is a super type of sub
364 */
365
366 Bool
TypeIsSupertype(Type * super,Type * sub)367 TypeIsSupertype (Type *super, Type *sub)
368 {
369 int n;
370 Bool ret;
371 StructType *super_st;
372 StructType *sub_st;
373 int super_dim;
374 int sub_dim;
375
376 if (super == sub)
377 return True;
378 if (!super || !sub)
379 return False;
380
381 /* resolve typedefs */
382 if (super->base.tag == type_name)
383 return TypeIsSupertype (TypeNameType (super), sub);
384 if (sub->base.tag == type_name)
385 return TypeIsSupertype (super, TypeNameType (sub));
386
387 /* check bogus internal union types */
388 if (super->base.tag == type_types)
389 {
390 TypeElt *elt;
391
392 for (elt = super->types.elt; elt; elt = elt->next)
393 if (TypeIsSupertype (elt->type, sub))
394 return True;
395 return False;
396 }
397
398 if (sub->base.tag == type_types)
399 {
400 TypeElt *elt;
401
402 for (elt = sub->types.elt; elt; elt = elt->next)
403 if (TypeIsSupertype (super, elt->type))
404 return True;
405 return False;
406 }
407
408 /* poly is a supertype of all types */
409 if (TypePoly (super))
410 return True;
411
412 if (super->base.tag != sub->base.tag)
413 return False;
414
415 switch (super->base.tag) {
416 case type_prim:
417 if (super->prim.prim == sub->prim.prim)
418 return True;
419 if (Numericp (super->prim.prim) && Numericp (sub->prim.prim))
420 return super->prim.prim >= sub->prim.prim;
421 return False;
422 case type_ref:
423 /*
424 * Avoid the infinite recursion, but don't unify type yet
425 */
426 for (n = 0; n < TypeCheckLevel; n++)
427 if (STACK_ELT(TypeCheckStack, n) == super)
428 return True;
429 STACK_PUSH (TypeCheckStack, super);
430 ++TypeCheckLevel;
431 /* XXX is this right? */
432 ret = TypeIsSupertype (super->ref.ref, sub->ref.ref);
433 STACK_POP (TypeCheckStack);
434 --TypeCheckLevel;
435 return ret;
436 case type_func:
437 if (TypeIsSupertype (super->func.ret, sub->func.ret))
438 {
439 ArgType *super_arg = super->func.args;
440 ArgType *sub_arg = sub->func.args;
441
442 while (super_arg || sub_arg)
443 {
444 if (!super_arg || !sub_arg)
445 return False;
446 if (super_arg->varargs != sub_arg->varargs)
447 return False;
448 if (!TypeIsSupertype (sub_arg->type, super_arg->type))
449 return False;
450 super_arg = super_arg->next;
451 sub_arg = sub_arg->next;
452 }
453 return True;
454 }
455 return False;
456 case type_array:
457 super_dim = TypeCountDimensions (super->array.dimensions);
458 sub_dim = TypeCountDimensions (sub->array.dimensions);
459 if (super_dim == 0 || sub_dim == 0 || super_dim == sub_dim)
460 return TypeIsSupertype (super->array.type, sub->array.type);
461 return False;
462 case type_hash:
463 return (TypeIsSupertype (super->hash.type, sub->hash.type) &&
464 TypeIsOrdered (super->hash.keyType, sub->hash.keyType));
465 case type_struct:
466 case type_union:
467 super_st = super->structs.structs;
468 sub_st = sub->structs.structs;
469 for (n = 0; n < super_st->nelements; n++)
470 {
471 Type *sub_mem;
472
473 /*
474 * Structs (or unions) are subtypes if they contain all
475 * of the super type members and those members are subtypes
476 */
477 sub_mem = StructMemType (sub_st, StructTypeAtoms(super_st)[n]);
478 if (!sub_mem)
479 return False;
480 if (!TypeIsSupertype (BoxTypesElements(super_st->types)[n],
481 sub_mem))
482 return False;
483 }
484 return True;
485 case type_name:
486 case type_types:
487 abort ();
488 }
489 return False;
490 }
491
492 /*
493 * Return True if a is a super or subtype of b
494 */
495
496 Bool
TypeIsOrdered(Type * a,Type * b)497 TypeIsOrdered (Type *a, Type *b)
498 {
499 return TypeIsSupertype (a, b) || TypeIsSupertype (b, a);
500 }
501
502 #if 0
503
504 /*
505 * The above relationship isn't quite right --
506 *
507 * real(real) x = int func(int a) { return a + 1; };
508 *
509 * fails as int(int) is neither supertype nor subtype of real(real)
510 *
511 * We're trying to figure out what the right answer is, and for everything
512 * aside from structures, it looks pretty easy. Structs are "hard"...
513 */
514
515 /*
516 * Return True if a is a "co-type" of b
517 */
518
519 Bool
520 TypeIsCotype (Type *a, Type *b)
521 {
522 int n;
523 Bool ret;
524 StructType *a_st;
525 StructType *b_st;
526 int a_dim;
527 int b_dim;
528
529 if (a == b)
530 return True;
531 if (!a || !b)
532 return False;
533
534 /* resolve typedefs */
535 if (a->base.tag == type_name)
536 return TypeIsCotype (TypeNameType (a), b);
537 if (b->base.tag == type_name)
538 return TypeIsCotype (a, TypeNameType (b));
539
540 /* check bogus internal union types */
541 if (a->base.tag == type_types)
542 {
543 TypeElt *elt;
544
545 for (elt = a->types.elt; elt; elt = elt->next)
546 if (TypeIsCotype (elt->type, b))
547 return True;
548 return False;
549 }
550
551 if (b->base.tag == type_types)
552 {
553 TypeElt *elt;
554
555 for (elt = b->types.elt; elt; elt = elt->next)
556 if (TypeIsCotype (a, elt->type))
557 return True;
558 return False;
559 }
560
561 /* poly is a supertype of all types */
562 if (TypePoly (a) || TypePoly (b))
563 return True;
564
565 if (a->base.tag != b->base.tag)
566 return False;
567
568 switch (a->base.tag) {
569 case type_prim:
570 if (a->prim.prim == b->prim.prim)
571 return True;
572 if (Numericp (a->prim.prim) && Numericp (b->prim.prim))
573 return True;
574 return False;
575 case type_ref:
576 /*
577 * Avoid the infinite recursion, but don't unify type yet
578 */
579 for (n = 0; n < TypeCheckLevel; n++)
580 if (STACK_ELT(TypeCheckStack, n) == a)
581 return True;
582 STACK_PUSH (TypeCheckStack, a);
583 ++TypeCheckLevel;
584 /* XXX is this right? */
585 ret = TypeIsCotype (a->ref.ref, b->ref.ref);
586 STACK_POP (TypeCheckStack);
587 --TypeCheckLevel;
588 return ret;
589 case type_func:
590 if (TypeIsCotype (a->func.ret, b->func.ret))
591 {
592 ArgType *a_arg = a->func.args;
593 ArgType *b_arg = b->func.args;
594
595 while (a_arg || b_arg)
596 {
597 if (!a_arg || !b_arg)
598 return False;
599 if (a_arg->varargs != b_arg->varargs)
600 return False;
601 if (!TypeIsCotype (b_arg->type, a_arg->type))
602 return False;
603 a_arg = a_arg->next;
604 b_arg = b_arg->next;
605 }
606 return True;
607 }
608 return False;
609 case type_array:
610 a_dim = TypeCountDimensions (a->array.dimensions);
611 b_dim = TypeCountDimensions (b->array.dimensions);
612 if (a_dim == 0 || b_dim == 0 || a_dim == b_dim)
613 return TypeIsCotype (a->array.type, b->array.type);
614 return False;
615 case type_hash:
616 return (TypeIsCotype (a->hash.type, b->hash.type) &&
617 TypeIsCotype (a->hash.keyType, b->hash.keyType));
618 case type_struct:
619 case type_union:
620 a_st = a->structs.structs;
621 b_st = b->structs.structs;
622 for (n = 0; n < a_st->nelements; n++)
623 {
624 Type *b_mem;
625
626 /*
627 * Structs (or unions) are subtypes if they contain all
628 * of the a type members and those members are subtypes
629 */
630 b_mem = StructMemType (b_st, StructTypeAtoms(a_st)[n]);
631 if (!b_mem)
632 return False;
633 if (!TypeIsCotype (BoxTypesElements(a_st->types)[n],
634 b_mem))
635 return False;
636 }
637 return True;
638 case type_name:
639 case type_types:
640 abort ();
641 }
642 return False;
643 }
644 #endif
645
646 /*
647 * return the combined type for an operation
648 * on a numeric type which is a group
649 */
650 static Type *
TypeBinaryGroup(Type * left,Type * right)651 TypeBinaryGroup (Type *left, Type *right)
652 {
653 if (TypePoly (left))
654 {
655 if (TypePoly (right) || TypeNumeric (right))
656 return typePrim[rep_float];
657 }
658 else if (TypePoly (right))
659 {
660 if (TypeNumeric (left))
661 return typePrim[rep_float];
662 }
663 else if (TypeNumeric (left) && TypeNumeric (right))
664 {
665 if (left->prim.prim < right->prim.prim)
666 left = right;
667 return left;
668 }
669 return 0;
670 }
671
672 /*
673 * Return the least-upper bound for an integral computation
674 */
675 static Type *
TypeBinaryIntegral(Type * left,Type * right)676 TypeBinaryIntegral (Type *left, Type *right)
677 {
678 if (TypePoly (left))
679 left = typePrim[rep_integer];
680 if (TypePoly (right))
681 right = typePrim[rep_integer];
682 if (TypeIntegral (left) && TypeIntegral (right))
683 {
684 if (left->prim.prim < right->prim.prim)
685 left = right;
686 return left;
687 }
688 else if (TypeNumeric (left) && TypeNumeric (right))
689 {
690 return typePrim[rep_integer];
691 }
692 return 0;
693 }
694
695 /*
696 * return the combined type for an operation
697 * on a set closed under addition and multiplication
698 */
699 static Type *
TypeBinaryField(Type * left,Type * right)700 TypeBinaryField (Type *left, Type *right)
701 {
702 if (TypePoly (left))
703 {
704 if (TypePoly (right) || TypeNumeric (right))
705 return typePrim[rep_float];
706 }
707 else if (TypePoly (right))
708 {
709 if (TypeNumeric (left))
710 return typePrim[rep_float];
711 }
712 else if (TypeNumeric (left) && TypeNumeric (right))
713 {
714 if (left->prim.prim < right->prim.prim)
715 left = right;
716 if (left->prim.prim < rep_rational)
717 left = typePrim[rep_rational];
718 return left;
719 }
720 return 0;
721 }
722
723 /*
724 * Return the type resuting from an div operator,
725 * integral for numeric type
726 */
727 static Type *
TypeBinaryDiv(Type * left,Type * right)728 TypeBinaryDiv (Type *left, Type *right)
729 {
730 if (TypePoly (left))
731 left = typePrim[rep_float];
732 if (TypePoly (right))
733 right = typePrim[rep_float];
734 if (TypeNumeric (left) && TypeNumeric (right))
735 {
736 return typePrim[rep_integer];
737 }
738 return 0;
739 }
740
741 /*
742 * Return the type resuting from an exponentiation operator,
743 * 'left' for integral 'right', float otherwise
744 */
745 static Type *
TypeBinaryPow(Type * left,Type * right)746 TypeBinaryPow (Type *left, Type *right)
747 {
748 if (TypePoly (left))
749 left = typePrim[rep_float];
750 if (TypePoly (right))
751 right = typePrim[rep_float];
752 if (TypeNumeric (left) && TypeNumeric (right))
753 {
754 if (TypeIntegral (right))
755 return left;
756 return typePrim[rep_float];
757 }
758 return 0;
759 }
760
761 /*
762 * Return string if both left and right are strings
763 */
764 static Type *
TypeBinaryString(Type * left,Type * right)765 TypeBinaryString (Type *left, Type *right)
766 {
767 if (TypePoly (left))
768 left = typePrim[rep_string];
769 if (TypePoly (right))
770 right = typePrim[rep_string];
771 if (TypeString (left) && TypeString (right))
772 return left;
773 return 0;
774 }
775
776 /*
777 * Return reference type resulting from addition/subtraction
778 */
779 static Type *
TypeBinaryRefOff(Type * ref,Type * off)780 TypeBinaryRefOff (Type *ref, Type *off)
781 {
782 if (TypePoly (ref))
783 ref = typeRefPoly;
784 if (TypePoly (off))
785 off = typePrim[rep_integer];
786 if (ref->base.tag == type_ref && TypeIntegral (off))
787 return ref;
788 return 0;
789 }
790
791 /*
792 * Return reference type resulting from subtraction
793 */
794 static Type *
TypeBinaryRefMinus(Type * aref,Type * bref)795 TypeBinaryRefMinus (Type *aref, Type *bref)
796 {
797 if (TypePoly (aref))
798 aref = typeRefPoly;
799 if (TypePoly (bref))
800 bref = typeRefPoly;
801 if (aref->base.tag == type_ref && bref->base.tag == type_ref)
802 if (TypeIsOrdered (aref->ref.ref, bref->ref.ref))
803 return typePrim[rep_integer];
804 return 0;
805 }
806
807 /*
808 * Return type referenced by ref
809 */
810 static Type *
TypeUnaryRef(Type * ref)811 TypeUnaryRef (Type *ref)
812 {
813 if (TypePoly (ref))
814 return typePoly;
815 if (ref->base.tag == type_ref)
816 return ref->ref.ref;
817 return 0;
818 }
819
820 static Type *
TypeUnaryGroup(Type * type)821 TypeUnaryGroup (Type *type)
822 {
823 if (TypePoly (type))
824 return typePrim[rep_float];
825 else if (TypeNumeric (type))
826 return type;
827 return 0;
828 }
829
830 static Type *
TypeUnaryIntegral(Type * type)831 TypeUnaryIntegral (Type *type)
832 {
833 if (TypePoly (type))
834 return typePrim[rep_integer];
835 if (TypeIntegral (type))
836 return type;
837 return 0;
838 }
839
840 /*
841 * Indexing a string returns this type
842 */
843 static Type *
TypeUnaryString(Type * type)844 TypeUnaryString (Type *type)
845 {
846 if (TypePoly (type))
847 return typePrim[rep_string];
848 if (TypeString (type))
849 return typePrim[rep_integer];
850 return 0;
851 }
852
853 /*
854 * Type of an array or hash reference
855 */
856 static Type *
TypeUnaryArray(Type * type)857 TypeUnaryArray (Type *type)
858 {
859 if (TypePoly (type))
860 return typePoly;
861 if (type->base.tag == type_array)
862 return type->array.type;
863 if (type->base.tag == type_hash)
864 return type->hash.type;
865 return 0;
866 }
867
868 /*
869 * Comparison a logical operator type
870 */
871 static Type *
TypeUnaryBool(Type * type)872 TypeUnaryBool (Type *type)
873 {
874 if (TypePoly (type))
875 return typePrim[rep_bool];
876 if (TypeBool (type))
877 return type;
878 return 0;
879 }
880
881 /*
882 * Return the least-upper bound for a boolean computation
883 */
884 static Type *
TypeBinaryBool(Type * left,Type * right)885 TypeBinaryBool (Type *left, Type *right)
886 {
887 if (TypePoly (left))
888 left = typePrim[rep_bool];
889 if (TypePoly (right))
890 right = typePrim[rep_bool];
891 if (TypeBool (left) && TypeBool (right))
892 return left;
893 return 0;
894 }
895
896 static void
TypeEltMark(void * object)897 TypeEltMark (void *object)
898 {
899 TypeElt *elt = object;
900 MemReference (elt->next);
901 MemReference (elt->type);
902 }
903
904 DataType TypeEltType = { TypeEltMark, 0, "TypeEltType" };
905
906 static TypeElt *
NewTypeElt(Type * type,TypeElt * next)907 NewTypeElt (Type *type, TypeElt *next)
908 {
909 ENTER ();
910 TypeElt *elt;
911
912 elt = ALLOCATE (&TypeEltType, sizeof (TypeElt));
913 elt->type = type;
914 elt->next = next;
915 RETURN (elt);
916 }
917
918 static Type *
TypeAdd(Type * old,Type * new)919 TypeAdd (Type *old, Type *new)
920 {
921 TypeElt **last;
922
923 if (new->base.tag == type_types)
924 {
925 TypeElt *elt;
926
927 for (elt = new->types.elt; elt; elt = elt->next)
928 old = TypeAdd (old, elt->type);
929 }
930 else
931 {
932 if (!old)
933 old = new;
934 else if (old != new)
935 {
936 if (old->base.tag != type_types)
937 old = NewTypeTypes (NewTypeElt (old, 0));
938 for (last = &old->types.elt; *last; last = &(*last)->next)
939 if ((*last)->type == new)
940 break;
941 if (!*last)
942 *last = NewTypeElt (new, 0);
943 }
944 }
945 return old;
946 }
947
948 static Type *
TypeCombineFlatten(Type * type)949 TypeCombineFlatten (Type *type)
950 {
951 ENTER ();
952
953 if (type && type->base.tag == type_types)
954 {
955 TypeElt *n, **p, *m;
956
957 /*
958 * Remove obvious duplicates
959 */
960 for (n = type->types.elt; n; n = n->next)
961 {
962 p = &n->next;
963 while ((m = *p))
964 {
965 if (m->type == n->type)
966 *p = m->next;
967 else
968 p = &m->next;
969 }
970 }
971 /*
972 * Check for a single type and return just that
973 */
974 if (!type->types.elt->next)
975 type = type->types.elt->type;
976 }
977 RETURN(type);
978 }
979
980 Type *
TypeCombineBinary(Type * left,int tag,Type * right)981 TypeCombineBinary (Type *left, int tag, Type *right)
982 {
983 ENTER ();
984 Type *type;
985 Type *ret = 0;
986
987 if (!left || !right)
988 RETURN(0);
989
990 if (left->base.tag == type_name)
991 RETURN (TypeCombineBinary (TypeNameType(left), tag, right));
992 if (right->base.tag == type_name)
993 RETURN (TypeCombineBinary (left, tag, TypeNameType(right)));
994
995 if (left->base.tag == type_types)
996 {
997 TypeElt *elt;
998 for (elt = left->types.elt; elt; elt = elt->next)
999 if ((type = TypeCombineBinary (elt->type, tag, right)))
1000 ret = TypeAdd (ret, type);
1001 }
1002 else if (right->base.tag == type_types)
1003 {
1004 TypeElt *elt;
1005 for (elt = right->types.elt; elt; elt = elt->next)
1006 if ((type = TypeCombineBinary (left, tag, elt->type)))
1007 ret = TypeAdd (ret, type);
1008 }
1009 else switch (tag) {
1010 case ASSIGN:
1011 if (TypeIsOrdered (left, right))
1012 {
1013 if (TypePoly (left))
1014 ret = TypeAdd (ret, right);
1015 else
1016 ret = TypeAdd (ret, left);
1017 }
1018 break;
1019 case PLUS:
1020 case ASSIGNPLUS:
1021 if ((type = TypeBinaryString (left, right)))
1022 ret = TypeAdd (ret, type);
1023 /* fall through ... */
1024 case MINUS:
1025 case ASSIGNMINUS:
1026 if ((type = TypeBinaryRefOff (left, right)))
1027 ret = TypeAdd (ret, type);
1028 if (tag == MINUS && (type = TypeBinaryRefMinus (left, right)))
1029 ret = TypeAdd (ret, type);
1030 if ((tag == MINUS || tag == PLUS) &&
1031 (type = TypeBinaryRefOff (right, left)))
1032 ret = TypeAdd (ret, type);
1033 /* fall through ... */
1034 case TIMES:
1035 case MOD:
1036 case ASSIGNTIMES:
1037 case ASSIGNMOD:
1038 if ((type = TypeBinaryGroup (left, right)))
1039 ret = TypeAdd (ret, type);
1040 break;
1041 case DIV:
1042 case ASSIGNDIV:
1043 if ((type = TypeBinaryDiv (left, right)))
1044 ret = TypeAdd (ret, type);
1045 break;
1046 case POW:
1047 case ASSIGNPOW:
1048 if ((type = TypeBinaryPow (left, right)))
1049 ret = TypeAdd (ret, type);
1050 break;
1051 case DIVIDE:
1052 case ASSIGNDIVIDE:
1053 if ((type = TypeBinaryField (left, right)))
1054 ret = TypeAdd (ret, type);
1055 break;
1056 case SHIFTL:
1057 case SHIFTR:
1058 case LXOR:
1059 case LAND:
1060 case LOR:
1061 case ASSIGNSHIFTL:
1062 case ASSIGNSHIFTR:
1063 case ASSIGNLXOR:
1064 case ASSIGNLAND:
1065 case ASSIGNLOR:
1066 if ((type = TypeBinaryIntegral (left, right)))
1067 ret = TypeAdd (ret, type);
1068 break;
1069 case ASSIGNAND:
1070 case ASSIGNOR:
1071 if ((type = TypeBinaryBool (left, right)))
1072 ret = TypeAdd (ret, type);
1073 break;
1074 case COLON:
1075 if (TypePoly (left) || TypePoly (right))
1076 ret = TypeAdd (ret, typePoly);
1077 else if (TypeIsSupertype (left, right))
1078 ret = TypeAdd (ret, left);
1079 else if (TypeIsSupertype (right, left))
1080 ret = TypeAdd (ret, right);
1081 break;
1082 case AND:
1083 case OR:
1084 if (TypeUnaryBool (left) && TypeUnaryBool (right))
1085 ret = TypeAdd (ret, typePrim[rep_bool]);
1086 break;
1087 case EQ:
1088 case NE:
1089 case LT:
1090 case GT:
1091 case LE:
1092 case GE:
1093 if (TypeIsOrdered (left, right))
1094 ret = TypeAdd (ret, typePrim[rep_bool]);
1095 break;
1096 }
1097 RETURN (TypeCombineFlatten (ret));
1098 }
1099
1100 Type *
TypeCombineUnary(Type * type,int tag)1101 TypeCombineUnary (Type *type, int tag)
1102 {
1103 ENTER ();
1104 Type *ret = 0;
1105 Type *t;
1106
1107 /* Avoid error cascade */
1108 if (!type)
1109 RETURN(typePoly);
1110
1111 if (type->base.tag == type_name)
1112 RETURN(TypeCombineUnary (TypeNameType(type), tag));
1113
1114 if (type->base.tag == type_types)
1115 {
1116 TypeElt *elt;
1117 for (elt = type->types.elt; elt; elt = elt->next)
1118 if ((t = TypeCombineUnary (elt->type, tag)))
1119 ret = TypeAdd (ret, t);
1120 }
1121 else switch (tag) {
1122 case STAR:
1123 if ((t = TypeUnaryRef (type)))
1124 ret = TypeAdd (ret, t);
1125 break;
1126 case LNOT:
1127 if ((t = TypeUnaryIntegral (type)))
1128 ret = TypeAdd (ret, t);
1129 break;
1130 case UMINUS:
1131 if ((t = TypeUnaryGroup (type)))
1132 ret = TypeAdd (ret, t);
1133 break;
1134 case BANG:
1135 if ((t = TypeUnaryBool (type)))
1136 ret = TypeAdd (ret, t);
1137 break;
1138 case FACT:
1139 if ((t = TypeUnaryIntegral (type)))
1140 ret = TypeAdd (ret, t);
1141 break;
1142 case OS:
1143 if ((t = TypeUnaryString (type)))
1144 ret = TypeAdd (ret, t);
1145 if ((t = TypeUnaryArray (type)))
1146 ret = TypeAdd (ret, t);
1147 break;
1148 }
1149 RETURN (TypeCombineFlatten (ret));
1150 }
1151
1152 Type *
TypeCombineArray(Type * type,int ndim,Bool lvalue)1153 TypeCombineArray (Type *type, int ndim, Bool lvalue)
1154 {
1155 ENTER ();
1156 Type *ret = 0;
1157 Type *t;
1158
1159 /* Avoid error cascade */
1160 if (!type)
1161 RETURN(typePoly);
1162
1163 if (type->base.tag == type_name)
1164 RETURN(TypeCombineArray (TypeNameType(type), ndim, lvalue));
1165
1166 if (type->base.tag == type_types)
1167 {
1168 TypeElt *elt;
1169 for (elt = type->types.elt; elt; elt = elt->next)
1170 if ((t = TypeCombineArray (elt->type, ndim, lvalue)))
1171 ret = TypeAdd (ret, t);
1172 }
1173 else
1174 {
1175 if ((t = TypeUnaryString (type)))
1176 ret = TypeAdd (ret, t);
1177
1178 if (TypePoly (type))
1179 ret = TypeAdd (ret, typePoly);
1180
1181 if (type->base.tag == type_array)
1182 {
1183 int n = TypeCountDimensions (type->array.dimensions);
1184 if (n == 0 || n == ndim)
1185 ret = TypeAdd (ret, type->array.type);
1186 }
1187 else if (type->base.tag == type_hash)
1188 {
1189 if (ndim == 1)
1190 ret = TypeAdd (ret, type->hash.type);
1191 }
1192 }
1193 RETURN (TypeCombineFlatten (ret));
1194 }
1195
1196 Type *
TypeCombineStruct(Type * type,int tag,Atom atom)1197 TypeCombineStruct (Type *type, int tag, Atom atom)
1198 {
1199 if (!type)
1200 return 0;
1201
1202 if (TypePoly (type))
1203 return typePoly;
1204
1205 if (type->base.tag == type_name)
1206 return TypeCombineStruct (TypeNameType(type), tag, atom);
1207
1208 switch (tag) {
1209 case DOT:
1210 if (type->base.tag == type_struct || type->base.tag == type_union)
1211 return StructMemType (type->structs.structs, atom);
1212 break;
1213 case ARROW:
1214 if (type->base.tag == type_ref)
1215 return TypeCombineStruct (type->ref.ref, DOT, atom);
1216 break;
1217 }
1218 return 0;
1219 }
1220
1221 Type *
TypeCombineReturn(Type * type)1222 TypeCombineReturn (Type *type)
1223 {
1224 if (TypePoly (type))
1225 return typePoly;
1226
1227 if (type->base.tag == type_name)
1228 return TypeCombineReturn (TypeNameType(type));
1229
1230 if (type->base.tag == type_func)
1231 return type->func.ret;
1232
1233 return 0;
1234 }
1235
1236 Type *
TypeCombineFunction(Type * type)1237 TypeCombineFunction (Type *type)
1238 {
1239 if (TypePoly (type))
1240 return typePoly;
1241
1242 if (type->base.tag == type_name)
1243 return TypeCombineFunction (TypeNameType(type));
1244
1245 if (type->base.tag == type_func)
1246 return type;
1247
1248 return 0;
1249 }
1250
1251 /*
1252 * Check an assignment for type compatibility; Lvalues can assert
1253 * maximal domain for their values
1254 */
1255
1256 Bool
TypeCompatibleAssign(TypePtr a,Value b)1257 TypeCompatibleAssign (TypePtr a, Value b)
1258 {
1259 int adim, bdim;
1260 int n;
1261
1262 if (!a || !b)
1263 return True;
1264
1265 if (a->base.tag == type_types)
1266 {
1267 TypeElt *elt;
1268 for (elt = a->types.elt; elt; elt = elt->next)
1269 if (TypeCompatibleAssign (elt->type, b))
1270 return True;
1271 return False;
1272 }
1273
1274 if (TypePoly (a))
1275 return True;
1276
1277 switch (a->base.tag) {
1278 case type_prim:
1279 if (a->prim.prim == ValueTag(b))
1280 return True;
1281 if (Numericp (a->prim.prim) && Numericp (ValueTag(b)))
1282 {
1283 if (a->prim.prim >= ValueTag(b))
1284 return True;
1285 }
1286 break;
1287 case type_name:
1288 return TypeCompatibleAssign (TypeNameType(a), b);
1289 case type_ref:
1290 if (ValueIsRef(b))
1291 {
1292 if (RefValueGet (b))
1293 return TypeCompatibleAssign (a->ref.ref, RefValueGet (b));
1294 else
1295 return TypeIsOrdered (a->ref.ref, RefType (b));
1296 }
1297 break;
1298 case type_func:
1299 if (ValueIsFunc(b))
1300 {
1301 if (TypeIsOrdered (a->func.ret, b->func.code->base.type))
1302 {
1303 ArgType *aarg = a->func.args, *barg = b->func.code->base.args;
1304
1305 while (aarg || barg)
1306 {
1307 if (!barg || !aarg)
1308 return False;
1309 if (barg->varargs != aarg->varargs)
1310 return False;
1311 if (!TypeIsOrdered (barg->type, aarg->type))
1312 return False;
1313 aarg = aarg->next;
1314 barg = barg->next;
1315 }
1316 return True;
1317 }
1318 }
1319 break;
1320 case type_array:
1321 if (ValueIsArray(b))
1322 {
1323 adim = TypeCountDimensions (a->array.dimensions);
1324 bdim = b->array.ndim;
1325 if (adim == 0 || adim == bdim)
1326 {
1327 if (TypePoly (a->array.type))
1328 return True;
1329 if (TypePoly (ArrayType(&b->array)))
1330 {
1331 int i;
1332
1333 for (i = 0; i < ArrayNvalues(&b->array); i++)
1334 {
1335 Value v = ArrayValueGet (&b->array, i);
1336 if (v &&
1337 !TypeCompatibleAssign (a->array.type, v))
1338 {
1339 return False;
1340 }
1341 }
1342 return True;
1343 }
1344 else
1345 return TypeIsOrdered (a->array.type, ArrayType(&b->array));
1346 }
1347 }
1348 break;
1349 case type_hash:
1350 if (ValueIsHash (b))
1351 {
1352 if (TypePoly (a->hash.type))
1353 return True;
1354 if (TypePoly (b->hash.type))
1355 {
1356 HashValue h;
1357 Value *e = BoxElements (b->hash.elts);
1358
1359 for (h = 0; h < b->hash.hashSet->size; h++)
1360 {
1361 if (!TypeCompatibleAssign (a->hash.type,
1362 HashEltValue(e)))
1363 {
1364 return False;
1365 }
1366 if (!TypeCompatibleAssign (a->hash.keyType,
1367 HashEltKey (e)))
1368 {
1369 return False;
1370 }
1371 HashEltStep (e);
1372 }
1373 return True;
1374 }
1375 else
1376 return (TypeIsOrdered (a->hash.type, b->hash.type) &&
1377 TypeIsOrdered (a->hash.keyType, b->hash.keyType));
1378 }
1379 case type_struct:
1380 case type_union:
1381 if ((ValueIsStruct(b) && a->base.tag == type_struct) ||
1382 (ValueIsUnion(b) && a->base.tag == type_union))
1383 {
1384 StructType *st = a->structs.structs;
1385 for (n = 0; n < st->nelements; n++)
1386 {
1387 Type *bt;
1388
1389 bt = StructMemType (b->structs.type, StructTypeAtoms(st)[n]);
1390 if (!bt)
1391 break;
1392 if (!TypeIsOrdered (BoxTypesElements(st->types)[n], bt))
1393 break;
1394 }
1395 if (n == st->nelements)
1396 return True;
1397 }
1398 break;
1399 default:
1400 break;
1401 }
1402 return False;
1403 }
1404
1405 /*
1406 * Check to see if 'b' is a subtype of 'a'
1407 */
1408
1409 Bool
ValueIsType(Value b,TypePtr a)1410 ValueIsType (Value b, TypePtr a)
1411 {
1412 int adim, bdim;
1413 int n;
1414
1415 if (!a || !b)
1416 return True;
1417
1418 if (a->base.tag == type_types)
1419 {
1420 TypeElt *elt;
1421 for (elt = a->types.elt; elt; elt = elt->next)
1422 if (ValueIsType (b, elt->type))
1423 return True;
1424 return False;
1425 }
1426
1427 if (TypePoly (a))
1428 return True;
1429
1430 switch (a->base.tag) {
1431 case type_prim:
1432 if (a->prim.prim == ValueTag(b))
1433 return True;
1434 if (Numericp (a->prim.prim) && Numericp (ValueTag(b)))
1435 {
1436 if (a->prim.prim >= ValueTag(b))
1437 return True;
1438 }
1439 break;
1440 case type_name:
1441 return ValueIsType (b, TypeNameType(a));
1442 case type_ref:
1443 if (ValueIsRef(b))
1444 {
1445 if (RefValueGet (b))
1446 return ValueIsType (RefValueGet (b), a->ref.ref);
1447 else
1448 return TypeIsSupertype (RefType(b), a->ref.ref);
1449 }
1450 break;
1451 case type_func:
1452 if (ValueIsFunc(b))
1453 {
1454 if (TypeIsSupertype (b->func.code->base.type, a->func.ret))
1455 {
1456 ArgType *aarg = a->func.args, *barg = b->func.code->base.args;
1457
1458 while (aarg || barg)
1459 {
1460 if (!barg || !aarg)
1461 return False;
1462 if (barg->varargs != aarg->varargs)
1463 return False;
1464 if (!TypeIsSupertype (aarg->type, barg->type))
1465 return False;
1466 aarg = aarg->next;
1467 barg = barg->next;
1468 }
1469 return True;
1470 }
1471 }
1472 break;
1473 case type_array:
1474 if (ValueIsArray(b))
1475 {
1476 adim = TypeCountDimensions (a->array.dimensions);
1477 bdim = b->array.ndim;
1478 if (adim == 0 || adim == bdim)
1479 {
1480 if (TypePoly (a->array.type))
1481 return True;
1482 if (TypePoly (ArrayType(&b->array)))
1483 {
1484 int i;
1485
1486 for (i = 0; i < ArrayNvalues(&b->array); i++)
1487 {
1488 Value v = ArrayValueGet (&b->array, i);
1489 if (v &&
1490 !ValueIsType (v, a->array.type))
1491 {
1492 return False;
1493 }
1494 }
1495 return True;
1496 }
1497 else
1498 return TypeIsSupertype (ArrayType(&b->array), a->array.type);
1499 }
1500 }
1501 break;
1502 case type_hash:
1503 if (ValueIsHash (b))
1504 {
1505 if (TypePoly (a->hash.type))
1506 return True;
1507 if (TypePoly (b->hash.type))
1508 {
1509 HashValue h;
1510 Value *e = BoxElements (b->hash.elts);
1511
1512 for (h = 0; h < b->hash.hashSet->size; h++)
1513 {
1514 if (!ValueIsType (HashEltValue(e), a->hash.type))
1515 {
1516 return False;
1517 }
1518 if (!ValueIsType (HashEltKey (e), a->hash.keyType))
1519 {
1520 return False;
1521 }
1522 HashEltStep (e);
1523 }
1524 return True;
1525 }
1526 else
1527 return (TypeIsSupertype (b->hash.type, a->hash.type) &&
1528 TypeIsSupertype (b->hash.keyType, a->hash.keyType));
1529 }
1530 case type_struct:
1531 case type_union:
1532 if ((ValueIsStruct(b) && a->base.tag == type_struct) ||
1533 (ValueIsUnion(b) && a->base.tag == type_union))
1534 {
1535 StructType *st = a->structs.structs;
1536 for (n = 0; n < st->nelements; n++)
1537 {
1538 Type *bt;
1539
1540 bt = StructMemType (b->structs.type, StructTypeAtoms(st)[n]);
1541 if (!bt)
1542 break;
1543 if (!TypeIsSupertype (bt, BoxTypesElements(st->types)[n]))
1544 break;
1545 }
1546 if (n == st->nelements)
1547 return True;
1548 }
1549 break;
1550 default:
1551 break;
1552 }
1553 return False;
1554 }
1555
1556 Type *
TypeCanon(Type * type)1557 TypeCanon (Type *type)
1558 {
1559 if (type && type->base.tag == type_name)
1560 return TypeCanon (TypeNameType(type));
1561 return type;
1562 }
1563
1564 int
TypeInit(void)1565 TypeInit (void)
1566 {
1567 ENTER ();
1568 Rep t;
1569
1570 for (t = rep_int; t <= rep_void; t++)
1571 {
1572 typePrim[t] = NewTypePrim (t);
1573 MemAddRoot (typePrim[t]);
1574 }
1575 typePoly = NewTypePrim(rep_undef);
1576 MemAddRoot (typePoly);
1577 typeRefPoly = NewTypeRef (typePoly, True);
1578 MemAddRoot (typeRefPoly);
1579
1580 typeArrayInt = NewTypeArray (typePrim[rep_integer], 0, False);
1581 MemAddRoot (typeArrayInt);
1582
1583 TypeCheckStack = StackCreate ();
1584 MemAddRoot (TypeCheckStack);
1585 TypeCheckLevel = 0;
1586 EXIT ();
1587 return 1;
1588 }
1589