![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to error.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to error.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 root 1: /*ident "@(#)ctrans:src/error.c 1.1.3.22" */
2: /**************************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All rigths Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: error.c :
11:
12: write error messages
13:
14: Until scan_started != 0 no context can be assumed
15:
16: ***************************************************************************/
17:
18: #ifdef __cplusplus
19: #include <stdlib.h>
20: #endif
21:
22: #include "cfront.h"
23: #include "size.h"
24:
25: int error_count;
26: static int no_of_warnings;
27: char scan_started;
28:
29: #define ERRTRACE 20
30:
31: static char* abbrev_tbl[] = {
32: " argument",
33: " base",
34: " class",
35: " declaration",
36: " expression",
37: " function",
38: "G",
39: "H",
40: " initialize",
41: "J",
42: " constructor", // 'K' !
43: " list",
44: " member",
45: " name",
46: " object",
47: " pointer",
48: " qualifie",
49: " reference",
50: " statement",
51: " type",
52: " undefined",
53: " variable",
54: " with",
55: " expected", // 'X'
56: "Y",
57: "Z",
58: };
59:
60: ea* ea0;
61:
62: void error_init()
63: {
64: static char errbuf[BUFSIZ];
65: setbuf(stderr,errbuf);
66: ea0 = new ea;
67: }
68:
69: #define INTERNAL 127
70:
71: void ext(int n)
72: {
73: int useit=n; // to avoid n not used warning during build
74: // for testing only
75: // if (n == INTERNAL)
76: // abort();
77: exit(error_count?error_count:1);
78: }
79:
80: static void print_loc()
81: {
82: loc* sl = (Cstmt) ? &Cstmt->where : 0;
83: loc* dl = (Cdcl && (Cdcl->base==NAME || Cdcl->base==TNAME)) ? &Cdcl->where : 0;
84: if (sl && dl && sl->file==dl->file) { // Cstmt and Cdcl in same file
85: if (sl->line<=dl->line) {
86: if (curloc.file==dl->file && curloc.line<dl->line)
87: // hack to compensate for YACC's
88: // bad manners in the use of line numbers
89: sl->put(out_file);
90: else
91: dl->put(out_file);
92: }
93: else
94: sl->put(out_file);
95: }
96: else if (sl && sl->file==curr_file) // Cstmt in current file
97: sl->put(out_file);
98: else if (dl && dl->file==curr_file) // Cdcl in current file
99: dl->put(out_file);
100: else
101: curloc.put(out_file);
102: }
103:
104: static void print_context()
105: {
106: putc('\n',out_file);
107: }
108:
109: static char in_error = 0;
110: static loc dummy_loc;
111:
112: void yyerror(char* s)
113: {
114: error(s);
115: }
116:
117: int error(const char* s)
118: {
119: return error(0,s);
120: }
121:
122: int error(int t, const char* s)
123: {
124: return error(t,&dummy_loc,s,*ea0,*ea0,*ea0,*ea0);
125: }
126:
127: int error(const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
128: {
129: return error(0,&dummy_loc,s,a0,a1,a2,a3);
130: }
131:
132: int error(loc* lc, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
133: {
134: return error(0,lc,s,a0,a1,a2,a3);
135: }
136:
137: int error(int t, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
138: {
139: return error(t,&dummy_loc,s,a0,a1,a2,a3);
140: }
141:
142: int suppress_error;
143:
144: int error(int t, loc* lc, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
145: /*
146: "int" not "void" because of "pch" in lex.c
147:
148: legal error types are:
149: 'w' warning (not counted in error count)
150: 'd' debug
151: 'D' debug -- no prefix
152: 's' "not implemented" message
153: 'l' "compiler limit exceeded" message
154: 0 error
155: 'i' internal error (causes abort)
156: 't' error while printing error message
157: */
158: {
159: if (suppress_error) return 0;
160:
161: if (in_error++)
162: if (t == 't')
163: t = 'i';
164: else if (4 < in_error) {
165: fprintf(stderr,"\nOops!, error while handling error\n");
166: ext(13);
167: }
168:
169: FILE * of = out_file;
170: out_file = stderr;
171:
172: if (!scan_started || t=='t')
173: putch('\n');
174: else if (lc != &dummy_loc) {
175: if(t != 'D') lc->put(out_file);
176: } else {
177: if(t != 'D') print_loc();
178: }
179:
180: switch (t) {
181: case 0:
182: putstring("error: ");
183: break;
184: case 'd':
185: putstring("DEBUG: ");
186: case 'D':
187: break;
188: case 'w':
189: no_of_warnings++;
190: putstring("warning: ");
191: break;
192: case 'l':
193: putstring("compiler limit exceeded: ");
194: break;
195: case 's':
196: putstring("sorry, not implemented: ");
197: break;
198: case 'i':
199: if (error_count++) {
200: fprintf(out_file,"sorry, %s cannot recover from earlier errors\n",prog_name);
201: ext(INTERNAL);
202: }
203: else
204: fprintf(out_file,"internal %s error: ",prog_name);
205: }
206:
207: ea argv[4];
208: ea* a = argv;
209: argv[0] = a0;
210: argv[1] = a1;
211: argv[2] = a2;
212: argv[3] = a3;
213:
214: int c;
215:
216: while (c = *s++) {
217: if ('A'<=c && c<='Z')
218: putstring(abbrev_tbl[c-'A']);
219: else if (c == '%') {
220: switch (c = *s++) {
221: case 'k': // TOK assumed passed as an int
222: { TOK x = TOK(a->i);
223: if (0<x && x<=MAXTOK && keys[x])
224: fprintf(out_file," %s",keys[x]);
225: else
226: fprintf(out_file," token(%d)",x);
227: break;
228: }
229: case 't': // Ptype
230: { Ptype tt = Ptype(a->p);
231: if (tt == 0) break;
232:
233: putch(' ');
234:
235: int nt = ntok;
236: emode = 1;
237: tt->dcl_print(0);
238: emode = 0;
239: ntok = nt;
240: break;
241: }
242: case 'n': // Pname
243: { Pname nn = Pname(a->p);
244: if (nn && nn->string) {
245: // suppress generated class names:
246: if (nn->string[0]=='_'
247: && nn->string[1]=='_'
248: && nn->string[2]=='C') break;
249: emode = 1;
250: putch(' ');
251: nn->print();
252: emode = 0;
253: }
254: else
255: putstring(" ?");
256: break;
257: }
258: case 'p': // pointer
259: { char* f = sizeof(char*)==sizeof(int)?" %d":" %ld";
260: fprintf(out_file,f,a->p);
261: break;
262: }
263: case 'c': // char assumed passed as an int
264: putch(a->i);
265: break;
266:
267: case 'd': // int
268: fprintf(out_file," %d",a->i);
269: break;
270:
271: case 'o': // int
272: fprintf(out_file," %o",a->i);
273: break;
274:
275: case 's': // char*
276: char *s = ((char *)a->p);
277: if ( s )
278: putst((char*)a->p);
279: break;
280: }
281: a++;
282: }
283: else
284: putch(c);
285: }
286:
287: /*
288: switch (t) {
289: case 'd':
290: case 't':
291: case 'w':
292: putch('\n');
293: break;
294: default:
295: */
296: print_context();
297: /*
298: }
299: */
300: fflush(stderr);
301: if (!scan_started && t!='d' && t!='w') ext(4);
302: /* now we may want to carry on */
303:
304: out_file = of;
305:
306: switch (t) {
307: case 't':
308: if (--in_error) return 0;
309: case 'i':
310: ext(INTERNAL);
311: case 0:
312: case 'l':
313: case 's':
314: if (MAXERR<++error_count) {
315: fprintf(stderr,"Sorry, too many errors\n");
316: ext(7);
317: }
318: }
319:
320: in_error = 0;
321: return 0;
322: }
323:
324:
325:
326: #ifdef DBG
327: #define OPEREP(v) ((v)>MAXTOK || (v)<=0 ? 0 : keys[v])
328: void
329: display_type( Ptype t )
330: {
331: if ( t ) { putc(' ',stderr);
332: FILE * of = out_file;
333: out_file = stderr;
334: extern int ntok; int nt = ntok;
335: emode=1; (t)->dcl_print(0); emode=0;
336: //fprintf(stderr," <node %d",t->node::id);
337: if(!t->allocated)fprintf(stderr," UNALLOCATED!");
338: //putc('>',stderr);
339: ntok = nt;
340: out_file = of;
341: } else fprintf(stderr," <null type>");
342: }
343: #define INDENT(in) { for ( int i = in; i > 0; --i ) fprintf(stderr," "); }
344: static indent = 0;
345:
346: void
347: display_expr( Pexpr ptr, char* label, int oneline )
348: {
349: INDENT(indent);
350: if ( label ) fprintf(stderr, "%s:", label);
351: if ( ptr == 0 ) {
352: fprintf(stderr, "NULL EXPR\n" );
353: return;
354: }
355: fprintf(stderr,"%d",ptr->node::id);
356: if(!ptr->allocated)fprintf(stderr," UNALLOCATED!");
357: putc(':',stderr);
358: char* s = OPEREP(ptr->base);
359: if ( s == 0 )
360: fprintf(stderr, "token(%d)", ptr->base );
361: else
362: fprintf(stderr,"%s",s);
363: if ( ptr->displayed ) { // recursion!!!
364: if ( ptr->base == NAME )
365: fprintf(stderr," '%s'",Pname(ptr)->string);
366: fprintf(stderr," RECURSION!!!\n");
367: ptr->displayed = 0;
368: return;
369: }
370: ptr->displayed = 1;
371: switch ( ptr->base ) {
372: case QUEST:
373: display_type(ptr->tp);
374: putc('\n',stderr);
375: if ( !oneline ) {
376: ++indent;
377: display_expr( ptr->cond, "cond" );
378: display_expr( ptr->e1, "e1" );
379: display_expr( ptr->e2, "e2" );
380: --indent;
381: }
382: break;
383: case REF: case DOT:
384: display_type(ptr->tp);
385: putc('\n',stderr);
386: if ( !oneline ) {
387: ++indent;
388: display_expr( ptr->e1, "e1" );
389: display_expr( ptr->mem, "mem" );
390: --indent;
391: }
392: break;
393: case MDOT:
394: display_type(ptr->tp);
395: fprintf(stderr," string2:'%s'\n",ptr->string2?ptr->string2:"");
396: if ( !oneline ) {
397: ++indent;
398: display_expr( ptr->mem, "mem" );
399: --indent;
400: }
401: break;
402: case ICALL:
403: fprintf(stderr," fn=='%s'",ptr->il->fct_name->string);
404: display_type(ptr->tp);
405: putc('\n',stderr);
406: if ( !oneline ) {
407: ++indent;
408: for ( int i = 0; i < ptr->il->i_slots; ++i ) {
409: ia *aa = &ptr->il->i_args[i];
410: INDENT(indent);
411: fprintf(stderr,"arg:'%s'",aa->local&&aa->local->string?aa->local->string:"");
412: display_type(aa->tp);
413: putc('\n',stderr);
414: ++indent;
415: display_expr( aa->arg, "actual" );
416: --indent;
417: }
418: display_expr( ptr->e1, "e1" );
419: display_expr( ptr->e2, "e2" );
420: --indent;
421: }
422: break;
423: case SIZEOF:
424: if ( ptr->tp2 ) {
425: putc('(',stderr);
426: display_type(ptr->tp2);
427: putc(')',stderr);
428: }
429: display_type(ptr->tp);
430: putc('\n',stderr);
431: if ( !oneline ) {
432: if ( ptr->e1 ) {
433: ++indent;
434: display_expr(ptr->e1,"e1");
435: --indent;
436: }
437: if ( ptr->e2 ) {
438: ++indent;
439: display_expr(ptr->e2,"e2");
440: --indent;
441: }
442: }
443: break;
444: case ZERO:
445: display_type(ptr->tp);
446: putc('\n',stderr);
447: break;
448: case NAME: case TNAME: case STRING:
449: case ICON: case ID:
450: case FCON: case CCON:
451: case IVAL:
452: fprintf(stderr," '%s'",(ptr->string)?ptr->string:"<0>");
453: display_type(ptr->tp);
454: if(ptr->string2)fprintf(stderr," string2=='%s'",ptr->string2);
455: if ( ptr->permanent ) fprintf(stderr, " (permanent)");
456: if ( ptr->base == IVAL ) fprintf(stderr, " i1==%d", ptr->i1);
457: putc('\n',stderr);
458: if ( !oneline && (ptr->base == NAME || ptr->base == TNAME) ) {
459: Pname n = Pname(ptr);
460: ++indent;
461: INDENT(indent);
462: fprintf(stderr, "n_sto==%d", n->n_sto );
463: fprintf(stderr, " n_stclass==%d",n->n_stclass);
464: fprintf(stderr, " n_scope==%d",n->n_scope);
465: fprintf(stderr, " n_protected==%d\n", n->n_protect );
466: INDENT(indent);
467: fprintf(stderr, "n_oper=='%s'", (s=OPEREP(n->base))?s:"0");
468: fprintf(stderr, " n_val==%d", n->n_val );
469: fprintf(stderr, " n_xref==%d",n->n_xref);
470: fprintf(stderr, " lex_level==%d\n", n->lex_level );
471: INDENT(indent);
472: fprintf(stderr, "n_used==%d",n->n_used);
473: fprintf(stderr, " n_assigned_to==%d",n->n_assigned_to);
474: fprintf(stderr, " n_addr_taken==%d\n",n->n_addr_taken );
475: INDENT(indent);
476: fprintf(stderr, "n_union==%d", n->n_union);
477: fprintf(stderr, " n_list=='%s'", n->n_list?n->n_list->string:"<0>" );
478: fprintf(stderr, " n_qualifier=='%s'", n->n_qualifier?n->n_qualifier->string:"<0>" );
479: if ( n->n_initializer ) {
480: fprintf(stderr, " n_initializer:\n" );
481: ++indent;
482: display_expr( n->n_initializer );
483: --indent;
484: } else fprintf(stderr, " n_initializer==<0>\n");
485: --indent;
486: }
487: break;
488: case BLOCK:
489: ((Pstmt)ptr)->where.put(stderr); putc(' ',stderr);
490: putc('\n',stderr);
491: break;
492: default:
493: display_type(ptr->tp);
494: putc('\n',stderr);
495: if ( !oneline && ptr->base > 0
496: && (ptr->base<165 || ptr->base==MEMPTR) ) {
497: ++indent;
498: display_expr( ptr->e1, "e1" );
499: display_expr( ptr->e2, "e2" );
500: --indent;
501: }
502: break;
503: }
504: ptr->displayed = 0;
505: return;
506: }
507: void
508: display_stmt( Pstmt ptr, char* label, int oneline )
509: {
510: INDENT(indent);
511: if ( label ) fprintf(stderr, "%s:", label);
512: if ( ptr == 0 ) {
513: fprintf(stderr, "NULL STMT\n" );
514: return;
515: }
516: fprintf(stderr,"%d",ptr->node::id);
517: if(!ptr->allocated)fprintf(stderr," UNALLOCATED!");
518: putc(':',stderr);
519: char* s = OPEREP(ptr->base);
520: if ( s == 0 )
521: fprintf(stderr, "token(%d)", ptr->base );
522: else
523: fprintf(stderr,"%s",s);
524: if ( ptr->displayed ) { // recursion!!!
525: if ( ptr->base == NAME )
526: fprintf(stderr," '%s'",Pname(ptr)->string);
527: fprintf(stderr," RECURSION!!!\n");
528: ptr->displayed = 0;
529: return;
530: }
531: putc(' ',stderr);
532: ptr->where.put(stderr);
533: if ( oneline ) { putc('\n',stderr); return; }
534: ptr->displayed = 1;
535: switch ( ptr->base ) {
536: case BLOCK:
537: fprintf(stderr," .. ");
538: ptr->where2.put(stderr);
539: putc('\n',stderr);
540: ++indent;
541: { for( Pstmt st = ptr->s; st; st = st->s_list )
542: display_stmt( ptr->s, "s" );
543: }
544: --indent;
545: break;
546: case IF:
547: putc('\n',stderr);
548: ++indent;
549: display_expr(ptr->e,"cond");
550: display_stmt(ptr->s,"if-clause");
551: --indent;
552: if ( ptr->else_stmt ) {
553: INDENT(indent);
554: fprintf(stderr,"else\n");
555: ++indent;
556: display_stmt(ptr->else_stmt,"else-clause");
557: --indent;
558: }
559: break;
560: case DO:
561: putc('\n',stderr);
562: ++indent;
563: display_stmt(ptr->s,"do-stmt");
564: display_expr(ptr->e,"cond");
565: --indent;
566: break;
567: case WHILE:
568: putc('\n',stderr);
569: ++indent;
570: display_expr(ptr->e,"cond");
571: display_stmt(ptr->s,"while-stmt");
572: --indent;
573: break;
574: case FOR:
575: putc('\n',stderr);
576: ++indent;
577: display_stmt(ptr->for_init,"init");
578: display_expr(ptr->e,"cond");
579: display_expr(ptr->e2,"incr");
580: display_stmt(ptr->s,"stmt");
581: --indent;
582: break;
583: case RETURN:
584: putc('\n',stderr);
585: ++indent;
586: display_expr(ptr->e,"e");
587: --indent;
588: break;
589: case SM:
590: putc('\n',stderr);
591: ++indent;
592: display_expr(ptr->e,"e");
593: --indent;
594: break;
595: default:
596: putc('\n',stderr);
597: break;
598: }
599: ptr->displayed = 0;
600: return;
601: }
602:
603: void
604: display_namelist( Plist nl, char* s, int verbose )
605: {
606: error('d',"namelist: %s",s?s:"");
607: ++indent;
608: for ( Plist l = nl; l; l = l->l ) {
609: Pname n = l->f;
610: INDENT(indent);
611: fprintf(stderr," %d",n);
612: error('D'," %n %k n_key %d",n,n?n->tp->base:0,n?n->n_key:0);
613: if ( verbose ) {
614: ++indent;
615: display_expr(n);
616: --indent;
617: }
618: }
619: --indent;
620: }
621: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.