![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to var.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / cyntax / cem|
Return to var.c CVS log | Up to [Research Unix] / researchv8dc / cmd / cyntax / cem |
1.1 root 1: #include "cem.h"
2: #define STD_OBJ 1
3: #include "stdobj.h"
4: #include "types.h"
5: #include "equiv.h"
6: #include "symbol.h"
7: #include "type.h"
8: #include "var.h"
9:
10: /*
11: * Variable routines.
12: */
13:
14: static long new_var_index = 1;
15:
16: /*
17: * We keep a cache of data objects rather than allowing malloc
18: * to inefficiently recycle them.
19: */
20: static arg *arg_free;
21: static args *args_free;
22: static var *var_free;
23:
24: /*
25: * Allocation routines.
26: */
27: static var *
28: new_var()
29: {
30: register var *p;
31:
32: if (var_free == NULL)
33: return talloc(var);
34:
35: p = var_free;
36: var_free = p->v_next;
37: return p;
38: }
39:
40: static void
41: free_arglist(a)
42: register arg *a;
43: {
44: register args *p;
45: register args *q;
46:
47: for (p = a->a_head; p != NULL; p = q)
48: {
49: q = p->a_next;
50: p->a_next = args_free;
51: args_free = p;
52: }
53:
54: a->a_next = arg_free;
55: arg_free = a;
56: }
57:
58: static arg *
59: new_arg()
60: {
61: register arg *p;
62:
63: if ((p = arg_free) == NULL)
64: p = talloc(arg);
65: else
66: arg_free = p->a_next;
67:
68: p->a_head = NULL;
69: p->a_tail = &p->a_head;
70: p->a_count = 0;
71: p->a_next = NULL;
72: return p;
73: }
74:
75: static void
76: free_arguments(a)
77: register arg *a;
78: {
79: register arg *b;
80:
81: while (a != NULL)
82: {
83: b = a->a_next;
84: free_arglist(a);
85: a = b;
86: }
87: }
88:
89: static void
90: add_argument(a, t)
91: register arg *a;
92: type *t;
93: {
94: register args *p;
95:
96: if ((p = args_free) == NULL)
97: p = talloc(args);
98: else
99: args_free = p->a_next;
100:
101: p->a_type = t;
102: p->a_next = NULL;
103: *a->a_tail = p;
104: a->a_tail = &p->a_next;
105: a->a_count++;
106: }
107:
108: /*
109: * Make a declaration.
110: */
111: static var *
112: declare(v, n, t, f, l)
113: obj_vars v;
114: symbol *n;
115: type *t;
116: symbol *f;
117: long l;
118: {
119: register var *p;
120:
121: p = new_var();
122: p->v_what = v;
123: p->v_name = n;
124: p->v_type = t;
125: p->v_file = f;
126: p->v_line = l;
127: p->v_ifile = NULL;
128: p->v_varargs = -1;
129: p->v_argdefn = NULL;
130: p->v_args = NULL;
131: p->v_tail = &p->v_args;
132: p->v_next = NULL;
133: return p;
134: }
135:
136: /*
137: * Set array size.
138: */
139: static void
140: array_size(p, t)
141: var *p;
142: type *t;
143: {
144: p->v_type = t;
145: }
146:
147: /*
148: * Note initialisation.
149: */
150: static void
151: initialisation(p, f, l)
152: var *p;
153: symbol *f;
154: long l;
155: {
156: p->v_ifile = f;
157: p->v_iline = l;
158: }
159:
160: /*
161: * Note varargs count.
162: */
163: static void
164: set_varargs(p, l)
165: var *p;
166: long l;
167: {
168: p->v_varargs = l;
169: }
170:
171: /*
172: * Add an instance of a variable to the symbol table instance list.
173: */
174: static void
175: add_instance(v)
176: register var *v;
177: {
178: register inst *p;
179: register defn *d;
180: register init *i;
181:
182: /*
183: * Don't let library definitions override.
184: */
185: if (in_lib && v->v_name->sy_inst != NULL && v->v_name->sy_inst->i_init)
186: return;
187:
188: if ((p = v->v_name->sy_inst) == NULL)
189: {
190: p = talloc(inst);
191: v->v_name->sy_inst = p;
192: p->i_argdefn = v->v_argdefn;
193:
194: if ((p->i_args = v->v_args) == NULL)
195: p->i_tail = &p->i_args;
196: else
197: p->i_tail = v->v_tail;
198:
199: d = talloc(defn);
200: p->i_defn = d;
201: p->i_init = NULL;
202: p->i_name = v->v_name;
203: d->d_what = v->v_what;
204: d->d_type = v->v_type;
205:
206: if (in_lib)
207: {
208: d->d_file = src_file;
209: d->d_line = 0;
210: }
211: else
212: {
213: d->d_file = v->v_file;
214: d->d_line = v->v_line;
215: }
216:
217: d->d_next = NULL;
218: p->i_next = global_list;
219: global_list = p;
220: }
221: else
222: {
223: if (v->v_argdefn != NULL)
224: p->i_argdefn = v->v_argdefn;
225:
226: if ((*p->i_tail = v->v_args) != NULL)
227: p->i_tail = v->v_tail;
228:
229: d = p->i_defn;
230:
231: loop
232: {
233: if (d == NULL)
234: {
235: d = talloc(defn);
236: d->d_next = p->i_defn;
237: p->i_defn = d;
238:
239: elab:
240: d->d_what = v->v_what;
241: d->d_type = v->v_type;
242:
243: if (in_lib)
244: {
245: d->d_file = src_file;
246: d->d_line = 0;
247: }
248: else
249: {
250: d->d_file = v->v_file;
251: d->d_line = v->v_line;
252: }
253:
254: break;
255: }
256:
257: if (d->d_type == v->v_type)
258: break;
259:
260: if (complex_elaboration(v->v_type, d->d_type))
261: goto elab;
262:
263: if (array_elaboration(v->v_type, d->d_type))
264: goto elab;
265:
266: if (compatible(d->d_type, v->v_type))
267: break;
268:
269: d = d->d_next;
270: }
271: }
272:
273: if (v->v_ifile != NULL)
274: {
275: i = talloc(init);
276:
277: if (in_lib)
278: {
279: i->i_file = src_file;
280: i->i_line = 0;
281: }
282: else
283: {
284: i->i_file = v->v_ifile;
285: i->i_line = v->v_iline;
286: }
287:
288: i->i_varargs = v->v_varargs;
289: i->i_next = p->i_init;
290: p->i_init = i;
291: }
292: }
293:
294: /*
295: * Add an arglist (call) to args list. If it is ceorcible to
296: * the definition don't bother.
297: */
298: static void
299: add_arglist(v, a)
300: register var *v;
301: register arg *a;
302: {
303: if (v->v_argdefn != NULL && coercible_arglist(v->v_argdefn, a, -1))
304: {
305: free_arglist(a);
306: return;
307: }
308:
309: *v->v_tail = a;
310: v->v_tail = &a->a_next;
311: a->a_next = NULL;
312: }
313:
314: /*
315: * Complain about improper calls.
316: */
317: static void
318: put_improper_calls(d, u, v, af, tf)
319: register arg *d;
320: register arg *u;
321: int v;
322: int (*af)();
323: int (*tf)();
324: {
325: register args *p;
326: register args *q;
327: register char *sep;
328: register int n;
329: int i;
330: int force;
331:
332: while (u != NULL)
333: {
334: if (!(*af)(d, u, v))
335: {
336: putchar('\t');
337: put_file(u->a_file, u->a_line);
338:
339: if (v >= 0 && u->a_count < v)
340: printf(", expected at least %d arg%s, found %d\n", v, v == 1 ? "" : "s", u->a_count);
341: else if (d->a_count != u->a_count)
342: printf(", expected %d arg%s, found %d\n", d->a_count, d->a_count == 1 ? "" : "s", u->a_count);
343: else
344: {
345: if (v < 0)
346: n = d->a_count;
347: else
348: n = v;
349:
350: i = 1;
351: sep = ", ";
352: p = d->a_head;
353: q = u->a_head;
354:
355: while (--n >= 0)
356: {
357: if (p->a_type != q->a_type && !(*tf)(p->a_type, q->a_type))
358: {
359: force = different_vintage(p->a_type, q->a_type);
360: printf("%sarg %d expected ", sep, i);
361: put_type(p->a_type, force);
362: printf(", found ");
363: put_type(q->a_type, force);
364: sep = "\n\t\t";
365: }
366:
367: i++;
368: p = p->a_next;
369: q = q->a_next;
370: }
371:
372: putchar('\n');
373: }
374: }
375:
376: u = u->a_next;
377: }
378: }
379:
380: /*
381: * Enter vars from input file. Check statics and enter instances.
382: */
383: void
384: enter_vars(n)
385: register long n;
386: {
387: register int i;
388: register long j;
389: register var *p;
390: register var **v;
391:
392: v = (var **)salloc(n * sizeof (var *));
393: var_trans = v;
394:
395: for (j = 0; j < n; j++)
396: *v++ = NULL;
397:
398: v = var_trans;
399:
400: while (data_ptr < data_end)
401: {
402: register long l0;
403: register long l1;
404: register long l2;
405: arg *ap;
406:
407: i = getd();
408:
409: switch (obj_item(i))
410: {
411: case i_data:
412: l0 = getv();
413: l1 = getv();
414: initialisation(var_trans[l0], str_trans[l1], getv());
415:
416: loop
417: {
418: i = getd();
419:
420: switch (obj_item(i))
421: {
422: case d_addr:
423: skip4();
424: continue;
425:
426: case d_bytes:
427: if (obj_id(i) == 0)
428: l0 = getv();
429: else
430: l0 = obj_id(i);
431:
432: data_ptr += l0;
433: continue;
434:
435: case d_end:
436: break;
437:
438: case d_istring:
439: if (obj_id(i) == 0)
440: l0 = getv();
441: else
442: l0 = obj_id(i);
443:
444: str_num++;
445: data_ptr += l0;
446: continue;
447:
448: case d_irstring:
449: if (obj_id(i) == 0)
450: l0 = getv();
451: else
452: l0 = obj_id(i);
453:
454: str_num++;
455: data_ptr += l0;
456: skip4();
457: continue;
458:
459: case d_space:
460: if (obj_id(i) == 0)
461: skip();
462:
463: continue;
464:
465: case d_string:
466: skip();
467: continue;
468:
469: case d_reloc:
470: case d_rstring:
471: skip();
472: skip4();
473: continue;
474:
475: default:
476: fprintf(stderr, "%s: unknown data id %d\n", my_name, i);
477: exit(1);
478: }
479:
480: break;
481: }
482:
483: break;
484:
485: case i_lib:
486: case i_src:
487: skip();
488: break;
489:
490: case i_string:
491: if (obj_id(i) == 0)
492: l0 = getv();
493: else
494: l0 = obj_id(i);
495:
496: str_num++;
497: data_ptr += l0;
498: break;
499:
500: case i_type:
501: switch (obj_id(i))
502: {
503: case t_arrayof:
504: case t_bitfield:
505: skip();
506: skip();
507: break;
508:
509: case t_basetype:
510: (void)getd();
511: break;
512:
513: case t_dimless:
514: case t_ftnreturning:
515: case t_ptrto:
516: skip();
517: break;
518:
519: case t_elaboration:
520: skip();
521: skip();
522: skip();
523:
524: switch (i = obj_id(getd()))
525: {
526: case t_enum:
527: skip();
528: goto elab_enum;
529:
530: case t_structof:
531: skip();
532:
533: do
534: {
535: skip();
536: skip();
537: }
538: while (getv() != 0);
539:
540: skip();
541: break;
542:
543: case t_unionof:
544: skip();
545:
546: do
547: skip();
548: while (getv() != 0);
549:
550: skip();
551: break;
552:
553: default:
554: fprintf(stderr, "%s: unknown elaboration id %d\n", my_name, i);
555: exit(1);
556: }
557:
558: break;
559:
560: case t_enum:
561: skip();
562: skip();
563: skip();
564:
565: if (getv() == 0)
566: break;
567:
568: elab_enum:
569: do
570: skip();
571: while (getv() != 0);
572:
573: skip();
574: skip();
575: break;
576:
577: case t_structof:
578: case t_unionof:
579: skip();
580: skip();
581: skip();
582: break;
583:
584: default:
585: fprintf(stderr, "%s: unknown type id %d\n", my_name, obj_id(i));
586: exit(1);
587: }
588:
589: break;
590:
591: case i_var:
592: switch (obj_id(i))
593: {
594: case v_arglist:
595: l0 = getv();
596: l1 = getv();
597: initialisation(var_trans[l0], str_trans[l1], getv());
598: ap = new_arg();
599:
600: while (getv() != 0)
601: {
602: add_argument(ap, type_trans[getv()]);
603: skip();
604: skip();
605: var_index++;
606: }
607:
608: var_trans[l0]->v_argdefn = ap;
609: break;
610:
611: case v_array_size:
612: l0 = getv();
613: array_size(var_trans[l0], type_trans[getv()]);
614: break;
615:
616: case v_auto:
617: var_index++;
618: skip();
619: skip();
620: skip();
621: skip();
622: break;
623:
624: case v_call:
625: l0 = getv();
626: ap = new_arg();
627: ap->a_file = str_trans[getv()];
628: ap->a_line = getv();
629:
630: while ((l1 = getv()) != 0)
631: add_argument(ap, type_trans[l1]);
632:
633: add_arglist(var_trans[l0], ap);
634: break;
635:
636: case v_block_static:
637: case v_global:
638: case v_implicit_function:
639: case v_static:
640: l0 = getv();
641: l1 = getv();
642: l2 = getv();
643: var_trans[var_index++] = declare(obj_id(i), str_trans[l0], type_trans[l1], str_trans[l2], getv());
644: break;
645:
646: case v_varargs:
647: l0 = getv();
648: set_varargs(var_trans[l0], getv());
649: break;
650:
651: default:
652: fprintf(stderr, "%s: unknown var id %d\n", my_name, obj_id(i));
653: exit(1);
654: }
655:
656: break;
657:
658: default:
659: fprintf(stderr, "%s: unknown obj_item %d\n", my_name, obj_item(i));
660: exit(1);
661: }
662: }
663:
664: for (j = 1; j < n; j++)
665: {
666: register arg *a;
667:
668: if ((p = v[j]) == NULL)
669: continue;
670:
671: switch (p->v_what)
672: {
673: case v_block_static:
674: break;
675:
676: case v_global:
677: case v_implicit_function:
678: add_instance(p);
679: break;
680:
681: case v_static:
682: switch (p->v_type->t_type)
683: {
684: char *diag;
685:
686: error:
687: say_file();
688: printf(", static %s %s, ", diag, p->v_name->sy_name);
689: put_file(p->v_file, p->v_line);
690: printf(", never defined\n");
691: errors++;
692: break;
693:
694: case t_dimless:
695: diag = "array[]";
696: goto error;
697:
698: case t_ftnreturning:
699: if (p->v_ifile == NULL)
700: {
701: diag = "function";
702: goto error;
703: }
704:
705: for (a = p->v_args; a != NULL; a = a->a_next)
706: {
707: if (!coercible_arglist(p->v_argdefn, a, p->v_varargs))
708: {
709: say_file();
710: printf(": static function %s: ", p->v_name->sy_name);
711: put_file(p->v_file, p->v_line);
712: printf("\n");
713: put_improper_calls(p->v_argdefn, a, p->v_varargs, coercible_arglist, coercible);
714: errors++;
715: break;
716: }
717: }
718:
719: free_arguments(p->v_args);
720: free_arguments(p->v_argdefn);
721: }
722:
723: break;
724:
725: default:
726: fprintf(stderr, "%s: bad var type\n", my_name);
727: exit(1);
728: }
729:
730: p->v_next = var_free;
731: var_free = p;
732: }
733: }
734:
735: /*
736: * Check for mutliple declarations and definitions.
737: * Also check arglist compatibility.
738: */
739: static void
740: check_instance(p)
741: register inst *p;
742: {
743: register defn *d;
744: register init *i;
745: register arg *a;
746:
747: if (p->i_defn->d_next != NULL)
748: {
749: printf("%s multiply declared:\n", p->i_name->sy_name);
750:
751: for (d = p->i_defn; d != NULL; d = d->d_next)
752: {
753: putchar('\t');
754: put_file(d->d_file, d->d_line);
755:
756: if (d->d_what == v_implicit_function)
757: printf(" implicitly");
758:
759: printf(" as ");
760: put_type(d->d_type, 0);
761: putchar('\n');
762: }
763:
764: errors++;
765: }
766:
767: if (p->i_init != NULL)
768: {
769: if (p->i_init->i_next != NULL)
770: {
771: printf("%s multiply defined:\n", p->i_name->sy_name);
772:
773: for (i = p->i_init; i != NULL; i = i->i_next)
774: {
775: putchar('\t');
776: put_file(i->i_file, i->i_line);
777: putchar('\n');
778: }
779:
780: errors++;
781: return;
782: }
783:
784: if (p->i_argdefn != NULL)
785: {
786: for (a = p->i_args; a != NULL; a = a->a_next)
787: {
788: if (!compatible_arglist(p->i_argdefn, a, p->i_init->i_varargs))
789: {
790: printf("function %s: ", p->i_name->sy_name);
791: put_file(p->i_init->i_file, p->i_init->i_line);
792: printf("\n");
793: put_improper_calls(p->i_argdefn, a, p->i_init->i_varargs, compatible_arglist, compatible);
794: errors++;
795: break;
796: }
797: }
798: }
799: }
800: }
801:
802: void
803: check_externs()
804: {
805: register inst *p;
806:
807: for (p = global_list; p != NULL; p = p->i_next)
808: check_instance(p);
809: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.