![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to cmd1.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 ! root 1: /* cmd1.c */ ! 2: ! 3: /* Author: ! 4: * Steve Kirkendall ! 5: * 16820 SW Tallac Way ! 6: * Beaverton, OR 97006 ! 7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda ! 8: */ ! 9: ! 10: ! 11: /* This file contains some of the EX commands - mostly ones that deal with ! 12: * files, options, etc. -- anything except text. ! 13: */ ! 14: ! 15: #include "config.h" ! 16: #include <ctype.h> ! 17: #include "vi.h" ! 18: #include "regexp.h" ! 19: ! 20: #if MSDOS ! 21: #define DATE __DATE__ ! 22: #endif ! 23: ! 24: #ifdef DEBUG ! 25: /* print the selected lines with info on the blocks */ ! 26: /*ARGSUSED*/ ! 27: void cmd_debug(frommark, tomark, cmd, bang, extra) ! 28: MARK frommark; ! 29: MARK tomark; ! 30: CMD cmd; ! 31: int bang; ! 32: char *extra; ! 33: { ! 34: REG char *scan; ! 35: REG long l; ! 36: REG int i; ! 37: int len; ! 38: ! 39: /* scan lnum[] to determine which block its in */ ! 40: l = markline(frommark); ! 41: for (i = 1; l > lnum[i]; i++) ! 42: { ! 43: } ! 44: ! 45: do ! 46: { ! 47: /* fetch text of the block containing that line */ ! 48: scan = blkget(i)->c; ! 49: ! 50: /* calculate its length */ ! 51: if (scan[BLKSIZE - 1]) ! 52: { ! 53: len = BLKSIZE; ! 54: } ! 55: else ! 56: { ! 57: len = strlen(scan); ! 58: } ! 59: ! 60: /* print block stats */ ! 61: msg("##### hdr[%d]=%d, lnum[%d-1]=%ld, lnum[%d]=%ld (%ld lines)", ! 62: i, hdr.n[i], i, lnum[i-1], i, lnum[i], lnum[i] - lnum[i - 1]); ! 63: msg("##### len=%d, buf=0x%lx, %sdirty", ! 64: len, scan, ((int *)scan)[MAXBLKS + 1] ? "" : "not "); ! 65: if (bang) ! 66: { ! 67: while (--len >= 0) ! 68: { ! 69: addch(*scan); ! 70: scan++; ! 71: } ! 72: } ! 73: exrefresh(); ! 74: ! 75: /* next block */ ! 76: i++; ! 77: } while (i < MAXBLKS && lnum[i] && lnum[i - 1] < markline(tomark)); ! 78: } ! 79: ! 80: ! 81: /* This function checks a lot of conditions to make sure they aren't screwy */ ! 82: /*ARGSUSED*/ ! 83: void cmd_validate(frommark, tomark, cmd, bang, extra) ! 84: MARK frommark; ! 85: MARK tomark; ! 86: CMD cmd; ! 87: int bang; ! 88: char *extra; ! 89: { ! 90: char *scan; ! 91: int i; ! 92: int nlcnt; /* used to count newlines */ ! 93: int len; /* counts non-NUL characters */ ! 94: ! 95: /* check lnum[0] */ ! 96: if (lnum[0] != 0L) ! 97: { ! 98: msg("lnum[0] = %ld", lnum[0]); ! 99: } ! 100: ! 101: /* check each block */ ! 102: for (i = 1; lnum[i] <= nlines; i++) ! 103: { ! 104: scan = blkget(i)->c; ! 105: if (scan[BLKSIZE - 1]) ! 106: { ! 107: msg("block %d has no NUL at the end", i); ! 108: } ! 109: else ! 110: { ! 111: for (nlcnt = len = 0; *scan; scan++, len++) ! 112: { ! 113: if (*scan == '\n') ! 114: { ! 115: nlcnt++; ! 116: } ! 117: } ! 118: if (scan[-1] != '\n') ! 119: { ! 120: msg("block %d doesn't end with '\\n' (length %d)", i, len); ! 121: } ! 122: if (bang || nlcnt != lnum[i] - lnum[i - 1]) ! 123: { ! 124: msg("block %d (line %ld?) has %d lines, but should have %ld", ! 125: i, lnum[i - 1] + 1L, nlcnt, lnum[i] - lnum[i - 1]); ! 126: } ! 127: } ! 128: exrefresh(); ! 129: } ! 130: ! 131: /* check lnum again */ ! 132: if (lnum[i] != INFINITY) ! 133: { ! 134: msg("hdr.n[%d] = %d, but lnum[%d] = %ld", ! 135: i, hdr.n[i], i, lnum[i]); ! 136: } ! 137: ! 138: msg("# = \"%s\", %% = \"%s\"", prevorig, origname); ! 139: } ! 140: #endif /* DEBUG */ ! 141: ! 142: ! 143: /*ARGSUSED*/ ! 144: void cmd_mark(frommark, tomark, cmd, bang, extra) ! 145: MARK frommark; ! 146: MARK tomark; ! 147: CMD cmd; ! 148: int bang; ! 149: char *extra; ! 150: { ! 151: /* validate the name of the mark */ ! 152: if (!extra || *extra < 'a' || *extra > 'z' || extra[1]) ! 153: { ! 154: msg("Invalid mark name"); ! 155: return; ! 156: } ! 157: ! 158: mark[*extra - 'a'] = tomark; ! 159: } ! 160: ! 161: /*ARGSUSED*/ ! 162: void cmd_write(frommark, tomark, cmd, bang, extra) ! 163: MARK frommark; ! 164: MARK tomark; ! 165: CMD cmd; ! 166: int bang; ! 167: char *extra; ! 168: { ! 169: int fd; ! 170: int append; /* boolean: write in "append" mode? */ ! 171: REG long l; ! 172: REG char *scan; ! 173: REG int i; ! 174: ! 175: /* if all lines are to be written, use tmpsave() */ ! 176: if (frommark == MARK_FIRST && tomark == MARK_LAST) ! 177: { ! 178: tmpsave(extra, bang); ! 179: return; ! 180: } ! 181: ! 182: /* see if we're going to do this in append mode or not */ ! 183: append = FALSE; ! 184: if (extra[0] == '>' && extra[1] == '>') ! 185: { ! 186: extra += 2; ! 187: append = TRUE; ! 188: } ! 189: ! 190: /* either the file must not exist, or we must have a ! or be appending */ ! 191: if (access(extra, 0) == 0 && !bang && !append) ! 192: { ! 193: msg("File already exists - Use :w! to overwrite"); ! 194: return; ! 195: } ! 196: ! 197: /* else do it line-by-line, like cmd_print() */ ! 198: if (append) ! 199: { ! 200: #ifdef O_APPEND ! 201: fd = open(extra, O_WRONLY|O_APPEND); ! 202: #else ! 203: fd = open(extra, O_WRONLY); ! 204: if (fd >= 0) ! 205: { ! 206: lseek(fd, 0L, 2); ! 207: } ! 208: #endif ! 209: } ! 210: else ! 211: { ! 212: fd = -1; /* so we know the file isn't open yet */ ! 213: } ! 214: ! 215: if (fd < 0) ! 216: { ! 217: fd = creat(extra, FILEPERMS); ! 218: if (fd < 0) ! 219: { ! 220: msg("Can't write to \"%s\"", extra); ! 221: return; ! 222: } ! 223: } ! 224: for (l = markline(frommark); l <= markline(tomark); l++) ! 225: { ! 226: /* get the next line */ ! 227: scan = fetchline(l); ! 228: i = strlen(scan); ! 229: scan[i++] = '\n'; ! 230: ! 231: /* print the line */ ! 232: twrite(fd, scan, i); ! 233: } ! 234: close(fd); ! 235: } ! 236: ! 237: ! 238: /*ARGSUSED*/ ! 239: void cmd_shell(frommark, tomark, cmd, bang, extra) ! 240: MARK frommark, tomark; ! 241: CMD cmd; ! 242: int bang; ! 243: char *extra; ! 244: { ! 245: static char prevextra[80]; ! 246: ! 247: /* special case: ":sh" means ":!sh" */ ! 248: if (cmd == CMD_SHELL) ! 249: { ! 250: extra = o_shell; ! 251: frommark = tomark = 0L; ! 252: } ! 253: ! 254: /* if extra is "!", substute previous command */ ! 255: if (*extra == '!') ! 256: { ! 257: if (!*prevextra) ! 258: { ! 259: msg("No previous shell command to substitute for '!'"); ! 260: return; ! 261: } ! 262: extra = prevextra; ! 263: } ! 264: else if (cmd == CMD_BANG && strlen(extra) < sizeof(prevextra) - 1) ! 265: { ! 266: strcpy(prevextra, extra); ! 267: } ! 268: ! 269: /* if no lines were specified, just run the command */ ! 270: suspend_curses(); ! 271: if (frommark == 0L) ! 272: { ! 273: system(extra); ! 274: } ! 275: else /* pipe lines from the file through the command */ ! 276: { ! 277: filter(frommark, tomark, extra); ! 278: } ! 279: ! 280: /* resume curses quietly for MODE_EX, but noisily otherwise */ ! 281: resume_curses(mode == MODE_EX); ! 282: } ! 283: ! 284: ! 285: /*ARGSUSED*/ ! 286: void cmd_global(frommark, tomark, cmd, bang, extra) ! 287: MARK frommark, tomark; ! 288: CMD cmd; ! 289: int bang; ! 290: char *extra; /* rest of the command line */ ! 291: { ! 292: char *cmdptr; /* the command from the command line */ ! 293: char cmdln[100]; /* copy of the command from the command line */ ! 294: char *line; /* a line from the file */ ! 295: long l; /* used as a counter to move through lines */ ! 296: long lqty; /* quantity of lines to be scanned */ ! 297: long nchanged; /* number of lines changed */ ! 298: regexp *re; /* the compiled search expression */ ! 299: ! 300: /* can't nest global commands */ ! 301: if (doingglobal) ! 302: { ! 303: msg("Can't nest global commands."); ! 304: rptlines = -1L; ! 305: return; ! 306: } ! 307: ! 308: /* ":g! ..." is the same as ":v ..." */ ! 309: if (bang) ! 310: { ! 311: cmd = CMD_VGLOBAL; ! 312: } ! 313: ! 314: /* make sure we got a search pattern */ ! 315: if (*extra != '/' && *extra != '?') ! 316: { ! 317: msg("Usage: %c /regular expression/ command", cmd == CMD_GLOBAL ? 'g' : 'v'); ! 318: return; ! 319: } ! 320: ! 321: /* parse & compile the search pattern */ ! 322: cmdptr = parseptrn(extra); ! 323: if (!extra[1]) ! 324: { ! 325: msg("Can't use empty regular expression with '%c' command", cmd == CMD_GLOBAL ? 'g' : 'v'); ! 326: return; ! 327: } ! 328: re = regcomp(extra + 1); ! 329: if (!re) ! 330: { ! 331: /* regcomp found & described an error */ ! 332: return; ! 333: } ! 334: ! 335: /* for each line in the range */ ! 336: doingglobal = TRUE; ! 337: ChangeText ! 338: { ! 339: /* NOTE: we have to go through the lines in a forward order, ! 340: * otherwise "g/re/p" would look funny. *BUT* for "g/re/d" ! 341: * to work, simply adding 1 to the line# on each loop won't ! 342: * work. The solution: count lines relative to the end of ! 343: * the file. Think about it. ! 344: */ ! 345: for (l = nlines - markline(frommark), ! 346: lqty = markline(tomark) - markline(frommark) + 1L, ! 347: nchanged = 0L; ! 348: lqty > 0 && nlines - l >= 0 && nchanged >= 0L; ! 349: l--, lqty--) ! 350: { ! 351: /* fetch the line */ ! 352: line = fetchline(nlines - l); ! 353: ! 354: /* if it contains the search pattern... */ ! 355: if ((!regexec(re, line, 1)) == (cmd != CMD_GLOBAL)) ! 356: { ! 357: /* move the cursor to that line */ ! 358: cursor = MARK_AT_LINE(nlines - l); ! 359: ! 360: /* do the ex command (without mucking up ! 361: * the original copy of the command line) ! 362: */ ! 363: strcpy(cmdln, cmdptr); ! 364: rptlines = 0L; ! 365: doexcmd(cmdln); ! 366: nchanged += rptlines; ! 367: } ! 368: } ! 369: } ! 370: doingglobal = FALSE; ! 371: ! 372: /* free the regexp */ ! 373: free(re); ! 374: ! 375: /* Reporting...*/ ! 376: rptlines = nchanged; ! 377: } ! 378: ! 379: ! 380: /*ARGSUSED*/ ! 381: void cmd_file(frommark, tomark, cmd, bang, extra) ! 382: MARK frommark, tomark; ! 383: CMD cmd; ! 384: int bang; ! 385: char *extra; ! 386: { ! 387: #ifndef CRUNCH ! 388: /* if we're given a new filename, use it as this file's name */ ! 389: if (extra && *extra) ! 390: { ! 391: strcpy(origname, extra); ! 392: } ! 393: #endif ! 394: if (cmd == CMD_FILE) ! 395: { ! 396: msg("\"%s\" %s%s %ld lines, line %ld [%ld%%]", ! 397: *origname ? origname : "[NO FILE]", ! 398: tstflag(file, MODIFIED) ? "[MODIFIED]" : "", ! 399: tstflag(file, READONLY) ? "[READONLY]" : "", ! 400: nlines, ! 401: markline(frommark), ! 402: markline(frommark) * 100 / nlines); ! 403: } ! 404: else if (markline(frommark) == markline(tomark)) ! 405: { ! 406: msg("%ld", markline(frommark)); ! 407: } ! 408: else ! 409: { ! 410: msg("range \"%ld,%ld\" contains %ld lines", ! 411: markline(frommark), ! 412: markline(tomark), ! 413: markline(tomark) - markline(frommark) + 1L); ! 414: } ! 415: } ! 416: ! 417: ! 418: /*ARGSUSED*/ ! 419: void cmd_edit(frommark, tomark, cmd, bang, extra) ! 420: MARK frommark, tomark; ! 421: CMD cmd; ! 422: int bang; ! 423: char *extra; ! 424: { ! 425: long line = 1L; /* might be set to prevline */ ! 426: ! 427: /* Editing previous file? Then start at previous line */ ! 428: if (!strcmp(extra, prevorig)) ! 429: { ! 430: line = prevline; ! 431: } ! 432: ! 433: #ifndef CRUNCH ! 434: /* if we were given an explicit starting line, then start there */ ! 435: if (*extra == '+') ! 436: { ! 437: for (extra++, line = 0L; *extra >= '0' && *extra <= '9'; extra++) ! 438: { ! 439: line *= 10L; ! 440: line += (*extra - '0'); ! 441: } ! 442: while (isascii(*extra) && isspace(*extra)) ! 443: { ! 444: extra++; ! 445: } ! 446: } ! 447: #endif /* not CRUNCH */ ! 448: ! 449: /* switch files */ ! 450: if (tmpabort(bang)) ! 451: { ! 452: tmpstart(extra); ! 453: if (line <= nlines && line >= 1L) ! 454: { ! 455: cursor = MARK_AT_LINE(line); ! 456: } ! 457: } ! 458: else ! 459: { ! 460: msg("Use edit! to abort changes, or w to save changes"); ! 461: ! 462: /* so we can say ":e!#" next time... */ ! 463: strcpy(prevorig, extra); ! 464: prevline = 1L; ! 465: } ! 466: } ! 467: ! 468: /* This code is also used for rewind -- GB */ ! 469: ! 470: /*ARGSUSED*/ ! 471: void cmd_next(frommark, tomark, cmd, bang, extra) ! 472: MARK frommark, tomark; ! 473: CMD cmd; ! 474: int bang; ! 475: char *extra; ! 476: { ! 477: int i, j; ! 478: char *scan; ! 479: char *build; ! 480: ! 481: /* if extra stuff given, use ":args" to define a new args list */ ! 482: if (cmd == CMD_NEXT && extra && *extra) ! 483: { ! 484: cmd_args(frommark, tomark, cmd, bang, extra); ! 485: } ! 486: ! 487: /* move to the next arg */ ! 488: if (cmd == CMD_NEXT) ! 489: { ! 490: i = argno + 1; ! 491: } ! 492: else if (cmd == CMD_PREVIOUS) ! 493: { ! 494: i = argno - 1; ! 495: } ! 496: else /* cmd == CMD_REWIND */ ! 497: { ! 498: i = 0; ! 499: } ! 500: if (i < 0 || i >= nargs) ! 501: { ! 502: msg("No %sfiles to edit", cmd == CMD_REWIND ? "" : "more "); ! 503: return; ! 504: } ! 505: ! 506: /* find & isolate the name of the file to edit */ ! 507: for (j = i, scan = args; j > 0; j--) ! 508: { ! 509: while(!isascii(*scan) || !isspace(*scan)) ! 510: { ! 511: scan++; ! 512: } ! 513: while (isascii(*scan) && isspace(*scan)) ! 514: { ! 515: scan++; ! 516: } ! 517: } ! 518: for (build = tmpblk.c; *scan && (!isascii(*scan) || !isspace(*scan)); ) ! 519: { ! 520: *build++ = *scan++; ! 521: } ! 522: *build = '\0'; ! 523: ! 524: /* switch to the next file */ ! 525: if (tmpabort(bang)) ! 526: { ! 527: tmpstart(tmpblk.c); ! 528: argno = i; ! 529: } ! 530: else ! 531: { ! 532: msg("Use :%s! to abort changes, or w to save changes", ! 533: cmd == CMD_NEXT ? "next" : ! 534: cmd == CMD_PREVIOUS ? "previous" : ! 535: "rewind"); ! 536: } ! 537: } ! 538: ! 539: /* also called from :wq -- always writes back in this case */ ! 540: ! 541: /*ARGSUSED*/ ! 542: void cmd_xit(frommark, tomark, cmd, bang, extra) ! 543: MARK frommark, tomark; ! 544: CMD cmd; ! 545: int bang; ! 546: char *extra; ! 547: { ! 548: static long whenwarned; /* when the user was last warned of extra files */ ! 549: int oldflag; ! 550: ! 551: /* if there are more files to edit, then warn user */ ! 552: if (argno + 1 < nargs && whenwarned != changes && (!bang || cmd != CMD_QUIT)) ! 553: { ! 554: msg("More files to edit -- Use \":n\" to go to next file"); ! 555: whenwarned = changes; ! 556: return; ! 557: } ! 558: ! 559: if (cmd == CMD_QUIT) ! 560: { ! 561: if (tmpabort(bang)) ! 562: { ! 563: mode = MODE_QUIT; ! 564: } ! 565: else ! 566: { ! 567: msg("Use q! to abort changes, or wq to save changes"); ! 568: } ! 569: } ! 570: else ! 571: { ! 572: /* else try to save this file */ ! 573: oldflag = tstflag(file, MODIFIED); ! 574: if (cmd == CMD_WQUIT) ! 575: setflag(file, MODIFIED); ! 576: if (tmpend(bang)) ! 577: { ! 578: mode = MODE_QUIT; ! 579: } ! 580: else ! 581: { ! 582: msg("Could not save file -- use quit! to abort changes, or w filename"); ! 583: } ! 584: if (!oldflag) ! 585: clrflag(file, MODIFIED); ! 586: } ! 587: } ! 588: ! 589: ! 590: /*ARGSUSED*/ ! 591: void cmd_args(frommark, tomark, cmd, bang, extra) ! 592: MARK frommark, tomark; ! 593: CMD cmd; ! 594: int bang; ! 595: char *extra; ! 596: { ! 597: char *scan; ! 598: char *eow; ! 599: int col; ! 600: int arg; ! 601: int addcols; ! 602: int scrolled = 0; ! 603: ! 604: /* if no extra names given, or just current name, then report the args ! 605: * we have now. ! 606: */ ! 607: if (!extra || !*extra) ! 608: { ! 609: for (scan = args, col=arg=0; *scan; ) ! 610: { ! 611: while (*scan && isascii(*scan) && isspace(*scan)) ! 612: scan++; ! 613: eow = scan; ! 614: while (*eow && (!isascii(*++eow) || !isspace(*eow))) ! 615: ; ! 616: if (arg == argno) ! 617: addcols = 2; ! 618: else ! 619: addcols = 0; ! 620: if (col+addcols+(int)(eow-scan)+1>=COLS) ! 621: { ! 622: addch('\n'); ! 623: scrolled=1; ! 624: col=0; ! 625: } ! 626: else if (arg) ! 627: { qaddch(' '); ! 628: col++; ! 629: } ! 630: if (arg == argno) ! 631: qaddch('['); ! 632: while (scan < eow) ! 633: { qaddch(*scan++); ! 634: col++; ! 635: } ! 636: if (arg == argno) ! 637: qaddch(']'); ! 638: arg++; ! 639: col+=addcols; ! 640: } ! 641: /* write a trailing newline */ ! 642: if ((mode == MODE_EX || mode == MODE_COLON || scrolled) && col) ! 643: addch('\n'); ! 644: exrefresh(); ! 645: } ! 646: else /* new args list given */ ! 647: { ! 648: strcpy(args, extra); ! 649: argno = -1; /* before the first, so :next will go to first */ ! 650: ! 651: /* count the names */ ! 652: for (nargs = 0, scan = args; *scan; nargs++) ! 653: { ! 654: while (*scan && (!isascii(*scan) || !isspace(*scan))) ! 655: { ! 656: scan++; ! 657: } ! 658: while (isascii(*scan) && isspace(*scan)) ! 659: { ! 660: scan++; ! 661: } ! 662: } ! 663: msg("%d files to edit", nargs); ! 664: } ! 665: } ! 666: ! 667: ! 668: /*ARGSUSED*/ ! 669: void cmd_cd(frommark, tomark, cmd, bang, extra) ! 670: MARK frommark, tomark; ! 671: CMD cmd; ! 672: int bang; ! 673: char *extra; ! 674: { ! 675: char *getenv(); ! 676: ! 677: /* default directory name is $HOME */ ! 678: if (!*extra) ! 679: { ! 680: extra = getenv("HOME"); ! 681: if (!extra) ! 682: { ! 683: msg("environment variable $HOME not set"); ! 684: return; ! 685: } ! 686: } ! 687: ! 688: /* go to the directory */ ! 689: if (chdir(extra) < 0) ! 690: { ! 691: perror(extra); ! 692: } ! 693: } ! 694: ! 695: ! 696: /*ARGSUSED*/ ! 697: void cmd_map(frommark, tomark, cmd, bang, extra) ! 698: MARK frommark, tomark; ! 699: CMD cmd; ! 700: int bang; ! 701: char *extra; ! 702: { ! 703: char *mapto; ! 704: ! 705: /* "map" with no extra will dump the map table contents */ ! 706: if (!*extra) ! 707: { ! 708: dumpkey(bang ? WHEN_VIINP|WHEN_VIREP : WHEN_VICMD); ! 709: } ! 710: else ! 711: { ! 712: /* "extra" is key to map, followed my what it maps to */ ! 713: for (mapto = extra; *mapto && *mapto != ' ' && *mapto!= '\t'; mapto++) ! 714: { ! 715: } ! 716: while (*mapto == ' ' || *mapto == '\t') ! 717: { ! 718: *mapto++ = '\0'; ! 719: } ! 720: ! 721: mapkey(extra, mapto, bang ? WHEN_VIINP|WHEN_VIREP : WHEN_VICMD, (char *)0); ! 722: } ! 723: } ! 724: ! 725: ! 726: /*ARGSUSED*/ ! 727: void cmd_set(frommark, tomark, cmd, bang, extra) ! 728: MARK frommark, tomark; ! 729: CMD cmd; ! 730: int bang; ! 731: char *extra; ! 732: { ! 733: if (!*extra) ! 734: { ! 735: dumpopts(FALSE);/* "FALSE" means "don't dump all" - only set */ ! 736: } ! 737: else if (!strcmp(extra, "all")) ! 738: { ! 739: dumpopts(TRUE); /* "TRUE" means "dump all" - even unset vars */ ! 740: } ! 741: else ! 742: { ! 743: setopts(extra); ! 744: ! 745: /* That option may have affected the appearence of text */ ! 746: changes++; ! 747: } ! 748: } ! 749: ! 750: /*ARGSUSED*/ ! 751: void cmd_tag(frommark, tomark, cmd, bang, extra) ! 752: MARK frommark, tomark; ! 753: CMD cmd; ! 754: int bang; ! 755: char *extra; ! 756: { ! 757: char *scan; /* used to scan through the tmpblk.c */ ! 758: char *cmp; /* char of tag name we're comparing, or NULL */ ! 759: char *end; /* marks the end of chars in tmpblk.c */ ! 760: int fd; /* file descriptor used to read the file */ ! 761: #ifndef NO_MAGIC ! 762: char wasmagic; /* preserves the original state of o_magic */ ! 763: #endif ! 764: static char prevtag[30]; ! 765: ! 766: /* if no tag is given, use the previous tag */ ! 767: if (!extra || !*extra) ! 768: { ! 769: if (!*prevtag) ! 770: { ! 771: msg("No previous tag"); ! 772: return; ! 773: } ! 774: extra = prevtag; ! 775: } ! 776: else ! 777: { ! 778: strncpy(prevtag, extra, sizeof prevtag); ! 779: } ! 780: ! 781: /* open the tags file */ ! 782: fd = open(TAGS, O_RDONLY); ! 783: if (fd < 0) ! 784: { ! 785: msg("No tags file"); ! 786: return; ! 787: } ! 788: ! 789: /* Hmmm... this would have been a lot easier with <stdio.h> */ ! 790: ! 791: /* find the line with our tag in it */ ! 792: for(scan = end = tmpblk.c, cmp = extra; ; scan++) ! 793: { ! 794: /* read a block, if necessary */ ! 795: if (scan >= end) ! 796: { ! 797: end = tmpblk.c + tread(fd, tmpblk.c, BLKSIZE); ! 798: scan = tmpblk.c; ! 799: if (scan >= end) ! 800: { ! 801: msg("tag \"%s\" not found", extra); ! 802: close(fd); ! 803: return; ! 804: } ! 805: } ! 806: ! 807: /* if we're comparing, compare... */ ! 808: if (cmp) ! 809: { ! 810: /* matched??? wow! */ ! 811: if (!*cmp && *scan == '\t') ! 812: { ! 813: break; ! 814: } ! 815: if (*cmp++ != *scan) ! 816: { ! 817: /* failed! skip to newline */ ! 818: cmp = (char *)0; ! 819: } ! 820: } ! 821: ! 822: /* if we're skipping to newline, do it fast! */ ! 823: if (!cmp) ! 824: { ! 825: while (scan < end && *scan != '\n') ! 826: { ! 827: scan++; ! 828: } ! 829: if (scan < end) ! 830: { ! 831: cmp = extra; ! 832: } ! 833: } ! 834: } ! 835: ! 836: /* found it! get the rest of the line into memory */ ! 837: for (cmp = tmpblk.c, scan++; scan < end && *scan != '\n'; ) ! 838: { ! 839: *cmp++ = *scan++; ! 840: } ! 841: if (scan == end) ! 842: { ! 843: tread(fd, cmp, BLKSIZE - (cmp - tmpblk.c)); ! 844: } ! 845: ! 846: /* we can close the tags file now */ ! 847: close(fd); ! 848: ! 849: /* extract the filename from the line, and edit the file */ ! 850: for (cmp = tmpblk.c; *cmp != '\t'; cmp++) ! 851: { ! 852: } ! 853: *cmp++ = '\0'; ! 854: if (strcmp(origname, tmpblk.c) != 0) ! 855: { ! 856: if (!tmpabort(bang)) ! 857: { ! 858: msg("Use :tag! to abort changes, or :w to save changes"); ! 859: return; ! 860: } ! 861: tmpstart(tmpblk.c); ! 862: } ! 863: ! 864: /* move to the desired line (or to line 1 if that fails) */ ! 865: #ifndef NO_MAGIC ! 866: wasmagic = *o_magic; ! 867: *o_magic = FALSE; ! 868: #endif ! 869: cursor = MARK_FIRST; ! 870: linespec(cmp, &cursor); ! 871: if (cursor == MARK_UNSET) ! 872: { ! 873: cursor = MARK_FIRST; ! 874: } ! 875: #ifndef NO_MAGIC ! 876: *o_magic = wasmagic; ! 877: #endif ! 878: } ! 879: ! 880: ! 881: ! 882: /*ARGSUSED*/ ! 883: void cmd_visual(frommark, tomark, cmd, bang, extra) ! 884: MARK frommark, tomark; ! 885: CMD cmd; ! 886: int bang; ! 887: char *extra; ! 888: { ! 889: mode = MODE_VI; ! 890: msg(""); ! 891: } ! 892: ! 893: ! 894: ! 895: ! 896: ! 897: /* describe this version of the program */ ! 898: /*ARGSUSED*/ ! 899: void cmd_version(frommark, tomark, cmd, bang, extra) ! 900: MARK frommark; ! 901: MARK tomark; ! 902: CMD cmd; ! 903: int bang; ! 904: char *extra; ! 905: { ! 906: #ifndef DATE ! 907: msg("%s", VERSION); ! 908: #else ! 909: msg("%s (%s)", VERSION, DATE); ! 910: #endif ! 911: #ifdef COMPILED_BY ! 912: msg("Compiled by %s", COMPILED_BY); ! 913: #endif ! 914: #ifdef CREDIT ! 915: msg("%s", CREDIT); ! 916: #endif ! 917: #ifdef COPYING ! 918: msg("%s", COPYING); ! 919: #endif ! 920: } ! 921: ! 922: ! 923: #ifndef NO_MKEXRC ! 924: /* make a .exrc file which describes the current configuration */ ! 925: /*ARGSUSED*/ ! 926: void cmd_mkexrc(frommark, tomark, cmd, bang, extra) ! 927: MARK frommark; ! 928: MARK tomark; ! 929: CMD cmd; ! 930: int bang; ! 931: char *extra; ! 932: { ! 933: int fd; ! 934: ! 935: /* the default name for the .exrc file EXRC */ ! 936: if (!*extra) ! 937: { ! 938: extra = EXRC; ! 939: } ! 940: ! 941: /* create the .exrc file */ ! 942: fd = creat(extra, FILEPERMS); ! 943: if (fd < 0) ! 944: { ! 945: msg("Couldn't create a new \"%s\" file", extra); ! 946: return; ! 947: } ! 948: ! 949: /* save stuff */ ! 950: savekeys(fd); ! 951: saveopts(fd); ! 952: #ifndef NO_DIGRAPH ! 953: savedigs(fd); ! 954: #endif ! 955: #ifndef NO_ABBR ! 956: saveabbr(fd); ! 957: #endif ! 958: ! 959: /* close the file */ ! 960: close(fd); ! 961: msg("Created a new \"%s\" file", extra); ! 962: } ! 963: #endif ! 964: ! 965: #ifndef NO_DIGRAPH ! 966: /*ARGSUSED*/ ! 967: void cmd_digraph(frommark, tomark, cmd, bang, extra) ! 968: MARK frommark; ! 969: MARK tomark; ! 970: CMD cmd; ! 971: int bang; ! 972: char *extra; ! 973: { ! 974: do_digraph(bang, extra); ! 975: } ! 976: #endif ! 977: ! 978: ! 979: #ifndef NO_ERRLIST ! 980: static char errfile[256]; /* the name of a file containing an error */ ! 981: static long errline; /* the line number for an error */ ! 982: ! 983: /* This static function tries to parse an error message. ! 984: * ! 985: * For most compilers, the first word is taken to be the name of the erroneous ! 986: * file, and the first number after that is taken to be the line number where ! 987: * the error was detected. The description of the error follows, possibly ! 988: * preceded by an "error ... :" or "warning ... :" label which is skipped. ! 989: * ! 990: * For Coherent, error messages look like "line#: filename: message". ! 991: * ! 992: * For non-error lines, or unparsable error lines, this function returns NULL. ! 993: * Normally, though, it alters errfile and errline, and returns a pointer to ! 994: * the description. ! 995: */ ! 996: static char *parse_errmsg(text) ! 997: REG char *text; ! 998: { ! 999: REG char *cpy; ! 1000: long atol(); ! 1001: # if COHERENT ! 1002: /* Get the line number. If no line number, then ignore this line. */ ! 1003: errline = atol(text); ! 1004: if (errline == 0L) ! 1005: return (char *)0; ! 1006: ! 1007: /* Skip to the start of the filename */ ! 1008: while (*text && *text++ != ':') ! 1009: { ! 1010: } ! 1011: if (!*text++) ! 1012: return (char *)0; ! 1013: ! 1014: /* copy the filename to errfile */ ! 1015: for (cpy = errfile; *text && (*cpy++ = *text++) != ':'; ) ! 1016: { ! 1017: } ! 1018: if (!*text++) ! 1019: return (char *)0; ! 1020: cpy[-1] = '\0'; ! 1021: ! 1022: return text; ! 1023: # else /* not COHERENT */ ! 1024: char *errmsg; ! 1025: ! 1026: /* the error message is the whole line, by default */ ! 1027: errmsg = text; ! 1028: ! 1029: /* skip leading garbage */ ! 1030: while (*text && !(isascii(*text) && isalnum(*text))) ! 1031: { ! 1032: text++; ! 1033: } ! 1034: ! 1035: /* copy over the filename */ ! 1036: cpy = errfile; ! 1037: while(isascii(*text) && isalnum(*text) || *text == '.') ! 1038: { ! 1039: *cpy++ = *text++; ! 1040: } ! 1041: *cpy = '\0'; ! 1042: ! 1043: /* ignore the name "Error" and filenames that contain a '/' */ ! 1044: if (*text == '/' || !strcmp(errfile + 1, "rror") || access(errfile, 0) < 0) ! 1045: { ! 1046: return (char *)0; ! 1047: } ! 1048: ! 1049: /* skip garbage between filename and line number */ ! 1050: while (*text && !(isascii(*text) && isdigit(*text))) ! 1051: { ! 1052: text++; ! 1053: } ! 1054: ! 1055: /* if the number is part of a larger word, then ignore this line */ ! 1056: if (*text && isascii(text[-1]) && isalpha(text[-1])) ! 1057: { ! 1058: return (char *)0; ! 1059: } ! 1060: ! 1061: /* get the error line */ ! 1062: errline = 0L; ! 1063: while (isascii(*text) && isdigit(*text)) ! 1064: { ! 1065: errline *= 10; ! 1066: errline += (*text - '0'); ! 1067: text++; ! 1068: } ! 1069: ! 1070: /* any line which lacks a filename or line number should be ignored */ ! 1071: if (!errfile[0] || !errline) ! 1072: { ! 1073: return (char *)0; ! 1074: } ! 1075: ! 1076: /* locate the beginning of the error description */ ! 1077: while (*text && isascii(*text) && !isspace(*text)) ! 1078: { ! 1079: text++; ! 1080: } ! 1081: while (*text) ! 1082: { ! 1083: # ifndef CRUNCH ! 1084: /* skip "error #:" and "warning #:" clauses */ ! 1085: if (!strncmp(text + 1, "rror ", 5) ! 1086: || !strncmp(text + 1, "arning ", 7) ! 1087: || !strncmp(text + 1, "atal error", 10)) ! 1088: { ! 1089: do ! 1090: { ! 1091: text++; ! 1092: } while (*text && *text != ':'); ! 1093: continue; ! 1094: } ! 1095: # endif ! 1096: ! 1097: /* anything other than whitespace or a colon is important */ ! 1098: if (!isascii(*text) || (!isspace(*text) && *text != ':')) ! 1099: { ! 1100: errmsg = text; ! 1101: break; ! 1102: } ! 1103: ! 1104: /* else keep looking... */ ! 1105: text++; ! 1106: } ! 1107: ! 1108: return errmsg; ! 1109: # endif /* not COHERENT */ ! 1110: } ! 1111: ! 1112: /*ARGSUSED*/ ! 1113: void cmd_errlist(frommark, tomark, cmd, bang, extra) ! 1114: MARK frommark, tomark; ! 1115: CMD cmd; ! 1116: int bang; ! 1117: char *extra; ! 1118: { ! 1119: static long endline;/* original number of lines in this file */ ! 1120: static long offset; /* offset of the next line in the errlist file */ ! 1121: static int fd = -2;/* fd of the errlist file */ ! 1122: int i; ! 1123: char *errmsg; ! 1124: ! 1125: /* if a new errlist file is named, open it */ ! 1126: if (extra && extra[0]) ! 1127: { ! 1128: /* close the old one */ ! 1129: if (fd >= 0) ! 1130: { ! 1131: close(fd); ! 1132: } ! 1133: ! 1134: fd = open(extra, O_RDONLY); ! 1135: offset = 0L; ! 1136: } ! 1137: else if (fd < 0) ! 1138: { ! 1139: fd = open(ERRLIST, O_RDONLY); ! 1140: offset = 0L; ! 1141: } ! 1142: ! 1143: /* do we have an errlist file now? */ ! 1144: if (fd < 0) ! 1145: { ! 1146: msg("There is no errlist file"); ! 1147: beep(); ! 1148: return; ! 1149: } ! 1150: ! 1151: /* find the next error message in the file */ ! 1152: do ! 1153: { ! 1154: /* read the next line from the errlist */ ! 1155: lseek(fd, offset, 0); ! 1156: if (read(fd, tmpblk.c, (unsigned)BLKSIZE) <= 0) ! 1157: { ! 1158: msg("No more errors"); ! 1159: beep(); ! 1160: close(fd); ! 1161: return; ! 1162: } ! 1163: for (i = 0; tmpblk.c[i] != '\n'; i++) ! 1164: { ! 1165: } ! 1166: tmpblk.c[i++] = 0; ! 1167: ! 1168: /* look for an error message in the line */ ! 1169: errmsg = parse_errmsg(tmpblk.c); ! 1170: if (!errmsg) ! 1171: { ! 1172: offset += i; ! 1173: } ! 1174: ! 1175: } while (!errmsg); ! 1176: ! 1177: /* switch to the file containing the error, if this isn't it */ ! 1178: if (strcmp(origname, errfile)) ! 1179: { ! 1180: if (!tmpabort(bang)) ! 1181: { ! 1182: msg("Use :er! to abort changes, or :w to save changes"); ! 1183: beep(); ! 1184: return; ! 1185: } ! 1186: tmpstart(errfile); ! 1187: endline = nlines; ! 1188: } ! 1189: else if (endline == 0L) ! 1190: { ! 1191: endline = nlines; ! 1192: } ! 1193: ! 1194: /* go to the line where the error was detected */ ! 1195: cursor = MARK_AT_LINE(errline + (nlines - endline)); ! 1196: if (cursor > MARK_LAST) ! 1197: { ! 1198: cursor = MARK_LAST; ! 1199: } ! 1200: if (mode == MODE_VI) ! 1201: { ! 1202: redraw(cursor, FALSE); ! 1203: } ! 1204: ! 1205: /* display the error message */ ! 1206: if (nlines > endline) ! 1207: { ! 1208: msg("line %ld(+%ld): %.60s", errline, nlines - endline, errmsg); ! 1209: } ! 1210: else if (nlines < endline) ! 1211: { ! 1212: msg("line %ld(-%ld): %.60s", errline, endline - nlines, errmsg); ! 1213: } ! 1214: else ! 1215: { ! 1216: msg("line %ld: %.65s", errline, errmsg); ! 1217: } ! 1218: ! 1219: /* remember where the NEXT error line will start */ ! 1220: offset += i; ! 1221: } ! 1222: ! 1223: ! 1224: /*ARGSUSED*/ ! 1225: void cmd_make(frommark, tomark, cmd, bang, extra) ! 1226: MARK frommark, tomark; ! 1227: CMD cmd; ! 1228: int bang; ! 1229: char *extra; ! 1230: { ! 1231: BLK buf; ! 1232: ! 1233: /* if the file hasn't been saved, then complain unless ! */ ! 1234: if (tstflag(file, MODIFIED) && !bang) ! 1235: { ! 1236: msg("\"%s\" not saved yet", origname); ! 1237: return; ! 1238: } ! 1239: ! 1240: /* build the command */ ! 1241: sprintf(buf.c, "%s %s %s%s", (cmd == CMD_CC ? o_cc : o_make), extra, REDIRECT, ERRLIST); ! 1242: qaddstr(buf.c); ! 1243: addch('\n'); ! 1244: ! 1245: /* run the command, with curses temporarily disabled */ ! 1246: suspend_curses(); ! 1247: system(buf.c); ! 1248: resume_curses(mode == MODE_EX); ! 1249: if (mode == MODE_COLON) ! 1250: mode = MODE_VI; ! 1251: ! 1252: /* run the "errlist" command */ ! 1253: cmd_errlist(MARK_UNSET, MARK_UNSET, cmd, bang, ERRLIST); ! 1254: } ! 1255: #endif ! 1256: ! 1257: ! 1258: #ifndef NO_ABBR ! 1259: /*ARGSUSED*/ ! 1260: void cmd_abbr(frommark, tomark, cmd, bang, extra) ! 1261: MARK frommark, tomark; ! 1262: CMD cmd; ! 1263: int bang; ! 1264: char *extra; ! 1265: { ! 1266: do_abbr(extra); ! 1267: } ! 1268: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.