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