![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to errortouch.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 errortouch.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[] = "@(#)errortouch.c 5.1 (Berkeley) 5/31/85";
9: #endif not lint
10:
11: #include <stdio.h>
12: #include <ctype.h>
13: #include <sys/types.h>
14: #include <sys/stat.h>
15: #include <signal.h>
16: #include "error.h"
17:
18: /*
19: * Iterate through errors
20: */
21: #define EITERATE(p, fv, i) for (p = fv[i]; p < fv[i+1]; p++)
22: #define ECITERATE(ei, p, lb) for (ei = lb; p = errors[ei],ei < nerrors; ei++)
23:
24: #define FILEITERATE(fi, lb) for (fi = lb; fi <= nfiles; fi++)
25: int touchstatus = Q_YES;
26:
27: findfiles(nerrors, errors, r_nfiles, r_files)
28: int nerrors;
29: Eptr *errors;
30: int *r_nfiles;
31: Eptr ***r_files;
32: {
33: int nfiles;
34: Eptr **files;
35:
36: char *name;
37: reg int ei;
38: int fi;
39: reg Eptr errorp;
40:
41: nfiles = countfiles(errors);
42:
43: files = (Eptr**)Calloc(nfiles + 3, sizeof (Eptr*));
44: touchedfiles = (boolean *)Calloc(nfiles+3, sizeof(boolean));
45: /*
46: * Now, partition off the error messages
47: * into those that are synchronization, discarded or
48: * not specific to any file, and those that were
49: * nulled or true errors.
50: */
51: files[0] = &errors[0];
52: ECITERATE(ei, errorp, 0){
53: if ( ! (NOTSORTABLE(errorp->error_e_class)))
54: break;
55: }
56: /*
57: * Now, and partition off all error messages
58: * for a given file.
59: */
60: files[1] = &errors[ei];
61: touchedfiles[0] = touchedfiles[1] = FALSE;
62: name = "\1";
63: fi = 1;
64: ECITERATE(ei, errorp, ei){
65: if ( (errorp->error_e_class == C_NULLED)
66: || (errorp->error_e_class == C_TRUE) ){
67: if (strcmp(errorp->error_text[0], name) != 0){
68: name = errorp->error_text[0];
69: touchedfiles[fi] = FALSE;
70: files[fi] = &errors[ei];
71: fi++;
72: }
73: }
74: }
75: files[fi] = &errors[nerrors];
76: *r_nfiles = nfiles;
77: *r_files = files;
78: }
79:
80: int countfiles(errors)
81: Eptr *errors;
82: {
83: char *name;
84: int ei;
85: reg Eptr errorp;
86:
87: int nfiles;
88: nfiles = 0;
89: name = "\1";
90: ECITERATE(ei, errorp, 0){
91: if (SORTABLE(errorp->error_e_class)){
92: if (strcmp(errorp->error_text[0],name) != 0){
93: nfiles++;
94: name = errorp->error_text[0];
95: }
96: }
97: }
98: return(nfiles);
99: }
100: char *class_table[] = {
101: /*C_UNKNOWN 0 */ "Unknown",
102: /*C_IGNORE 1 */ "ignore",
103: /*C_SYNC 2 */ "synchronization",
104: /*C_DISCARD 3 */ "discarded",
105: /*C_NONSPEC 4 */ "non specific",
106: /*C_THISFILE 5 */ "specific to this file",
107: /*C_NULLED 6 */ "nulled",
108: /*C_TRUE 7 */ "true",
109: /*C_DUPL 8 */ "duplicated"
110: };
111:
112: int class_count[C_LAST - C_FIRST] = {0};
113:
114: filenames(nfiles, files)
115: int nfiles;
116: Eptr **files;
117: {
118: reg int fi;
119: char *sep = " ";
120: extern char *class_table[];
121: int someerrors;
122:
123: /*
124: * first, simply dump out errors that
125: * don't pertain to any file
126: */
127: someerrors = nopertain(files);
128:
129: if (nfiles){
130: someerrors++;
131: fprintf(stdout, terse
132: ? "%d file%s"
133: : "%d file%s contain%s errors",
134: nfiles, plural(nfiles), verbform(nfiles));
135: if (!terse){
136: FILEITERATE(fi, 1){
137: fprintf(stdout, "%s\"%s\" (%d)",
138: sep, (*files[fi])->error_text[0],
139: files[fi+1] - files[fi]);
140: sep = ", ";
141: }
142: }
143: fprintf(stdout, "\n");
144: }
145: if (!someerrors)
146: fprintf(stdout, "No errors.\n");
147: }
148:
149: /*
150: * Dump out errors that don't pertain to any file
151: */
152: int nopertain(files)
153: Eptr **files;
154: {
155: int type;
156: int someerrors = 0;
157: reg Eptr *erpp;
158: reg Eptr errorp;
159:
160: if (files[1] - files[0] <= 0)
161: return(0);
162: for(type = C_UNKNOWN; NOTSORTABLE(type); type++){
163: if (class_count[type] <= 0)
164: continue;
165: if (type > C_SYNC)
166: someerrors++;
167: if (terse){
168: fprintf(stdout, "\t%d %s errors NOT PRINTED\n",
169: class_count[type], class_table[type]);
170: } else {
171: fprintf(stdout, "\n\t%d %s errors follow\n",
172: class_count[type], class_table[type]);
173: EITERATE(erpp, files, 0){
174: errorp = *erpp;
175: if (errorp->error_e_class == type){
176: errorprint(stdout, errorp, TRUE);
177: }
178: }
179: }
180: }
181: return(someerrors);
182: }
183:
184: extern boolean notouch;
185:
186: boolean touchfiles(nfiles, files, r_edargc, r_edargv)
187: int nfiles;
188: Eptr **files;
189: int *r_edargc;
190: char ***r_edargv;
191: {
192: char *name;
193: reg Eptr errorp;
194: reg int fi;
195: reg Eptr *erpp;
196: int ntrueerrors;
197: boolean scribbled;
198: int n_pissed_on; /* # of file touched*/
199: int spread;
200:
201: FILEITERATE(fi, 1){
202: name = (*files[fi])->error_text[0];
203: spread = files[fi+1] - files[fi];
204: fprintf(stdout, terse
205: ? "\"%s\" has %d error%s, "
206: : "\nFile \"%s\" has %d error%s.\n"
207: , name ,spread ,plural(spread));
208: /*
209: * First, iterate through all error messages in this file
210: * to see how many of the error messages really will
211: * get inserted into the file.
212: */
213: ntrueerrors = 0;
214: EITERATE(erpp, files, fi){
215: errorp = *erpp;
216: if (errorp->error_e_class == C_TRUE)
217: ntrueerrors++;
218: }
219: fprintf(stdout, terse
220: ? "insert %d\n"
221: : "\t%d of these errors can be inserted into the file.\n",
222: ntrueerrors);
223:
224: hackfile(name, files, fi, ntrueerrors);
225: }
226: scribbled = FALSE;
227: n_pissed_on = 0;
228: FILEITERATE(fi, 1){
229: scribbled |= touchedfiles[fi];
230: n_pissed_on++;
231: }
232: if (scribbled){
233: /*
234: * Construct an execv argument
235: */
236: execvarg(n_pissed_on, r_edargc, r_edargv);
237: return(TRUE);
238: } else {
239: if (!terse)
240: fprintf(stdout, "You didn't touch any files.\n");
241: return(FALSE);
242: }
243: }
244:
245: hackfile(name, files, ix, nerrors)
246: char *name;
247: Eptr **files;
248: int ix;
249: {
250: boolean previewed;
251: int errordest; /* where errors go*/
252:
253: if (!oktotouch(name)) {
254: previewed = FALSE;
255: errordest = TOSTDOUT;
256: } else {
257: previewed = preview(name, nerrors, files, ix);
258: errordest = settotouch(name);
259: }
260:
261: if (errordest != TOSTDOUT)
262: touchedfiles[ix] = TRUE;
263:
264: if (previewed && (errordest == TOSTDOUT))
265: return;
266:
267: diverterrors(name, errordest, files, ix, previewed, nerrors);
268:
269: if (errordest == TOTHEFILE){
270: /*
271: * overwrite the original file
272: */
273: writetouched(1);
274: }
275: }
276:
277: boolean preview(name, nerrors, files, ix)
278: char *name;
279: int nerrors;
280: Eptr **files;
281: int ix;
282: {
283: int back;
284: reg Eptr *erpp;
285:
286: if (nerrors <= 0)
287: return(FALSE);
288: back = FALSE;
289: if(query){
290: switch(inquire(terse
291: ? "Preview? "
292: : "Do you want to preview the errors first? ")){
293: case Q_YES:
294: case Q_yes:
295: back = TRUE;
296: EITERATE(erpp, files, ix){
297: errorprint(stdout, *erpp, TRUE);
298: }
299: if (!terse)
300: fprintf(stdout, "\n");
301: default:
302: break;
303: }
304: }
305: return(back);
306: }
307:
308: int settotouch(name)
309: char *name;
310: {
311: int dest = TOSTDOUT;
312:
313: if (query){
314: switch(touchstatus = inquire(terse
315: ? "Touch? "
316: : "Do you want to touch file \"%s\"? ",
317: name)){
318: case Q_NO:
319: case Q_no:
320: return(dest);
321: default:
322: break;
323: }
324: }
325:
326: switch(probethisfile(name)){
327: case F_NOTREAD:
328: dest = TOSTDOUT;
329: fprintf(stdout, terse
330: ? "\"%s\" unreadable\n"
331: : "File \"%s\" is unreadable\n",
332: name);
333: break;
334: case F_NOTWRITE:
335: dest = TOSTDOUT;
336: fprintf(stdout, terse
337: ? "\"%s\" unwritable\n"
338: : "File \"%s\" is unwritable\n",
339: name);
340: break;
341: case F_NOTEXIST:
342: dest = TOSTDOUT;
343: fprintf(stdout, terse
344: ? "\"%s\" not found\n"
345: : "Can't find file \"%s\" to insert error messages into.\n",
346: name);
347: break;
348: default:
349: dest = edit(name) ? TOSTDOUT : TOTHEFILE;
350: break;
351: }
352: return(dest);
353: }
354:
355: diverterrors(name, dest, files, ix, previewed, nterrors)
356: char *name;
357: int dest;
358: Eptr **files;
359: int ix;
360: boolean previewed;
361: int nterrors;
362: {
363: int nerrors;
364: reg Eptr *erpp;
365: reg Eptr errorp;
366:
367: nerrors = files[ix+1] - files[ix];
368:
369: if ( (nerrors != nterrors)
370: && (!previewed) ){
371: fprintf(stdout, terse
372: ? "Uninserted errors\n"
373: : ">>Uninserted errors for file \"%s\" follow.\n",
374: name);
375: }
376:
377: EITERATE(erpp, files, ix){
378: errorp = *erpp;
379: if (errorp->error_e_class != C_TRUE){
380: if (previewed || touchstatus == Q_NO)
381: continue;
382: errorprint(stdout, errorp, TRUE);
383: continue;
384: }
385: switch (dest){
386: case TOSTDOUT:
387: if (previewed || touchstatus == Q_NO)
388: continue;
389: errorprint(stdout,errorp, TRUE);
390: break;
391: case TOTHEFILE:
392: insert(errorp->error_line);
393: text(errorp, FALSE);
394: break;
395: }
396: }
397: }
398:
399: int oktotouch(filename)
400: char *filename;
401: {
402: extern char *suffixlist;
403: reg char *src;
404: reg char *pat;
405: char *osrc;
406:
407: pat = suffixlist;
408: if (pat == 0)
409: return(0);
410: if (*pat == '*')
411: return(1);
412: while (*pat++ != '.')
413: continue;
414: --pat; /* point to the period */
415:
416: for (src = &filename[strlen(filename)], --src;
417: (src > filename) && (*src != '.'); --src)
418: continue;
419: if (*src != '.')
420: return(0);
421:
422: for (src++, pat++, osrc = src; *src && *pat; src = osrc, pat++){
423: for (; *src /* not at end of the source */
424: && *pat /* not off end of pattern */
425: && *pat != '.' /* not off end of sub pattern */
426: && *pat != '*' /* not wild card */
427: && *src == *pat; /* and equal... */
428: src++, pat++)
429: continue;
430: if (*src == 0 && (*pat == 0 || *pat == '.' || *pat == '*'))
431: return(1);
432: if (*src != 0 && *pat == '*')
433: return(1);
434: while (*pat && *pat != '.')
435: pat++;
436: if (! *pat)
437: return(0);
438: }
439: return(0);
440: }
441: /*
442: * Construct an execv argument
443: * We need 1 argument for the editor's name
444: * We need 1 argument for the initial search string
445: * We need n_pissed_on arguments for the file names
446: * We need 1 argument that is a null for execv.
447: * The caller fills in the editor's name.
448: * We fill in the initial search string.
449: * We fill in the arguments, and the null.
450: */
451: execvarg(n_pissed_on, r_argc, r_argv)
452: int n_pissed_on;
453: int *r_argc;
454: char ***r_argv;
455: {
456: Eptr p;
457: char *sep;
458: int fi;
459:
460: (*r_argv) = (char **)Calloc(n_pissed_on + 3, sizeof(char *));
461: (*r_argc) = n_pissed_on + 2;
462: (*r_argv)[1] = "+1;/###/";
463: n_pissed_on = 2;
464: if (!terse){
465: fprintf(stdout, "You touched file(s):");
466: sep = " ";
467: }
468: FILEITERATE(fi, 1){
469: if (!touchedfiles[fi])
470: continue;
471: p = *(files[fi]);
472: if (!terse){
473: fprintf(stdout,"%s\"%s\"", sep, p->error_text[0]);
474: sep = ", ";
475: }
476: (*r_argv)[n_pissed_on++] = p->error_text[0];
477: }
478: if (!terse)
479: fprintf(stdout, "\n");
480: (*r_argv)[n_pissed_on] = 0;
481: }
482:
483: FILE *o_touchedfile; /* the old file */
484: FILE *n_touchedfile; /* the new file */
485: char *o_name;
486: char n_name[64];
487: char *canon_name = "/tmp/ErrorXXXXXX";
488: int o_lineno;
489: int n_lineno;
490: boolean tempfileopen = FALSE;
491: /*
492: * open the file; guaranteed to be both readable and writable
493: * Well, if it isn't, then return TRUE if something failed
494: */
495: boolean edit(name)
496: char *name;
497: {
498: o_name = name;
499: if ( (o_touchedfile = fopen(name, "r")) == NULL){
500: fprintf(stderr, "%s: Can't open file \"%s\" to touch (read).\n",
501: processname, name);
502: return(TRUE);
503: }
504: (void)strcpy(n_name, canon_name);
505: (void)mktemp(n_name);
506: if ( (n_touchedfile = fopen(n_name, "w")) == NULL){
507: fprintf(stderr,"%s: Can't open file \"%s\" to touch (write).\n",
508: processname, name);
509: return(TRUE);
510: }
511: tempfileopen = TRUE;
512: n_lineno = 0;
513: o_lineno = 0;
514: return(FALSE);
515: }
516: /*
517: * Position to the line (before, after) the line given by place
518: */
519: char edbuf[BUFSIZ];
520: insert(place)
521: int place;
522: {
523: --place; /* always insert messages before the offending line*/
524: for(; o_lineno < place; o_lineno++, n_lineno++){
525: if(fgets(edbuf, BUFSIZ, o_touchedfile) == NULL)
526: return;
527: fputs(edbuf, n_touchedfile);
528: }
529: }
530:
531: text(p, use_all)
532: reg Eptr p;
533: boolean use_all;
534: {
535: int offset = use_all ? 0 : 2;
536:
537: fputs(lang_table[p->error_language].lang_incomment, n_touchedfile);
538: fprintf(n_touchedfile, "%d [%s] ",
539: p->error_line,
540: lang_table[p->error_language].lang_name);
541: wordvprint(n_touchedfile, p->error_lgtext-offset, p->error_text+offset);
542: fputs(lang_table[p->error_language].lang_outcomment,n_touchedfile);
543: n_lineno++;
544: }
545:
546: /*
547: * write the touched file to its temporary copy,
548: * then bring the temporary in over the local file
549: */
550: writetouched(overwrite)
551: int overwrite;
552: {
553: reg int nread;
554: reg FILE *localfile;
555: reg FILE *tmpfile;
556: int botch;
557: int oktorm;
558:
559: botch = 0;
560: oktorm = 1;
561: while((nread = fread(edbuf, 1, sizeof(edbuf), o_touchedfile)) != NULL){
562: if (nread != fwrite(edbuf, 1, nread, n_touchedfile)){
563: /*
564: * Catastrophe in temporary area: file system full?
565: */
566: botch = 1;
567: fprintf(stderr,
568: "%s: write failure: No errors inserted in \"%s\"\n",
569: processname, o_name);
570: }
571: }
572: fclose(n_touchedfile);
573: fclose(o_touchedfile);
574: /*
575: * Now, copy the temp file back over the original
576: * file, thus preserving links, etc
577: */
578: if (botch == 0 && overwrite){
579: botch = 0;
580: localfile = NULL;
581: tmpfile = NULL;
582: if ((localfile = fopen(o_name, "w")) == NULL){
583: fprintf(stderr,
584: "%s: Can't open file \"%s\" to overwrite.\n",
585: processname, o_name);
586: botch++;
587: }
588: if ((tmpfile = fopen(n_name, "r")) == NULL){
589: fprintf(stderr, "%s: Can't open file \"%s\" to read.\n",
590: processname, n_name);
591: botch++;
592: }
593: if (!botch)
594: oktorm = mustoverwrite(localfile, tmpfile);
595: if (localfile != NULL)
596: fclose(localfile);
597: if (tmpfile != NULL)
598: fclose(tmpfile);
599: }
600: if (oktorm == 0){
601: fprintf(stderr, "%s: Catastrophe: A copy of \"%s\: was saved in \"%s\"\n",
602: processname, o_name, n_name);
603: exit(1);
604: }
605: /*
606: * Kiss the temp file good bye
607: */
608: unlink(n_name);
609: tempfileopen = FALSE;
610: return(TRUE);
611: }
612: /*
613: * return 1 if the tmpfile can be removed after writing it out
614: */
615: int mustoverwrite(preciousfile, tmpfile)
616: FILE *preciousfile;
617: FILE *tmpfile;
618: {
619: int nread;
620:
621: while((nread = fread(edbuf, 1, sizeof(edbuf), tmpfile)) != NULL){
622: if (mustwrite(edbuf, nread, preciousfile) == 0)
623: return(0);
624: }
625: return(1);
626: }
627: /*
628: * return 0 on catastrophe
629: */
630: mustwrite(base, n, preciousfile)
631: char *base;
632: int n;
633: FILE *preciousfile;
634: {
635: int nwrote;
636:
637: if (n <= 0)
638: return(1);
639: nwrote = fwrite(base, 1, n, preciousfile);
640: if (nwrote == n)
641: return(1);
642: perror(processname);
643: switch(inquire(terse
644: ? "Botch overwriting: retry? "
645: : "Botch overwriting the source file: retry? ")){
646: case Q_YES:
647: case Q_yes:
648: mustwrite(base + nwrote, n - nwrote, preciousfile);
649: return(1);
650: case Q_NO:
651: case Q_no:
652: switch(inquire("Are you sure? ")){
653: case Q_YES:
654: case Q_yes:
655: return(0);
656: case Q_NO:
657: case Q_no:
658: mustwrite(base + nwrote, n - nwrote, preciousfile);
659: return(1);
660: }
661: default:
662: return(0);
663: }
664: }
665:
666: onintr()
667: {
668: switch(inquire(terse
669: ? "\nContinue? "
670: : "\nInterrupt: Do you want to continue? ")){
671: case Q_YES:
672: case Q_yes:
673: signal(SIGINT, onintr);
674: return;
675: default:
676: if (tempfileopen){
677: /*
678: * Don't overwrite the original file!
679: */
680: writetouched(0);
681: }
682: exit(1);
683: }
684: /*NOTREACHED*/
685: }
686:
687: errorprint(place, errorp, print_all)
688: FILE *place;
689: Eptr errorp;
690: boolean print_all;
691: {
692: int offset = print_all ? 0 : 2;
693:
694: if (errorp->error_e_class == C_IGNORE)
695: return;
696: fprintf(place, "[%s] ", lang_table[errorp->error_language].lang_name);
697: wordvprint(place,errorp->error_lgtext-offset,errorp->error_text+offset);
698: putc('\n', place);
699: }
700:
701: int inquire(fmt, a1, a2)
702: char *fmt;
703: /*VARARGS1*/
704: {
705: char buffer[128];
706:
707: if (queryfile == NULL)
708: return(0);
709: for(;;){
710: do{
711: fflush(stdout);
712: fprintf(stderr, fmt, a1, a2);
713: fflush(stderr);
714: } while (fgets(buffer, 127, queryfile) == NULL);
715: switch(buffer[0]){
716: case 'Y': return(Q_YES);
717: case 'y': return(Q_yes);
718: case 'N': return(Q_NO);
719: case 'n': return(Q_no);
720: default: fprintf(stderr, "Yes or No only!\n");
721: }
722: }
723: }
724:
725: int probethisfile(name)
726: char *name;
727: {
728: struct stat statbuf;
729: if (stat(name, &statbuf) < 0)
730: return(F_NOTEXIST);
731: if((statbuf.st_mode & S_IREAD) == 0)
732: return(F_NOTREAD);
733: if((statbuf.st_mode & S_IWRITE) == 0)
734: return(F_NOTWRITE);
735: return(F_TOUCHIT);
736: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.