![[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 [Research Unix] / researchv10no / cmd / error|
Return to errortouch.c CVS log | Up to [Research Unix] / researchv10no / cmd / error |
1.1 ! root 1: static char *sccsid = "@(#)errortouch.c 1.2 (Berkeley) 10/16/80"; ! 2: #include <stdio.h> ! 3: #include <ctype.h> ! 4: #include <sys/types.h> ! 5: #include <sys/stat.h> ! 6: #include <signal.h> ! 7: #include "error.h" ! 8: ! 9: findfiles(nerrors, errors, r_nfiles, r_files) ! 10: int nerrors; ! 11: struct error_desc **errors; ! 12: int *r_nfiles; ! 13: struct error_desc ****r_files; ! 14: { ! 15: int nfiles; ! 16: struct error_desc ***files; ! 17: ! 18: char *currentfilename; ! 19: register int errorindex; ! 20: int fileindex; ! 21: register struct error_desc *errorp; ! 22: /* ! 23: * First, go through and count all of the filenames ! 24: */ ! 25: for (errorp = errors[errorindex = 0],nfiles = 0, currentfilename = "\1"; ! 26: errorindex < nerrors; ! 27: errorp = errors[++errorindex]){ ! 28: if (SORTABLE(errorp->error_e_class)){ ! 29: if (strcmp(errorp->error_text[0],currentfilename) != 0){ ! 30: nfiles++; ! 31: currentfilename = errorp->error_text[0]; ! 32: } ! 33: } ! 34: } ! 35: files = (struct error_desc ***)Calloc(nfiles + 3, ! 36: sizeof (struct error_desc**)); ! 37: touchedfiles = (boolean *)Calloc(nfiles+3, sizeof(boolean)); ! 38: /* ! 39: * Now, go through and partition off the error messages ! 40: * into those that are synchronization, discarded or ! 41: * not specific to any file, and those that were ! 42: * nulled or true errors. ! 43: */ ! 44: files[0] = &errors[0]; ! 45: for (errorp = errors[errorindex = 0], fileindex = 0; ! 46: (errorindex < nerrors) && ! 47: (NOTSORTABLE(errorp->error_e_class)); ! 48: errorp = errors[++errorindex]){ ! 49: continue; ! 50: } ! 51: /* ! 52: * Now, go through and partition off all error messages ! 53: * for a given file. ! 54: */ ! 55: files[1] = &errors[errorindex]; ! 56: touchedfiles[0] = touchedfiles[1] = FALSE; ! 57: for (errorp = errors[errorindex], currentfilename = "\1", fileindex = 1; ! 58: errorindex < nerrors; errorp = errors[++errorindex]){ ! 59: if ( (errorp->error_e_class == C_NULLED) || (errorp->error_e_class == C_TRUE) ){ ! 60: if (strcmp(errorp->error_text[0],currentfilename) != 0){ ! 61: currentfilename = errorp->error_text[0]; ! 62: touchedfiles[fileindex] = FALSE; ! 63: files[fileindex++] = &errors[errorindex]; ! 64: } ! 65: } ! 66: } ! 67: files[fileindex] = &errors[nerrors]; ! 68: *r_nfiles = nfiles; ! 69: *r_files = files; ! 70: } ! 71: ! 72: char *class_table[] = { ! 73: /*C_UNKNOWN 0 */ "Unknown", ! 74: /*C_IGNORE 1 */ "ignore", ! 75: /*C_SYNC 2 */ "synchronization", ! 76: /*C_DISCARD 3 */ "discarded", ! 77: /*C_NONSPEC 4 */ "non specific", ! 78: /*C_THISFILE 5 */ "specific to this file", ! 79: /*C_NULLED 6 */ "nulled", ! 80: /*C_TRUE 7 */ "true", ! 81: /*C_DUPL 8 */ "duplicated" ! 82: }; ! 83: ! 84: int class_count[C_LAST - C_FIRST] = {0}; ! 85: ! 86: filenames(nfiles, files) ! 87: int nfiles; ! 88: struct error_desc ***files; ! 89: { ! 90: register int fileindex; ! 91: register struct error_desc *errorp; ! 92: register struct error_desc **erpp; ! 93: char *sep = " "; ! 94: register int errortype; ! 95: extern char *class_table[]; ! 96: int someerrors = 0; ! 97: ! 98: /* ! 99: * first, go through and simply dump out errors that ! 100: * don't pertain to any file ! 101: */ ! 102: if (files[1] - files[0] > 0){ ! 103: for(errortype = C_UNKNOWN; NOTSORTABLE(errortype); errortype++){ ! 104: if (class_count[errortype] > 0){ ! 105: if (errortype > C_SYNC) ! 106: someerrors++; ! 107: fprintf(stdout, "\n\t%d %s errors follow:\n", ! 108: class_count[errortype], class_table[errortype]); ! 109: for (errorp = *(erpp = files[0]); ! 110: erpp < files[1]; ! 111: errorp = (*++erpp)){ ! 112: if (errorp->error_e_class == errortype) ! 113: errorprint(stdout, errorp, TRUE); ! 114: } ! 115: } ! 116: } ! 117: } ! 118: if (nfiles){ ! 119: someerrors++; ! 120: fprintf(stdout, "%d files contain errors:", nfiles); ! 121: for (fileindex = 1; fileindex <= nfiles; fileindex++){ ! 122: fprintf(stdout, "%s\"%s\" (%d)", ! 123: sep, (*files[fileindex])->error_text[0], ! 124: files[fileindex+1] - files[fileindex]); ! 125: sep = ", "; ! 126: } ! 127: fprintf(stdout, "\n"); ! 128: } ! 129: if (!someerrors) ! 130: fprintf(stdout, "No errors.\n"); ! 131: } ! 132: ! 133: extern boolean notouch; ! 134: ! 135: boolean touchfiles(nfiles, files, r_edargc, r_edargv) ! 136: int nfiles; ! 137: struct error_desc ***files; ! 138: int *r_edargc; ! 139: char ***r_edargv; ! 140: { ! 141: char *currentfilename; ! 142: register struct error_desc *errorp; ! 143: register int fileindex; ! 144: register struct error_desc **erpp; ! 145: int ntrueerrors; ! 146: int errordest; /* where errors go*/ ! 147: char *sep; ! 148: boolean scribbled; ! 149: int n_pissed_on; /* # of file touched*/ ! 150: int previewed; ! 151: ! 152: for (fileindex = 1; fileindex <= nfiles; fileindex++){ ! 153: fprintf(stdout, "\nFile \"%s\" has %d total error messages.\n", ! 154: currentfilename = (*files[fileindex])->error_text[0], ! 155: files[fileindex+1] - files[fileindex]); ! 156: /* ! 157: * First, iterate through all error messages in this file ! 158: * to see how many of the error messages really will ! 159: * get inserted into the file. ! 160: */ ! 161: for (erpp = files[fileindex], ntrueerrors = 0; ! 162: erpp < files[fileindex+1]; ! 163: erpp++){ ! 164: errorp = *erpp; ! 165: if (errorp->error_e_class == C_TRUE) ! 166: ntrueerrors++; ! 167: } ! 168: fprintf(stdout,"\t%d of these errors can be inserted into the file.\n", ! 169: ntrueerrors); ! 170: ! 171: /* ! 172: * What does the operator want? ! 173: */ ! 174: previewed = 0; ! 175: errordest = TOSTDOUT; ! 176: if (oktotouch(currentfilename) && (ntrueerrors > 0) ){ ! 177: if (query && inquire("Do you want to preview the errors first?")){ ! 178: previewed = 1; ! 179: for (erpp = files[fileindex]; ! 180: erpp < files[fileindex + 1]; ! 181: erpp++){ ! 182: errorprint(stdout, *erpp, TRUE); ! 183: } ! 184: fprintf(stdout, "\n"); ! 185: } ! 186: if ( !query ! 187: || inquire("Do you want to touch file \"%s\"? ", ! 188: currentfilename) ! 189: ){ ! 190: errordest = TOTHEFILE; ! 191: if (!probethisfile(currentfilename)){ ! 192: errordest = TOSTDOUT; ! 193: fprintf(stdout, ! 194: "Can't find file \"%s\" to insert error messages into.\n", ! 195: currentfilename); ! 196: } else { ! 197: if (edit(currentfilename)) ! 198: errordest = TOSTDOUT; ! 199: else ! 200: touchedfiles[fileindex] = TRUE; ! 201: } ! 202: } ! 203: } ! 204: if (previewed && (errordest == TOSTDOUT)) ! 205: continue; /* with the next file */ ! 206: /* ! 207: * go through and print each error message, ! 208: * diverting to the right place ! 209: */ ! 210: if ( (files[fileindex+1] - files[fileindex]) != ntrueerrors) ! 211: if (!previewed) fprintf(stdout, ! 212: ">>Uninserted error messages for file \"%s\" follow.\n", ! 213: currentfilename); ! 214: for (erpp = files[fileindex];erpp < files[fileindex+1];erpp++){ ! 215: errorp = *erpp; ! 216: if (errorp->error_e_class == C_TRUE){ ! 217: switch (errordest){ ! 218: case TOSTDOUT: ! 219: if (!previewed) ! 220: errorprint(stdout,errorp, TRUE); ! 221: break; ! 222: case TOTHEFILE: ! 223: insert(errorp->error_line); ! 224: text(errorp, FALSE); ! 225: break; ! 226: } /* switch */ ! 227: } else { ! 228: if (!previewed) ! 229: errorprint(stdout, errorp, TRUE); ! 230: } ! 231: } /* end of walking through all errors*/ ! 232: if (errordest == TOTHEFILE){ ! 233: writetouched(); ! 234: } ! 235: } /* end of walking through all files*/ ! 236: scribbled = FALSE; ! 237: for (n_pissed_on = 0, fileindex = 1; fileindex <= nfiles; fileindex++){ ! 238: scribbled |= touchedfiles[fileindex]; ! 239: n_pissed_on++; ! 240: } ! 241: if (scribbled){ ! 242: /* ! 243: * Construct an execv argument ! 244: * We need 1 argument for the editor's name ! 245: * We need 1 argument for the initial search string ! 246: * We need n_pissed_on arguments for the file names ! 247: * We need 1 argument that is a null for execv. ! 248: * The caller fills in the editor's name. ! 249: * We fill in the initial search string. ! 250: * We fill in the arguments, and the null. ! 251: */ ! 252: (*r_edargv) = (char **)Calloc(n_pissed_on + 3, sizeof(char *)); ! 253: (*r_edargc) = n_pissed_on + 2; ! 254: (*r_edargv)[1] = "+/###/"; ! 255: n_pissed_on = 2; ! 256: fprintf(stdout, "You touched file(s):"); ! 257: sep = " "; ! 258: for (fileindex = 1; fileindex <= nfiles; fileindex++){ ! 259: if (!touchedfiles[fileindex]) ! 260: continue; ! 261: errorp = *(files[fileindex]); ! 262: fprintf(stdout,"%s\"%s\"", sep, errorp->error_text[0]); ! 263: sep = ", "; ! 264: (*r_edargv)[n_pissed_on++] = errorp->error_text[0]; ! 265: } ! 266: fprintf(stdout, "\n"); ! 267: (*r_edargv)[n_pissed_on] = 0; ! 268: return(TRUE); ! 269: } else { ! 270: fprintf(stdout, "You didn't touch any files.\n"); ! 271: return(FALSE); ! 272: } ! 273: ! 274: } /* end of touchfiles*/ ! 275: int oktotouch(filename) ! 276: char *filename; ! 277: { ! 278: extern char *suffixlist; ! 279: register char *src; ! 280: register char *pat; ! 281: char *osrc; ! 282: ! 283: pat = suffixlist; ! 284: if (pat == 0) ! 285: return(0); ! 286: if (*pat == '*') ! 287: return(1); ! 288: while (*pat++ != '.') ! 289: continue; ! 290: --pat; /* point to the period */ ! 291: ! 292: for (src = &filename[strlen(filename)], --src; ! 293: (src > filename) && (*src != '.'); --src) ! 294: continue; ! 295: if (*src != '.') ! 296: return(0); ! 297: ! 298: for (src++, pat++, osrc = src; *src && *pat; src = osrc, pat++){ ! 299: for (; *src /* not at end of the source */ ! 300: && *pat /* not off end of pattern */ ! 301: && *pat != '.' /* not off end of sub pattern */ ! 302: && *pat != '*' /* not wild card */ ! 303: && *src == *pat; /* and equal... */ ! 304: src++, pat++) ! 305: continue; ! 306: if (*src == 0 && (*pat == 0 || *pat == '.' || *pat == '*')) ! 307: return(1); ! 308: if (*src != 0 && *pat == '*') ! 309: return(1); ! 310: while (*pat && *pat != '.') ! 311: pat++; ! 312: if (! *pat) ! 313: return(0); ! 314: } ! 315: return(0); ! 316: } ! 317: ! 318: FILE *o_touchedfile; /* the old file */ ! 319: FILE *n_touchedfile; /* the new file */ ! 320: char *o_name; ! 321: char n_name[32]; ! 322: char *canon_name = "ErrorXXXXXX"; ! 323: int o_lineno; ! 324: int n_lineno; ! 325: boolean tempfileopen = FALSE; ! 326: /* ! 327: * open the file; guaranteed to be both readable and writable ! 328: * Well, if it isn't, then return TRUE if something failed ! 329: */ ! 330: boolean edit(name) ! 331: char *name; ! 332: { ! 333: o_name = name; ! 334: if ( (o_touchedfile = fopen(name, "r")) == NULL){ ! 335: fprintf(stderr, "%s: Can't open file \"%s\" to touch (read).\n", ! 336: processname, name); ! 337: return(TRUE); ! 338: } ! 339: strcpy(n_name, canon_name); ! 340: mktemp(n_name); ! 341: if ( (n_touchedfile = fopen(n_name, "w")) == NULL){ ! 342: fprintf(stderr,"%s: Can't open file \"%s\" to touch (write).\n", ! 343: processname, name); ! 344: return(TRUE); ! 345: } ! 346: tempfileopen = TRUE; ! 347: n_lineno = 0; ! 348: o_lineno = 0; ! 349: return(FALSE); ! 350: } ! 351: /* ! 352: * Position to the line (before, after) the line given by place ! 353: */ ! 354: char edbuffer[BUFSIZ]; ! 355: insert(place) ! 356: int place; ! 357: { ! 358: --place; /* always insert messages before the offending line*/ ! 359: for(; o_lineno < place; o_lineno++, n_lineno++){ ! 360: if(fgets(edbuffer, BUFSIZ, o_touchedfile) == NULL) ! 361: return; ! 362: fputs(edbuffer, n_touchedfile); ! 363: } ! 364: } ! 365: ! 366: text(errorp, use_all) ! 367: register struct error_desc *errorp; ! 368: boolean use_all; ! 369: { ! 370: int offset = use_all ? 0 : 2; ! 371: fputs(lang_table[errorp->error_language].lang_incomment, n_touchedfile); ! 372: fprintf(n_touchedfile, "%d [%s] ", ! 373: errorp->error_line, ! 374: lang_table[errorp->error_language].lang_name); ! 375: wordvprint(n_touchedfile, ! 376: errorp->error_lgtext-offset, errorp->error_text+offset); ! 377: fputs(lang_table[errorp->error_language].lang_outcomment,n_touchedfile); ! 378: n_lineno++; ! 379: } ! 380: ! 381: writetouched() ! 382: { ! 383: int bytes_read; ! 384: for(; (bytes_read = fread(edbuffer, 1, sizeof(edbuffer), o_touchedfile))!= NULL; ){ ! 385: fwrite(edbuffer, 1, bytes_read, n_touchedfile); ! 386: } ! 387: fclose(n_touchedfile); ! 388: fclose(o_touchedfile); ! 389: unlink(o_name); ! 390: link(n_name, o_name); ! 391: unlink(n_name); ! 392: tempfileopen = FALSE; ! 393: } ! 394: onintr() ! 395: { ! 396: if (inquire("\nInterrupt: Do you want to continue?")){ ! 397: signal(SIGINT, onintr); ! 398: return; ! 399: } ! 400: if (tempfileopen) ! 401: writetouched(); ! 402: exit(1); ! 403: } ! 404: errorprint(place, errorp, print_all) ! 405: FILE *place; ! 406: struct error_desc *errorp; ! 407: boolean print_all; ! 408: { ! 409: int offset = print_all ? 0 : 2; ! 410: ! 411: if (errorp->error_e_class == C_IGNORE) ! 412: return; ! 413: fprintf(place, "[%s] ", lang_table[errorp->error_language].lang_name); ! 414: wordvprint(place,errorp->error_lgtext-offset,errorp->error_text+offset); ! 415: putc('\n', place); ! 416: } ! 417: ! 418: boolean inquire(fmt, a1, a2) ! 419: char *fmt; ! 420: /*VARARGS1*/ ! 421: { ! 422: char buffer[128]; ! 423: char ch; ! 424: for(;;){ ! 425: do{ ! 426: fflush(stdout); ! 427: fprintf(stderr, fmt, a1, a2); ! 428: fflush(stderr); ! 429: } while (fgets(buffer, 127, queryfile) == NULL); ! 430: ch = buffer[0]; ! 431: if (ch == 'Y' || ch == 'y') ! 432: return(TRUE); ! 433: if (ch == 'N' || ch == 'n') ! 434: return(FALSE); ! 435: fprintf(stderr, "Yes or No only!\n"); ! 436: } ! 437: } ! 438: ! 439: boolean probethisfile(currentfilename) ! 440: char *currentfilename; ! 441: { ! 442: struct stat statbuf; ! 443: if (stat(currentfilename, &statbuf) != 0) ! 444: return(FALSE); ! 445: if ( (statbuf.st_mode&S_IREAD) && (statbuf.st_mode&S_IWRITE)) ! 446: return(TRUE); ! 447: return(FALSE); ! 448: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.