![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to errorsubr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / error|
Return to errorsubr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / error |
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[] = "@(#)errorsubr.c 5.1 (Berkeley) 5/31/85";
9: #endif not lint
10:
11: #include <stdio.h>
12: #include <ctype.h>
13: #include "error.h"
14: /*
15: * Arrayify a list of rules
16: */
17: arrayify(e_length, e_array, header)
18: int *e_length;
19: Eptr **e_array;
20: Eptr header;
21: {
22: reg Eptr errorp;
23: reg Eptr *array;
24: reg int listlength;
25: reg int listindex;
26:
27: for (errorp = header, listlength = 0;
28: errorp; errorp = errorp->error_next, listlength++)
29: continue;
30: array = (Eptr*)Calloc(listlength+1, sizeof (Eptr));
31: for(listindex = 0, errorp = header;
32: listindex < listlength;
33: listindex++, errorp = errorp->error_next){
34: array[listindex] = errorp;
35: errorp->error_position = listindex;
36: }
37: array[listindex] = (Eptr)0;
38: *e_length = listlength;
39: *e_array = array;
40: }
41:
42: /*VARARGS1*/
43: error(msg, a1, a2, a3)
44: char *msg;
45: {
46: fprintf(stderr, "Error: ");
47: fprintf(stderr, msg, a1, a2, a3);
48: fprintf(stderr, "\n");
49: fflush(stdout);
50: fflush(stderr);
51: exit(6);
52: }
53: /*ARGSUSED*/
54: char *Calloc(nelements, size)
55: int nelements;
56: int size;
57: {
58: char *back;
59: if ( (back = (char *)calloc(nelements, size)) == (char *)NULL){
60: error("Ran out of memory.\n");
61: exit(1);
62: }
63: return(back);
64: }
65:
66: char *strsave(instring)
67: char *instring;
68: {
69: char *outstring;
70: (void)strcpy(outstring = (char *)Calloc(1, strlen(instring) + 1),
71: instring);
72: return(outstring);
73: }
74: /*
75: * find the position of a given character in a string
76: * (one based)
77: */
78: int position(string, ch)
79: reg char *string;
80: reg char ch;
81: {
82: reg int i;
83: if (string)
84: for (i=1; *string; string++, i++){
85: if (*string == ch)
86: return(i);
87: }
88: return(-1);
89: }
90: /*
91: * clobber the first occurance of ch in string by the new character
92: */
93: char *substitute(string, chold, chnew)
94: char *string;
95: char chold, chnew;
96: {
97: reg char *cp = string;
98:
99: if (cp)
100: while (*cp){
101: if (*cp == chold){
102: *cp = chnew;
103: break;
104: }
105: cp++;
106: }
107: return(string);
108: }
109:
110: char lastchar(string)
111: char *string;
112: {
113: int length;
114: if (string == 0) return('\0');
115: length = strlen(string);
116: if (length >= 1)
117: return(string[length-1]);
118: else
119: return('\0');
120: }
121:
122: char firstchar(string)
123: char *string;
124: {
125: if (string)
126: return(string[0]);
127: else
128: return('\0');
129: }
130:
131: char next_lastchar(string)
132: char *string;
133: {
134: int length;
135: if (string == 0) return('\0');
136: length = strlen(string);
137: if (length >= 2)
138: return(string[length - 2]);
139: else
140: return('\0');
141: }
142:
143: clob_last(string, newstuff)
144: char *string, newstuff;
145: {
146: int length = 0;
147: if (string)
148: length = strlen(string);
149: if (length >= 1)
150: string[length - 1] = newstuff;
151: }
152:
153: /*
154: * parse a string that is the result of a format %s(%d)
155: * return TRUE if this is of the proper format
156: */
157: boolean persperdexplode(string, r_perd, r_pers)
158: char *string;
159: char **r_perd, **r_pers;
160: {
161: reg char *cp;
162: int length = 0;
163:
164: if (string)
165: length = strlen(string);
166: if ( (length >= 4)
167: && (string[length - 1] == ')' ) ){
168: for (cp = &string[length - 2];
169: (isdigit(*cp)) && (*cp != '(');
170: --cp)
171: continue;
172: if (*cp == '('){
173: string[length - 1] = '\0'; /* clobber the ) */
174: *r_perd = strsave(cp+1);
175: string[length - 1] = ')';
176: *cp = '\0'; /* clobber the ( */
177: *r_pers = strsave(string);
178: *cp = '(';
179: return(TRUE);
180: }
181: }
182: return(FALSE);
183: }
184: /*
185: * parse a quoted string that is the result of a format \"%s\"(%d)
186: * return TRUE if this is of the proper format
187: */
188: boolean qpersperdexplode(string, r_perd, r_pers)
189: char *string;
190: char **r_perd, **r_pers;
191: {
192: reg char *cp;
193: int length = 0;
194:
195: if (string)
196: length = strlen(string);
197: if ( (length >= 4)
198: && (string[length - 1] == ')' ) ){
199: for (cp = &string[length - 2];
200: (isdigit(*cp)) && (*cp != '(');
201: --cp)
202: continue;
203: if (*cp == '(' && *(cp - 1) == '"'){
204: string[length - 1] = '\0';
205: *r_perd = strsave(cp+1);
206: string[length - 1] = ')';
207: *(cp - 1) = '\0'; /* clobber the " */
208: *r_pers = strsave(string + 1);
209: *(cp - 1) = '"';
210: return(TRUE);
211: }
212: }
213: return(FALSE);
214: }
215:
216: static char cincomment[] = CINCOMMENT;
217: static char coutcomment[] = COUTCOMMENT;
218: static char fincomment[] = FINCOMMENT;
219: static char foutcomment[] = FOUTCOMMENT;
220: static char newline[] = NEWLINE;
221: static char piincomment[] = PIINCOMMENT;
222: static char pioutcomment[] = PIOUTCOMMENT;
223: static char lispincomment[] = LISPINCOMMENT;
224: static char riincomment[] = RIINCOMMENT;
225: static char rioutcomment[] = RIOUTCOMMENT;
226: static char troffincomment[] = TROFFINCOMMENT;
227: static char troffoutcomment[] = TROFFOUTCOMMENT;
228: static char mod2incomment[] = MOD2INCOMMENT;
229: static char mod2outcomment[] = MOD2OUTCOMMENT;
230:
231: struct lang_desc lang_table[] = {
232: /*INUNKNOWN 0*/ "unknown", cincomment, coutcomment,
233: /*INCPP 1*/ "cpp", cincomment, coutcomment,
234: /*INCC 2*/ "cc", cincomment, coutcomment,
235: /*INAS 3*/ "as", ASINCOMMENT, newline,
236: /*INLD 4*/ "ld", cincomment, coutcomment,
237: /*INLINT 5*/ "lint", cincomment, coutcomment,
238: /*INF77 6*/ "f77", fincomment, foutcomment,
239: /*INPI 7*/ "pi", piincomment, pioutcomment,
240: /*INPC 8*/ "pc", piincomment, pioutcomment,
241: /*INFRANZ 9*/ "franz",lispincomment, newline,
242: /*INLISP 10*/ "lisp", lispincomment, newline,
243: /*INVAXIMA 11*/ "vaxima",lispincomment,newline,
244: /*INRATFOR 12*/ "ratfor",fincomment, foutcomment,
245: /*INLEX 13*/ "lex", cincomment, coutcomment,
246: /*INYACC 14*/ "yacc", cincomment, coutcomment,
247: /*INAPL 15*/ "apl", ".lm", newline,
248: /*INMAKE 16*/ "make", ASINCOMMENT, newline,
249: /*INRI 17*/ "ri", riincomment, rioutcomment,
250: /*INTROFF 18*/ "troff",troffincomment,troffoutcomment,
251: /*INMOD2 19*/ "mod2", mod2incomment, mod2outcomment,
252: 0, 0, 0
253: };
254:
255: printerrors(look_at_subclass, errorc, errorv)
256: boolean look_at_subclass;
257: int errorc;
258: Eptr errorv[];
259: {
260: reg int i;
261: reg Eptr errorp;
262:
263: for (errorp = errorv[i = 0]; i < errorc; errorp = errorv[++i]){
264: if (errorp->error_e_class == C_IGNORE)
265: continue;
266: if (look_at_subclass && errorp->error_s_class == C_DUPL)
267: continue;
268: printf("Error %d, (%s error) [%s], text = \"",
269: i,
270: class_table[errorp->error_e_class],
271: lang_table[errorp->error_language].lang_name);
272: wordvprint(stdout,errorp->error_lgtext,errorp->error_text);
273: printf("\"\n");
274: }
275: }
276:
277: wordvprint(fyle, wordc, wordv)
278: FILE *fyle;
279: int wordc;
280: char *wordv[];
281: {
282: int i;
283: char *sep = "";
284:
285: for(i = 0; i < wordc; i++)
286: if (wordv[i]) {
287: fprintf(fyle, "%s%s",sep,wordv[i]);
288: sep = " ";
289: }
290: }
291:
292: /*
293: * Given a string, parse it into a number of words, and build
294: * a wordc wordv combination pointing into it.
295: */
296: wordvbuild(string, r_wordc, r_wordv)
297: char *string;
298: int *r_wordc;
299: char ***r_wordv;
300: {
301: reg char *cp;
302: char *saltedbuffer;
303: char **wordv;
304: int wordcount;
305: int wordindex;
306:
307: saltedbuffer = strsave(string);
308: for (wordcount = 0, cp = saltedbuffer; *cp; wordcount++){
309: while (*cp && isspace(*cp))
310: cp++;
311: if (*cp == 0)
312: break;
313: while (!isspace(*cp))
314: cp++;
315: }
316: wordv = (char **)Calloc(wordcount + 1, sizeof (char *));
317: for (cp=saltedbuffer,wordindex=0; wordcount; wordindex++,--wordcount){
318: while (*cp && isspace(*cp))
319: cp++;
320: if (*cp == 0)
321: break;
322: wordv[wordindex] = cp;
323: while(!isspace(*cp))
324: cp++;
325: *cp++ = '\0';
326: }
327: if (wordcount != 0)
328: error("Initial miscount of the number of words in a line\n");
329: wordv[wordindex] = (char *)0;
330: #ifdef FULLDEBUG
331: for (wordcount = 0; wordcount < wordindex; wordcount++)
332: printf("Word %d = \"%s\"\n", wordcount, wordv[wordcount]);
333: printf("\n");
334: #endif
335: *r_wordc = wordindex;
336: *r_wordv = wordv;
337: }
338: /*
339: * Compare two 0 based wordvectors
340: */
341: int wordvcmp(wordv1, wordc, wordv2)
342: char **wordv1;
343: int wordc;
344: char **wordv2;
345: {
346: reg int i;
347: int back;
348: for (i = 0; i < wordc; i++){
349: if (wordv1[i] == 0 || wordv2[i] == 0)
350: return(-1);
351: if (back = strcmp(wordv1[i], wordv2[i])){
352: return(back);
353: }
354: }
355: return(0); /* they are equal */
356: }
357:
358: /*
359: * splice a 0 basedword vector onto the tail of a
360: * new wordv, allowing the first emptyhead slots to be empty
361: */
362: char **wordvsplice(emptyhead, wordc, wordv)
363: int emptyhead;
364: int wordc;
365: char **wordv;
366: {
367: reg char **nwordv;
368: int nwordc = emptyhead + wordc;
369: reg int i;
370:
371: nwordv = (char **)Calloc(nwordc, sizeof (char *));
372: for (i = 0; i < emptyhead; i++)
373: nwordv[i] = 0;
374: for(i = emptyhead; i < nwordc; i++){
375: nwordv[i] = wordv[i-emptyhead];
376: }
377: return(nwordv);
378: }
379: /*
380: * plural'ize and verb forms
381: */
382: static char *S = "s";
383: static char *N = "";
384: char *plural(n)
385: int n;
386: {
387: return( n > 1 ? S : N);
388: }
389: char *verbform(n)
390: int n;
391: {
392: return( n > 1 ? N : S);
393: }
394:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.