![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to errorpi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb / error|
Return to errorpi.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb / error |
1.1 root 1: static char *sccsid = "@(#)errorpi.c 1.3 (Berkeley) 7/2/83";
2: #include <stdio.h>
3: #include <ctype.h>
4: #include "error.h"
5:
6: extern char *currentfilename;
7: static char *c_linenumber;
8: static char *unk_hdr[] = {"In", "program", "???"};
9: static char **c_header = &unk_hdr[0];
10:
11: /*
12: * Attempt to handle error messages produced by pi (and by pc)
13: *
14: * problem #1: There is no file name available when a file does not
15: * use a #include; this will have to be given to error
16: * in the command line.
17: * problem #2: pi doesn't always tell you what line number
18: * a error refers to; for example during the tree
19: * walk phase of code generation and error detection,
20: * an error can refer to "variable foo in procedure bletch"
21: * without giving a line number
22: * problem #3: line numbers, when available, are attached to
23: * the source line, along with the source line itself
24: * These line numbers must be extracted, and
25: * the source line thrown away.
26: * problem #4: Some error messages produce more than one line number
27: * on the same message.
28: * There are only two (I think):
29: * %s undefined on line%s
30: * %s improperly used on line%s
31: * here, the %s makes line plural or singular.
32: *
33: * Here are the error strings used in pi version 1.2 that can refer
34: * to a file name or line number:
35: *
36: * Multiply defined label in case, lines %d and %d
37: * Goto %s from line %d is into a structured statement
38: * End matched %s on line %d
39: * Inserted keyword end matching %s on line %d
40: *
41: * Here are the general pi patterns recognized:
42: * define piptr == -.*^-.*
43: * define msg = .*
44: * define digit = [0-9]
45: * definename = .*
46: * define date_format letter*3 letter*3 (digit | (digit digit))
47: * (digit | (digit digit)):digit*2 digit*4
48: *
49: * {e,E} (piptr) (msg) Encounter an error during textual scan
50: * E {digit}* - (msg) Have an error message that refers to a new line
51: * E - msg Have an error message that refers to current
52: * function, program or procedure
53: * (date_format) (name): When switch compilation files
54: * ... (msg) When refer to the previous line
55: * 'In' ('procedure'|'function'|'program') (name):
56: * pi is now complaining about 2nd pass errors.
57: *
58: * Here is the output from a compilation
59: *
60: *
61: * 2 var i:integer;
62: * e --------------^--- Inserted ';'
63: * E 2 - All variables must be declared in one var part
64: * E 5 - Include filename must end in .i
65: * Mon Apr 21 15:56 1980 test.h:
66: * 2 begin
67: * e ------^--- Inserted ';'
68: * Mon Apr 21 16:06 1980 test.p:
69: * E 2 - Function type must be specified
70: * 6 procedure foo(var x:real);
71: * e ------^--- Inserted ';'
72: * In function bletch:
73: * E - No assignment to the function variable
74: * w - variable x is never used
75: * E 6 - foo is already defined in this block
76: * In procedure foo:
77: * w - variable x is neither used nor set
78: * 9 z : = 23;
79: * E --------------^--- Undefined variable
80: * 10 y = [1];
81: * e ----------------^--- Inserted ':'
82: * 13 z := 345.;
83: * e -----------------------^--- Digits required after decimal point
84: * E 10 - Constant set involved in non set context
85: * E 11 - Type clash: real is incompatible with integer
86: * ... Type of expression clashed with type of variable in assignment
87: * E 12 - Parameter type not identical to type of var parameter x of foo
88: * In program mung:
89: * w - variable y is never used
90: * w - type foo is never used
91: * w - function bletch is never used
92: * E - z undefined on lines 9 13
93: */
94: char *Months[] = {
95: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
96: "Jul", "Aug", "Sep", "Oct","Nov", "Dec",
97: 0
98: };
99: char *Days[] = {
100: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", 0
101: };
102: char *Piroutines[] = {
103: "program", "function", "procedure", 0
104: };
105:
106:
107: static boolean structured, multiple;
108:
109: char *pi_Endmatched[] = {"End", "matched"};
110: char *pi_Inserted[] = {"Inserted", "keyword", "end", "matching"};
111:
112: char *pi_multiple[] = {"Mutiply", "defined", "label", "in", "case,", "line"};
113: char *pi_structured[] = {"is", "into", "a", "structured", "statement"};
114:
115: char *pi_und1[] = {"undefined", "on", "line"};
116: char *pi_und2[] = {"undefined", "on", "lines"};
117: char *pi_imp1[] = {"improperly", "used", "on", "line"};
118: char *pi_imp2[] = {"improperly", "used", "on", "lines"};
119:
120: boolean alldigits(string)
121: reg char *string;
122: {
123: for (; *string && isdigit(*string); string++)
124: continue;
125: return(*string == '\0');
126: }
127: boolean instringset(member, set)
128: char *member;
129: reg char **set;
130: {
131: for(; *set; set++){
132: if (strcmp(*set, member) == 0)
133: return(TRUE);
134: }
135: return(FALSE);
136: }
137:
138: boolean isdateformat(wordc, wordv)
139: int wordc;
140: char **wordv;
141: {
142: return(
143: (wordc == 5)
144: && (instringset(wordv[0], Days))
145: && (instringset(wordv[1], Months))
146: && (alldigits(wordv[2]))
147: && (alldigits(wordv[4])) );
148: }
149:
150: boolean piptr(string)
151: reg char *string;
152: {
153: if (*string != '-')
154: return(FALSE);
155: while (*string && *string == '-')
156: string++;
157: if (*string != '^')
158: return(FALSE);
159: string++;
160: while (*string && *string == '-')
161: string++;
162: return(*string == '\0');
163: }
164:
165: extern int wordc;
166: extern char **wordv;
167:
168: Errorclass pi()
169: {
170: char **nwordv;
171:
172: if (wordc < 2)
173: return (C_UNKNOWN);
174: if ( ( strlen(wordv[1]) == 1)
175: && ( (wordv[1][0] == 'e') || (wordv[1][0] == 'E') )
176: && ( piptr(wordv[2]) )
177: ) {
178: boolean longpiptr = 0;
179: /*
180: * We have recognized a first pass error of the form:
181: * letter ------^---- message
182: *
183: * turn into an error message of the form:
184: *
185: * file line 'pascal errortype' letter \n |---- message
186: * or of the form:
187: * file line letter |---- message
188: * when there are strlen("(*[pi]") or more
189: * preceding '-' on the error pointer.
190: *
191: * Where the | is intended to be a down arrow, so that
192: * the pi error messages can be inserted above the
193: * line in error, instead of below. (All of the other
194: * langauges put thier messages before the source line,
195: * instead of after it as does pi.)
196: *
197: * where the pointer to the error has been truncated
198: * by 6 characters to account for the fact that
199: * the pointer points into a tab preceded input line.
200: */
201: language = INPI;
202: (void)substitute(wordv[2], '^', '|');
203: longpiptr = position(wordv[2],'|') > (6+8 & � &� ��2��$ &�
204: � _Gs 辿 _Gs � � &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& /*
205: * C object code impr -- third part
206: */
207:
208: #include "c2.h"
209: #include <stdio.h>
210: #include <ctype.h>
211:
212: #define NUSE 6
213: struct node *uses[NUSE]; /* for backwards flow analysis */
214: char *lastrand; /* last operand of instruction */
215: char *findcon();
216:
217: ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
218: register int log;
219: if (n==0 || n&(n-1)) return(-1); log=0;
220: for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
221: }
222:
223: equop(p1, p2)
224: register struct node *p1, *p2;
225: {
226: register char *cp1, *cp2;
227:
228: if (p1->op != p2->op || p1->subop != p2->subop)
229: return(0);
230: if (p1->op>0 && p1->op<MOV)
231: return(0);
232: if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
233: cp1 = p1->code;
234: cp2 = p2->code;
235: if (cp1==0 && cp2==0)
236: return(1);
237: if (cp1==0 || cp2==0)
238: return(0);
239: while (*cp1 == *cp2++)
240: if (*cp1++ == 0)
241: return(1);
242: return(0);
243: }
244:
245: delnode(p) register struct node *p; {
246: p->back->forw = p->forw;
247: p->forw->back = p->back;
248: }
249:
250: decref(p)
251: register struct node *p;
252: {
253: if (p && --p->refc <= 0) {
254: nrlab++; nchange++;
255: delnod ;
256: }
257: }
258:
259: struct node *
260: nonlab(ap)
261: struct node *ap;
262: {
263: register struct node *p;
264:
265: p = ap;
266: while (p && p->op==LABEL)
267: p = p->forw;
268: return(p);
269: }
270:
271: clearuse() {
272: register struct node **i;
273: for (i=uses+NUSE; i>uses;) *--i=0;
274: }
275:
276: clearreg() {
277: register char **i;
278: for (i=regs+NREG; i>regs;){ **--i=0; **i=0; }
279: conloc[0] = 0; ccloc[0] = 0;
280: }
281:
282: savereg(ai, s, type)
283: register char *s;
284: {
285: register char *p, *sp;
286:
287: sp = p = regs[ai];
288: /* if any indexing, must be parameter or local */
289: /* indirection (as in "*-4(fp)") is ok, however */
290: *p++ = type;
291: while (*p++ = *s)
292: if (*s=='[' || *s++=='(' && *s!='f') {*sp = 0; return;}
293: }
294:
295: dest(s,type, ccflg)
296: register char *s;
297: {
298: register int i;
299:
300: if ((i = isreg(s)) >= 0) {
301: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */
302: }
303: for (i=NREG; --i>=0;)
304: if (regs[i][1]=='*' && equstr(s, regs[i]+2))
305: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */
306: while ((i = findrand(s,0)) >= 0) /* previous values (wordc == 6) && (wordvcmp(wordv+1, 2, pi_Endmatched) == 0))
307: || ( (wordc == 8) && (wordvcmp(wordv+1, 4, pi_Inserted) == 0))
308: || ( multiple = ((wordc == 9) && (wordvcmp(wordv+1,6, pi_multiple) == 0) ) )
309: || ( structured = ((wordc == 10) && (wordvcmp(wordv+6,5, pi_structured) == 0 ) ))
310: ){
311: language = INPI;
312: nwordv = wordvsplice(2, wordc, wordv+1);
313: nwordv[0] = strsave(currentfilename);
314: nwordv[1] = structured ? wordv [5] : wordv[wordc];
315: wordc += 2;
316: wordv = nwordv - 1;
317: if (!multiple)
318: return(C_TRUE);
319: erroradd(wordc, nwordv, C_TRUE, C_UNKNOWN);
320: nwordv = wordvsplice(0, wordc, nwordv);
321: nwordv[1] = wordv[wordc - 2];
322: return(C_TRUE);
323: }
324: return(C_UNKNOWN);
325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.