![[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 [CSRG BSD Unix] / 43BSD / usr.bin / f77 / src / f77pass1|
Return to error.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / f77 / src / f77pass1 |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)error.c 5.1 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: /*
12: * error.c
13: *
14: * Error handling routines for f77 compiler pass 1, 4.2 BSD.
15: *
16: * University of Utah CS Dept modification history:
17: *
18: * Revision 1.2 84/08/20 17:57:20 donn
19: * Added strategic colons to the format strings in execerr() and dclerr().
20: *
21: */
22:
23: #include "defs.h"
24:
25:
26: warn1(s,t)
27: char *s, *t;
28: {
29: char buff[100];
30: sprintf(buff, s, t);
31: warn(buff);
32: }
33:
34:
35: warn(s)
36: char *s;
37: {
38: if(nowarnflag)
39: return;
40: fprintf(diagfile, "Warning on line %d of %s: %s\n", lineno, infname, s);
41: ++nwarn;
42: }
43:
44:
45: errstr(s, t)
46: char *s, *t;
47: {
48: char buff[100];
49: sprintf(buff, s, t);
50: err(buff);
51: }
52:
53:
54: errnm(fmt, l, s)
55: char *fmt;
56: int l;
57: register char *s;
58: {
59: char buff[VL+1];
60: register int i;
61:
62: i = 0;
63: while (i < l)
64: {
65: buff[i] = s[i];
66: i++;
67: }
68: buff[i] = '\0';
69:
70: errstr(fmt, buff);
71: }
72:
73: warnnm(fmt, l, s)
74: char *fmt;
75: int l;
76: register char *s;
77: {
78: char buff[VL+1];
79: register int i;
80:
81: i = 0;
82: while (i < l)
83: {
84: buff[i] = s[i];
85: i++;
86: }
87: buff[i] = '\0';
88:
89: warn1(fmt, buff);
90: }
91:
92: erri(s,t)
93: char *s;
94: int t;
95: {
96: char buff[100];
97: sprintf(buff, s, t);
98: err(buff);
99: }
100:
101:
102: err(s)
103: char *s;
104: {
105: fprintf(diagfile, "Error on line %d of %s: %s\n", lineno, infname, s);
106: ++nerr;
107: optoff();
108: }
109:
110:
111: yyerror(s)
112: char *s;
113: { err(s); }
114:
115:
116:
117: dclerr(s, v)
118: char *s;
119: Namep v;
120: {
121: char buff[100];
122:
123: if(v)
124: {
125: sprintf(buff, "Declaration error for %s: %s", varstr(VL, v->varname), s);
126: err(buff);
127: }
128: else
129: errstr("Declaration error: %s", s);
130: }
131:
132:
133:
134: execerr(s, n)
135: char *s, *n;
136: {
137: char buf1[100], buf2[100];
138:
139: sprintf(buf1, "Execution error: %s", s);
140: sprintf(buf2, buf1, n);
141: err(buf2);
142: }
143:
144:
145: fatal(t)
146: char *t;
147: {
148: fprintf(diagfile, "Compiler error line %d of %s: %s\n", lineno, infname, t);
149: if (debugflag[8])
150: showbuffer();
151: if (debugflag[0])
152: abort();
153: done(3);
154: exit(3);
155: }
156:
157:
158:
159:
160: fatalstr(t,s)
161: char *t, *s;
162: {
163: char buff[100];
164: sprintf(buff, t, s);
165: fatal(buff);
166: }
167:
168:
169:
170: fatali(t,d)
171: char *t;
172: int d;
173: {
174: char buff[100];
175: sprintf(buff, t, d);
176: fatal(buff);
177: }
178:
179:
180:
181: badthing(thing, r, t)
182: char *thing, *r;
183: int t;
184: {
185: char buff[50];
186: sprintf(buff, "Impossible %s %d in routine %s", thing, t, r);
187: fatal(buff);
188: }
189:
190:
191:
192: badop(r, t)
193: char *r;
194: int t;
195: {
196: badthing("opcode", r, t);
197: }
198:
199:
200:
201: badtag(r, t)
202: char *r;
203: int t;
204: {
205: badthing("tag", r, t);
206: }
207:
208:
209:
210:
211:
212: badstg(r, t)
213: char *r;
214: int t;
215: {
216: badthing("storage class", r, t);
217: }
218:
219:
220:
221:
222: badtype(r, t)
223: char *r;
224: int t;
225: {
226: badthing("type", r, t);
227: }
228:
229:
230: many(s, c)
231: char *s, c;
232: {
233: char buff[25];
234:
235: sprintf(buff, "Too many %s. Try the -N%c option", s, c);
236: fatal(buff);
237: }
238:
239:
240: err66(s)
241: char *s;
242: {
243: errstr("Fortran 77 feature used: %s", s);
244: }
245:
246:
247:
248: errext(s)
249: char *s;
250: {
251: errstr("F77 compiler extension used: %s", s);
252: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.