![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_cmdsub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / ex|
Return to ex_cmdsub.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / ex |
1.1 ! root 1: /* Copyright (c) 1980 Regents of the University of California */ ! 2: static char *sccsid = "@(#)ex_cmdsub.c 6.1 10/18/80"; ! 3: #include "ex.h" ! 4: #include "ex_argv.h" ! 5: #include "ex_temp.h" ! 6: #include "ex_tty.h" ! 7: #include "ex_vis.h" ! 8: ! 9: /* ! 10: * Command mode subroutines implementing ! 11: * append, args, copy, delete, join, move, put, ! 12: * shift, tag, yank, z and undo ! 13: */ ! 14: ! 15: bool endline = 1; ! 16: line *tad1; ! 17: static jnoop(); ! 18: ! 19: /* ! 20: * Append after line a lines returned by function f. ! 21: * Be careful about intermediate states to avoid scramble ! 22: * if an interrupt comes in. ! 23: */ ! 24: append(f, a) ! 25: int (*f)(); ! 26: line *a; ! 27: { ! 28: register line *a1, *a2, *rdot; ! 29: int nline; ! 30: ! 31: nline = 0; ! 32: dot = a; ! 33: if(FIXUNDO && !inopen && f!=getsub) { ! 34: undap1 = undap2 = dot + 1; ! 35: undkind = UNDCHANGE; ! 36: } ! 37: while ((*f)() == 0) { ! 38: if (truedol >= endcore) { ! 39: if (morelines() < 0) { ! 40: if (FIXUNDO && f == getsub) { ! 41: undap1 = addr1; ! 42: undap2 = addr2 + 1; ! 43: } ! 44: error("Out of memory@- too many lines in file"); ! 45: } ! 46: } ! 47: nline++; ! 48: a1 = truedol + 1; ! 49: a2 = a1 + 1; ! 50: dot++; ! 51: undap2++; ! 52: dol++; ! 53: unddol++; ! 54: truedol++; ! 55: for (rdot = dot; a1 > rdot;) ! 56: *--a2 = *--a1; ! 57: *rdot = 0; ! 58: putmark(rdot); ! 59: if (f == gettty) { ! 60: dirtcnt++; ! 61: TSYNC(); ! 62: } ! 63: } ! 64: return (nline); ! 65: } ! 66: ! 67: appendnone() ! 68: { ! 69: ! 70: if(FIXUNDO) { ! 71: undkind = UNDCHANGE; ! 72: undap1 = undap2 = addr1; ! 73: } ! 74: } ! 75: ! 76: /* ! 77: * Print out the argument list, with []'s around the current name. ! 78: */ ! 79: pargs() ! 80: { ! 81: register char **av = argv0, *as = args0; ! 82: register int ac; ! 83: ! 84: for (ac = 0; ac < argc0; ac++) { ! 85: if (ac != 0) ! 86: putchar(' '); ! 87: if (ac + argc == argc0 - 1) ! 88: printf("["); ! 89: lprintf("%s", as); ! 90: if (ac + argc == argc0 - 1) ! 91: printf("]"); ! 92: as = av ? *++av : strend(as) + 1; ! 93: } ! 94: noonl(); ! 95: } ! 96: ! 97: /* ! 98: * Delete lines; two cases are if we are really deleting, ! 99: * more commonly we are just moving lines to the undo save area. ! 100: */ ! 101: delete(hush) ! 102: bool hush; ! 103: { ! 104: register line *a1, *a2; ! 105: ! 106: nonzero(); ! 107: if(FIXUNDO) { ! 108: register int (*dsavint)(); ! 109: ! 110: #ifdef TRACE ! 111: if (trace) ! 112: vudump("before delete"); ! 113: #endif ! 114: change(); ! 115: dsavint = signal(SIGINT, SIG_IGN); ! 116: undkind = UNDCHANGE; ! 117: a1 = addr1; ! 118: squish(); ! 119: a2 = addr2; ! 120: if (a2++ != dol) { ! 121: reverse(a1, a2); ! 122: reverse(a2, dol + 1); ! 123: reverse(a1, dol + 1); ! 124: } ! 125: dol -= a2 - a1; ! 126: unddel = a1 - 1; ! 127: if (a1 > dol) ! 128: a1 = dol; ! 129: dot = a1; ! 130: pkill[0] = pkill[1] = 0; ! 131: signal(SIGINT, dsavint); ! 132: #ifdef TRACE ! 133: if (trace) ! 134: vudump("after delete"); ! 135: #endif ! 136: } else { ! 137: register line *a3; ! 138: register int i; ! 139: ! 140: change(); ! 141: a1 = addr1; ! 142: a2 = addr2 + 1; ! 143: a3 = truedol; ! 144: i = a2 - a1; ! 145: unddol -= i; ! 146: undap2 -= i; ! 147: dol -= i; ! 148: truedol -= i; ! 149: do ! 150: *a1++ = *a2++; ! 151: while (a2 <= a3); ! 152: a1 = addr1; ! 153: if (a1 > dol) ! 154: a1 = dol; ! 155: dot = a1; ! 156: } ! 157: if (!hush) ! 158: killed(); ! 159: } ! 160: ! 161: deletenone() ! 162: { ! 163: ! 164: if(FIXUNDO) { ! 165: undkind = UNDCHANGE; ! 166: squish(); ! 167: unddel = addr1; ! 168: } ! 169: } ! 170: ! 171: /* ! 172: * Crush out the undo save area, moving the open/visual ! 173: * save area down in its place. ! 174: */ ! 175: squish() ! 176: { ! 177: register line *a1 = dol + 1, *a2 = unddol + 1, *a3 = truedol + 1; ! 178: ! 179: if(FIXUNDO) { ! 180: if (inopen == -1) ! 181: return; ! 182: if (a1 < a2 && a2 < a3) ! 183: do ! 184: *a1++ = *a2++; ! 185: while (a2 < a3); ! 186: truedol -= unddol - dol; ! 187: unddol = dol; ! 188: } ! 189: } ! 190: ! 191: /* ! 192: * Join lines. Special hacks put in spaces, two spaces if ! 193: * preceding line ends with '.', or no spaces if next line starts with ). ! 194: */ ! 195: static int jcount, jnoop(); ! 196: ! 197: join(c) ! 198: int c; ! 199: { ! 200: register line *a1; ! 201: register char *cp, *cp1; ! 202: ! 203: cp = genbuf; ! 204: *cp = 0; ! 205: for (a1 = addr1; a1 <= addr2; a1++) { ! 206: getline(*a1); ! 207: cp1 = linebuf; ! 208: if (a1 != addr1 && c == 0) { ! 209: while (*cp1 == ' ' || *cp1 == '\t') ! 210: cp1++; ! 211: if (*cp1 && cp > genbuf && cp[-1] != ' ' && cp[-1] != '\t') { ! 212: if (*cp1 != ')') { ! 213: *cp++ = ' '; ! 214: if (cp[-2] == '.') ! 215: *cp++ = ' '; ! 216: } ! 217: } ! 218: } ! 219: while (*cp++ = *cp1++) ! 220: if (cp > &genbuf[LBSIZE-2]) ! 221: error("Line overflow|Result line of join would be too long"); ! 222: cp--; ! 223: } ! 224: strcLIN(genbuf); ! 225: delete(0); ! 226: jcount = 1; ! 227: if (FIXUNDO) ! 228: undap1 = undap2 = addr1; ! 229: ignore(append(jnoop, --addr1)); ! 230: if (FIXUNDO) ! 231: vundkind = VMANY; ! 232: } ! 233: ! 234: static ! 235: jnoop() ! 236: { ! 237: ! 238: return(--jcount); ! 239: } ! 240: ! 241: /* ! 242: * Move and copy lines. Hard work is done by move1 which ! 243: * is also called by undo. ! 244: */ ! 245: int getcopy(); ! 246: ! 247: move() ! 248: { ! 249: register line *adt; ! 250: bool iscopy = 0; ! 251: ! 252: if (Command[0] == 'm') { ! 253: setdot1(); ! 254: markpr(addr2 == dot ? addr1 - 1 : addr2 + 1); ! 255: } else { ! 256: iscopy++; ! 257: setdot(); ! 258: } ! 259: nonzero(); ! 260: adt = address(0); ! 261: if (adt == 0) ! 262: serror("%s where?|%s requires a trailing address", Command); ! 263: newline(); ! 264: move1(iscopy, adt); ! 265: killed(); ! 266: } ! 267: ! 268: move1(cflag, addrt) ! 269: int cflag; ! 270: line *addrt; ! 271: { ! 272: register line *adt, *ad1, *ad2; ! 273: int lines; ! 274: ! 275: adt = addrt; ! 276: lines = (addr2 - addr1) + 1; ! 277: if (cflag) { ! 278: tad1 = addr1; ! 279: ad1 = dol; ! 280: ignore(append(getcopy, ad1++)); ! 281: ad2 = dol; ! 282: } else { ! 283: ad2 = addr2; ! 284: for (ad1 = addr1; ad1 <= ad2;) ! 285: *ad1++ &= ~01; ! 286: ad1 = addr1; ! 287: } ! 288: ad2++; ! 289: if (adt < ad1) { ! 290: if (adt + 1 == ad1 && !cflag && !inglobal) ! 291: error("That move would do nothing!"); ! 292: dot = adt + (ad2 - ad1); ! 293: if (++adt != ad1) { ! 294: reverse(adt, ad1); ! 295: reverse(ad1, ad2); ! 296: reverse(adt, ad2); ! 297: } ! 298: } else if (adt >= ad2) { ! 299: dot = adt++; ! 300: reverse(ad1, ad2); ! 301: reverse(ad2, adt); ! 302: reverse(ad1, adt); ! 303: } else ! 304: error("Move to a moved line"); ! 305: change(); ! 306: if (!inglobal) ! 307: if(FIXUNDO) { ! 308: if (cflag) { ! 309: undap1 = addrt + 1; ! 310: undap2 = undap1 + lines; ! 311: deletenone(); ! 312: } else { ! 313: undkind = UNDMOVE; ! 314: undap1 = addr1; ! 315: undap2 = addr2; ! 316: unddel = addrt; ! 317: squish(); ! 318: } ! 319: } ! 320: } ! 321: ! 322: getcopy() ! 323: { ! 324: ! 325: if (tad1 > addr2) ! 326: return (EOF); ! 327: getline(*tad1++); ! 328: return (0); ! 329: } ! 330: ! 331: /* ! 332: * Put lines in the buffer from the undo save area. ! 333: */ ! 334: getput() ! 335: { ! 336: ! 337: if (tad1 > unddol) ! 338: return (EOF); ! 339: getline(*tad1++); ! 340: tad1++; ! 341: return (0); ! 342: } ! 343: ! 344: put() ! 345: { ! 346: register int cnt; ! 347: ! 348: if (!FIXUNDO) ! 349: error("Cannot put inside global/macro"); ! 350: cnt = unddol - dol; ! 351: if (cnt && inopen && pkill[0] && pkill[1]) { ! 352: pragged(1); ! 353: return; ! 354: } ! 355: tad1 = dol + 1; ! 356: ignore(append(getput, addr2)); ! 357: undkind = UNDPUT; ! 358: notecnt = cnt; ! 359: netchange(cnt); ! 360: } ! 361: ! 362: /* ! 363: * A tricky put, of a group of lines in the middle ! 364: * of an existing line. Only from open/visual. ! 365: * Argument says pkills have meaning, e.g. called from ! 366: * put; it is 0 on calls from putreg. ! 367: */ ! 368: pragged(kill) ! 369: bool kill; ! 370: { ! 371: extern char *cursor; ! 372: register char *gp = &genbuf[cursor - linebuf]; ! 373: ! 374: /* ! 375: * This kind of stuff is TECO's forte. ! 376: * We just grunge along, since it cuts ! 377: * across our line-oriented model of the world ! 378: * almost scrambling our addled brain. ! 379: */ ! 380: if (!kill) ! 381: getDOT(); ! 382: strcpy(genbuf, linebuf); ! 383: getline(*unddol); ! 384: if (kill) ! 385: *pkill[1] = 0; ! 386: strcat(linebuf, gp); ! 387: putmark(unddol); ! 388: getline(dol[1]); ! 389: if (kill) ! 390: strcLIN(pkill[0]); ! 391: strcpy(gp, linebuf); ! 392: strcLIN(genbuf); ! 393: putmark(dol+1); ! 394: undkind = UNDCHANGE; ! 395: undap1 = dot; ! 396: undap2 = dot + 1; ! 397: unddel = dot - 1; ! 398: undo(1); ! 399: } ! 400: ! 401: /* ! 402: * Shift lines, based on c. ! 403: * If c is neither < nor >, then this is a lisp aligning =. ! 404: */ ! 405: shift(c, cnt) ! 406: int c; ! 407: int cnt; ! 408: { ! 409: register line *addr; ! 410: register char *cp; ! 411: char *dp; ! 412: register int i; ! 413: ! 414: if(FIXUNDO) ! 415: save12(), undkind = UNDCHANGE; ! 416: cnt *= value(SHIFTWIDTH); ! 417: for (addr = addr1; addr <= addr2; addr++) { ! 418: dot = addr; ! 419: #ifdef LISPCODE ! 420: if (c == '=' && addr == addr1 && addr != addr2) ! 421: continue; ! 422: #endif ! 423: getDOT(); ! 424: i = whitecnt(linebuf); ! 425: switch (c) { ! 426: ! 427: case '>': ! 428: if (linebuf[0] == 0) ! 429: continue; ! 430: cp = genindent(i + cnt); ! 431: break; ! 432: ! 433: case '<': ! 434: if (i == 0) ! 435: continue; ! 436: i -= cnt; ! 437: cp = i > 0 ? genindent(i) : genbuf; ! 438: break; ! 439: ! 440: #ifdef LISPCODE ! 441: default: ! 442: i = lindent(addr); ! 443: getDOT(); ! 444: cp = genindent(i); ! 445: break; ! 446: #endif ! 447: } ! 448: if (cp + strlen(dp = vpastwh(linebuf)) >= &genbuf[LBSIZE - 2]) ! 449: error("Line too long|Result line after shift would be too long"); ! 450: CP(cp, dp); ! 451: strcLIN(genbuf); ! 452: putmark(addr); ! 453: } ! 454: killed(); ! 455: } ! 456: ! 457: /* ! 458: * Find a tag in the tags file. ! 459: * Most work here is in parsing the tags file itself. ! 460: */ ! 461: tagfind(quick) ! 462: bool quick; ! 463: { ! 464: char cmdbuf[BUFSIZ]; ! 465: char filebuf[FNSIZE]; ! 466: char tagfbuf[128]; ! 467: register int c, d; ! 468: bool samef = 1; ! 469: int tfcount = 0; ! 470: int omagic; ! 471: char *fn, *fne; ! 472: #ifdef VMUNIX ! 473: /* ! 474: * We have lots of room so we bring in stdio and do ! 475: * a binary search on the tags file. ! 476: */ ! 477: # undef EOF ! 478: # include <stdio.h> ! 479: # undef getchar ! 480: # undef putchar ! 481: FILE *iof; ! 482: char iofbuf[BUFSIZ]; ! 483: long mid; /* assumed byte offset */ ! 484: long top, bot; /* length of tag file */ ! 485: struct stat sbuf; ! 486: #endif ! 487: ! 488: omagic = value(MAGIC); ! 489: if (!skipend()) { ! 490: register char *lp = lasttag; ! 491: ! 492: while (!iswhite(peekchar()) && !endcmd(peekchar())) ! 493: if (lp < &lasttag[sizeof lasttag - 2]) ! 494: *lp++ = getchar(); ! 495: else ! 496: ignchar(); ! 497: *lp++ = 0; ! 498: if (!endcmd(peekchar())) ! 499: badtag: ! 500: error("Bad tag|Give one tag per line"); ! 501: } else if (lasttag[0] == 0) ! 502: error("No previous tag"); ! 503: c = getchar(); ! 504: if (!endcmd(c)) ! 505: goto badtag; ! 506: if (c == EOF) ! 507: ungetchar(c); ! 508: clrstats(); ! 509: ! 510: /* ! 511: * Loop once for each file in tags "path". ! 512: */ ! 513: CP(tagfbuf, svalue(TAGS)); ! 514: fne = tagfbuf - 1; ! 515: while (fne) { ! 516: fn = ++fne; ! 517: while (*fne && *fne != ' ') ! 518: fne++; ! 519: if (*fne == 0) ! 520: fne = 0; /* done, quit after this time */ ! 521: else ! 522: *fne = 0; /* null terminate filename */ ! 523: #ifdef VMUNIX ! 524: iof = fopen(fn, "r"); ! 525: if (iof == NULL) ! 526: continue; ! 527: tfcount++; ! 528: setbuf(iof, iofbuf); ! 529: fstat(fileno(iof), &sbuf); ! 530: top = sbuf.st_size; ! 531: if (top == 0L || iof == NULL) ! 532: top = -1L; ! 533: bot = 0L; ! 534: while (top >= bot) { ! 535: #else ! 536: /* ! 537: * Avoid stdio and scan tag file linearly. ! 538: */ ! 539: io = open(fn, 0); ! 540: if (io<0) ! 541: continue; ! 542: tfcount++; ! 543: while (getfile() == 0) { ! 544: #endif ! 545: /* loop for each tags file entry */ ! 546: register char *cp = linebuf; ! 547: register char *lp = lasttag; ! 548: char *oglobp; ! 549: ! 550: #ifdef VMUNIX ! 551: mid = (top + bot) / 2; ! 552: fseek(iof, mid, 0); ! 553: if (mid > 0) /* to get first tag in file to work */ ! 554: /* scan to next \n */ ! 555: if(fgets(linebuf, sizeof linebuf, iof)==NULL) ! 556: goto goleft; ! 557: /* get the line itself */ ! 558: if(fgets(linebuf, sizeof linebuf, iof)==NULL) ! 559: goto goleft; ! 560: linebuf[strlen(linebuf)-1] = 0; /* was '\n' */ ! 561: #endif ! 562: while (*cp && *lp == *cp) ! 563: cp++, lp++; ! 564: if ((*lp || !iswhite(*cp)) && (value(TAGLENGTH)==0 || lp-lasttag < value(TAGLENGTH))) { ! 565: #ifdef VMUNIX ! 566: if (*lp > *cp) ! 567: bot = mid + 1; ! 568: else ! 569: goleft: ! 570: top = mid - 1; ! 571: #endif ! 572: /* Not this tag. Try the next */ ! 573: continue; ! 574: } ! 575: ! 576: /* ! 577: * We found the tag. Decode the line in the file. ! 578: */ ! 579: #ifdef VMUNIX ! 580: fclose(iof); ! 581: #else ! 582: close(io); ! 583: #endif ! 584: /* Rest of tag if abbreviated */ ! 585: while (!iswhite(*cp)) ! 586: cp++; ! 587: ! 588: /* name of file */ ! 589: while (*cp && iswhite(*cp)) ! 590: cp++; ! 591: if (!*cp) ! 592: badtags: ! 593: serror("%s: Bad tags file entry", lasttag); ! 594: lp = filebuf; ! 595: while (*cp && *cp != ' ' && *cp != '\t') { ! 596: if (lp < &filebuf[sizeof filebuf - 2]) ! 597: *lp++ = *cp; ! 598: cp++; ! 599: } ! 600: *lp++ = 0; ! 601: ! 602: if (*cp == 0) ! 603: goto badtags; ! 604: if (dol != zero) { ! 605: /* ! 606: * Save current position in 't for ^^ in visual. ! 607: */ ! 608: names['t'-'a'] = *dot &~ 01; ! 609: if (inopen) { ! 610: extern char *ncols['z'-'a'+2]; ! 611: extern char *cursor; ! 612: ! 613: ncols['t'-'a'] = cursor; ! 614: } ! 615: } ! 616: strcpy(cmdbuf, cp); ! 617: if (strcmp(filebuf, savedfile) || !edited) { ! 618: char cmdbuf2[sizeof filebuf + 10]; ! 619: ! 620: /* Different file. Do autowrite & get it. */ ! 621: if (!quick) { ! 622: ckaw(); ! 623: if (chng && dol > zero) ! 624: error("No write@since last change (:tag! overrides)"); ! 625: } ! 626: oglobp = globp; ! 627: strcpy(cmdbuf2, "e! "); ! 628: strcat(cmdbuf2, filebuf); ! 629: globp = cmdbuf2; ! 630: d = peekc; ungetchar(0); ! 631: commands(1, 1); ! 632: peekc = d; ! 633: globp = oglobp; ! 634: value(MAGIC) = omagic; ! 635: samef = 0; ! 636: } ! 637: ! 638: /* ! 639: * Look for pattern in the current file. ! 640: */ ! 641: oglobp = globp; ! 642: globp = cmdbuf; ! 643: d = peekc; ungetchar(0); ! 644: if (samef) ! 645: markpr(dot); ! 646: /* ! 647: * BUG: if it isn't found (user edited header ! 648: * line) we get left in nomagic mode. ! 649: */ ! 650: value(MAGIC) = 0; ! 651: commands(1, 1); ! 652: peekc = d; ! 653: globp = oglobp; ! 654: value(MAGIC) = omagic; ! 655: return; ! 656: } /* end of "for each tag in file" */ ! 657: ! 658: /* ! 659: * No such tag in this file. Close it and try the next. ! 660: */ ! 661: #ifdef VMUNIX ! 662: fclose(iof); ! 663: #else ! 664: close(io); ! 665: #endif ! 666: } /* end of "for each file in path" */ ! 667: if (tfcount <= 0) ! 668: error("No tags file"); ! 669: else ! 670: serror("%s: No such tag@in tags file", lasttag); ! 671: } ! 672: ! 673: /* ! 674: * Save lines from addr1 thru addr2 as though ! 675: * they had been deleted. ! 676: */ ! 677: yank() ! 678: { ! 679: ! 680: if (!FIXUNDO) ! 681: error("Can't yank inside global/macro"); ! 682: save12(); ! 683: undkind = UNDNONE; ! 684: killcnt(addr2 - addr1 + 1); ! 685: } ! 686: ! 687: /* ! 688: * z command; print windows of text in the file. ! 689: * ! 690: * If this seems unreasonably arcane, the reasons ! 691: * are historical. This is one of the first commands ! 692: * added to the first ex (then called en) and the ! 693: * number of facilities here were the major advantage ! 694: * of en over ed since they allowed more use to be ! 695: * made of fast terminals w/o typing .,.22p all the time. ! 696: */ ! 697: bool zhadpr; ! 698: bool znoclear; ! 699: short zweight; ! 700: ! 701: zop(hadpr) ! 702: int hadpr; ! 703: { ! 704: register int c, lines, op; ! 705: bool excl; ! 706: ! 707: zhadpr = hadpr; ! 708: notempty(); ! 709: znoclear = 0; ! 710: zweight = 0; ! 711: excl = exclam(); ! 712: switch (c = op = getchar()) { ! 713: ! 714: case '^': ! 715: zweight = 1; ! 716: case '-': ! 717: case '+': ! 718: while (peekchar() == op) { ! 719: ignchar(); ! 720: zweight++; ! 721: } ! 722: case '=': ! 723: case '.': ! 724: c = getchar(); ! 725: break; ! 726: ! 727: case EOF: ! 728: znoclear++; ! 729: break; ! 730: ! 731: default: ! 732: op = 0; ! 733: break; ! 734: } ! 735: if (isdigit(c)) { ! 736: lines = c - '0'; ! 737: for(;;) { ! 738: c = getchar(); ! 739: if (!isdigit(c)) ! 740: break; ! 741: lines *= 10; ! 742: lines += c - '0'; ! 743: } ! 744: if (lines < LINES) ! 745: znoclear++; ! 746: value(WINDOW) = lines; ! 747: if (op == '=') ! 748: lines += 2; ! 749: } else ! 750: lines = op == EOF ? value(SCROLL) : excl ? LINES - 1 : 2*value(SCROLL); ! 751: if (inopen || c != EOF) { ! 752: ungetchar(c); ! 753: newline(); ! 754: } ! 755: addr1 = addr2; ! 756: if (addr2 == 0 && dot < dol && op == 0) ! 757: addr1 = addr2 = dot+1; ! 758: setdot(); ! 759: zop2(lines, op); ! 760: } ! 761: ! 762: zop2(lines, op) ! 763: register int lines; ! 764: register int op; ! 765: { ! 766: register line *split; ! 767: ! 768: split = NULL; ! 769: switch (op) { ! 770: ! 771: case EOF: ! 772: if (addr2 == dol) ! 773: error("\nAt EOF"); ! 774: case '+': ! 775: if (addr2 == dol) ! 776: error("At EOF"); ! 777: addr2 += lines * zweight; ! 778: if (addr2 > dol) ! 779: error("Hit BOTTOM"); ! 780: addr2++; ! 781: default: ! 782: addr1 = addr2; ! 783: addr2 += lines-1; ! 784: dot = addr2; ! 785: break; ! 786: ! 787: case '=': ! 788: case '.': ! 789: znoclear = 0; ! 790: lines--; ! 791: lines >>= 1; ! 792: if (op == '=') ! 793: lines--; ! 794: addr1 = addr2 - lines; ! 795: if (op == '=') ! 796: dot = split = addr2; ! 797: addr2 += lines; ! 798: if (op == '.') { ! 799: markDOT(); ! 800: dot = addr2; ! 801: } ! 802: break; ! 803: ! 804: case '^': ! 805: case '-': ! 806: addr2 -= lines * zweight; ! 807: if (addr2 < one) ! 808: error("Hit TOP"); ! 809: lines--; ! 810: addr1 = addr2 - lines; ! 811: dot = addr2; ! 812: break; ! 813: } ! 814: if (addr1 <= zero) ! 815: addr1 = one; ! 816: if (addr2 > dol) ! 817: addr2 = dol; ! 818: if (dot > dol) ! 819: dot = dol; ! 820: if (addr1 > addr2) ! 821: return; ! 822: if (op == EOF && zhadpr) { ! 823: getline(*addr1); ! 824: putchar('\r' | QUOTE); ! 825: shudclob = 1; ! 826: } else if (znoclear == 0 && CL != NOSTR && !inopen) { ! 827: flush1(); ! 828: vclear(); ! 829: } ! 830: if (addr2 - addr1 > 1) ! 831: pstart(); ! 832: if (split) { ! 833: plines(addr1, split - 1, 0); ! 834: splitit(); ! 835: plines(split, split, 0); ! 836: splitit(); ! 837: addr1 = split + 1; ! 838: } ! 839: plines(addr1, addr2, 0); ! 840: } ! 841: ! 842: static ! 843: splitit() ! 844: { ! 845: register int l; ! 846: ! 847: for (l = COLUMNS > 80 ? 40 : COLUMNS / 2; l > 0; l--) ! 848: putchar('-'); ! 849: putnl(); ! 850: } ! 851: ! 852: plines(adr1, adr2, movedot) ! 853: line *adr1; ! 854: register line *adr2; ! 855: bool movedot; ! 856: { ! 857: register line *addr; ! 858: ! 859: pofix(); ! 860: for (addr = adr1; addr <= adr2; addr++) { ! 861: getline(*addr); ! 862: pline(lineno(addr)); ! 863: if (inopen) ! 864: putchar('\n' | QUOTE); ! 865: if (movedot) ! 866: dot = addr; ! 867: } ! 868: } ! 869: ! 870: pofix() ! 871: { ! 872: ! 873: if (inopen && Outchar != termchar) { ! 874: vnfl(); ! 875: setoutt(); ! 876: } ! 877: } ! 878: ! 879: /* ! 880: * Dudley doright to the rescue. ! 881: * Undo saves the day again. ! 882: * A tip of the hatlo hat to Warren Teitleman ! 883: * who made undo as useful as do. ! 884: * ! 885: * Command level undo works easily because ! 886: * the editor has a unique temporary file ! 887: * index for every line which ever existed. ! 888: * We don't have to save large blocks of text, ! 889: * only the indices which are small. We do this ! 890: * by moving them to after the last line in the ! 891: * line buffer array, and marking down info ! 892: * about whence they came. ! 893: * ! 894: * Undo is its own inverse. ! 895: */ ! 896: undo(c) ! 897: bool c; ! 898: { ! 899: register int i; ! 900: register line *jp, *kp; ! 901: line *dolp1, *newdol, *newadot; ! 902: ! 903: #ifdef TRACE ! 904: if (trace) ! 905: vudump("before undo"); ! 906: #endif ! 907: if (inglobal && inopen <= 0) ! 908: error("Can't undo in global@commands"); ! 909: if (!c) ! 910: somechange(); ! 911: pkill[0] = pkill[1] = 0; ! 912: change(); ! 913: if (undkind == UNDMOVE) { ! 914: /* ! 915: * Command to be undone is a move command. ! 916: * This is handled as a special case by noting that ! 917: * a move "a,b m c" can be inverted by another move. ! 918: */ ! 919: if ((i = (jp = unddel) - undap2) > 0) { ! 920: /* ! 921: * when c > b inverse is a+(c-b),c m a-1 ! 922: */ ! 923: addr2 = jp; ! 924: addr1 = (jp = undap1) + i; ! 925: unddel = jp-1; ! 926: } else { ! 927: /* ! 928: * when b > c inverse is c+1,c+1+(b-a) m b ! 929: */ ! 930: addr1 = ++jp; ! 931: addr2 = jp + ((unddel = undap2) - undap1); ! 932: } ! 933: kp = undap1; ! 934: move1(0, unddel); ! 935: dot = kp; ! 936: Command = "move"; ! 937: killed(); ! 938: } else { ! 939: int cnt; ! 940: ! 941: newadot = dot; ! 942: cnt = lineDOL(); ! 943: newdol = dol; ! 944: dolp1 = dol + 1; ! 945: /* ! 946: * Command to be undone is a non-move. ! 947: * All such commands are treated as a combination of ! 948: * a delete command and a append command. ! 949: * We first move the lines appended by the last command ! 950: * from undap1 to undap2-1 so that they are just before the ! 951: * saved deleted lines. ! 952: */ ! 953: if ((i = (kp = undap2) - (jp = undap1)) > 0) { ! 954: if (kp != dolp1) { ! 955: reverse(jp, kp); ! 956: reverse(kp, dolp1); ! 957: reverse(jp, dolp1); ! 958: } ! 959: /* ! 960: * Account for possible backward motion of target ! 961: * for restoration of saved deleted lines. ! 962: */ ! 963: if (unddel >= jp) ! 964: unddel -= i; ! 965: newdol -= i; ! 966: /* ! 967: * For the case where no lines are restored, dot ! 968: * is the line before the first line deleted. ! 969: */ ! 970: dot = jp-1; ! 971: } ! 972: /* ! 973: * Now put the deleted lines, if any, back where they were. ! 974: * Basic operation is: dol+1,unddol m unddel ! 975: */ ! 976: if (undkind == UNDPUT) { ! 977: unddel = undap1 - 1; ! 978: squish(); ! 979: } ! 980: jp = unddel + 1; ! 981: if ((i = (kp = unddol) - dol) > 0) { ! 982: if (jp != dolp1) { ! 983: reverse(jp, dolp1); ! 984: reverse(dolp1, ++kp); ! 985: reverse(jp, kp); ! 986: } ! 987: /* ! 988: * Account for possible forward motion of the target ! 989: * for restoration of the deleted lines. ! 990: */ ! 991: if (undap1 >= jp) ! 992: undap1 += i; ! 993: /* ! 994: * Dot is the first resurrected line. ! 995: */ ! 996: dot = jp; ! 997: newdol += i; ! 998: } ! 999: /* ! 1000: * Clean up so we are invertible ! 1001: */ ! 1002: unddel = undap1 - 1; ! 1003: undap1 = jp; ! 1004: undap2 = jp + i; ! 1005: dol = newdol; ! 1006: netchHAD(cnt); ! 1007: if (undkind == UNDALL) { ! 1008: dot = undadot; ! 1009: undadot = newadot; ! 1010: } else ! 1011: undkind = UNDCHANGE; ! 1012: } ! 1013: /* ! 1014: * Defensive programming - after a munged undadot. ! 1015: * Also handle empty buffer case. ! 1016: */ ! 1017: if ((dot <= zero || dot > dol) && dot != dol) ! 1018: dot = one; ! 1019: #ifdef TRACE ! 1020: if (trace) ! 1021: vudump("after undo"); ! 1022: #endif ! 1023: } ! 1024: ! 1025: /* ! 1026: * Be (almost completely) sure there really ! 1027: * was a change, before claiming to undo. ! 1028: */ ! 1029: somechange() ! 1030: { ! 1031: register line *ip, *jp; ! 1032: ! 1033: switch (undkind) { ! 1034: ! 1035: case UNDMOVE: ! 1036: return; ! 1037: ! 1038: case UNDCHANGE: ! 1039: if (undap1 == undap2 && dol == unddol) ! 1040: break; ! 1041: return; ! 1042: ! 1043: case UNDPUT: ! 1044: if (undap1 != undap2) ! 1045: return; ! 1046: break; ! 1047: ! 1048: case UNDALL: ! 1049: if (unddol - dol != lineDOL()) ! 1050: return; ! 1051: for (ip = one, jp = dol + 1; ip <= dol; ip++, jp++) ! 1052: if ((*ip &~ 01) != (*jp &~ 01)) ! 1053: return; ! 1054: break; ! 1055: ! 1056: case UNDNONE: ! 1057: error("Nothing to undo"); ! 1058: } ! 1059: error("Nothing changed|Last undoable command didn't change anything"); ! 1060: } ! 1061: ! 1062: /* ! 1063: * Map command: ! 1064: * map src dest ! 1065: */ ! 1066: mapcmd(un, ab) ! 1067: int un; /* true if this is unmap command */ ! 1068: int ab; /* true if this is abbr command */ ! 1069: { ! 1070: char lhs[100], rhs[100]; /* max sizes resp. */ ! 1071: register char *p; ! 1072: register char c; ! 1073: char *dname; ! 1074: struct maps *mp; /* the map structure we are working on */ ! 1075: ! 1076: mp = ab ? abbrevs : exclam() ? immacs : arrows; ! 1077: if (skipend()) { ! 1078: int i; ! 1079: ! 1080: /* print current mapping values */ ! 1081: if (peekchar() != EOF) ! 1082: ignchar(); ! 1083: if (un) ! 1084: error("Missing lhs"); ! 1085: if (inopen) ! 1086: pofix(); ! 1087: for (i=0; mp[i].mapto; i++) ! 1088: if (mp[i].cap) { ! 1089: lprintf("%s", mp[i].descr); ! 1090: putchar('\t'); ! 1091: lprintf("%s", mp[i].cap); ! 1092: putchar('\t'); ! 1093: lprintf("%s", mp[i].mapto); ! 1094: putNFL(); ! 1095: } ! 1096: return; ! 1097: } ! 1098: ! 1099: ignore(skipwh()); ! 1100: for (p=lhs; ; ) { ! 1101: c = getchar(); ! 1102: if (c == CTRL(v)) { ! 1103: c = getchar(); ! 1104: } else if (!un && any(c, " \t")) { ! 1105: /* End of lhs */ ! 1106: break; ! 1107: } else if (endcmd(c) && c!='"') { ! 1108: ungetchar(c); ! 1109: if (un) { ! 1110: newline(); ! 1111: *p = 0; ! 1112: addmac(lhs, NOSTR, NOSTR, mp); ! 1113: return; ! 1114: } else ! 1115: error("Missing rhs"); ! 1116: } ! 1117: *p++ = c; ! 1118: } ! 1119: *p = 0; ! 1120: ! 1121: if (skipend()) ! 1122: error("Missing rhs"); ! 1123: for (p=rhs; ; ) { ! 1124: c = getchar(); ! 1125: if (c == CTRL(v)) { ! 1126: c = getchar(); ! 1127: } else if (endcmd(c) && c!='"') { ! 1128: ungetchar(c); ! 1129: break; ! 1130: } ! 1131: *p++ = c; ! 1132: } ! 1133: *p = 0; ! 1134: newline(); ! 1135: /* ! 1136: * Special hack for function keys: #1 means key f1, etc. ! 1137: * If the terminal doesn't have function keys, we just use #1. ! 1138: */ ! 1139: if (lhs[0] == '#') { ! 1140: char *fnkey; ! 1141: char *fkey(); ! 1142: char funkey[3]; ! 1143: ! 1144: fnkey = fkey(lhs[1] - '0'); ! 1145: funkey[0] = 'f'; funkey[1] = lhs[1]; funkey[2] = 0; ! 1146: if (fnkey) ! 1147: strcpy(lhs, fnkey); ! 1148: dname = funkey; ! 1149: } else { ! 1150: dname = lhs; ! 1151: } ! 1152: addmac(lhs,rhs,dname,mp); ! 1153: } ! 1154: ! 1155: /* ! 1156: * Add a macro definition to those that already exist. The sequence of ! 1157: * chars "src" is mapped into "dest". If src is already mapped into something ! 1158: * this overrides the mapping. There is no recursion. Unmap is done by ! 1159: * using NOSTR for dest. Dname is what to show in listings. mp is ! 1160: * the structure to affect (arrows, etc). ! 1161: */ ! 1162: addmac(src,dest,dname,mp) ! 1163: register char *src, *dest, *dname; ! 1164: register struct maps *mp; ! 1165: { ! 1166: register int slot, zer; ! 1167: ! 1168: #ifdef TRACE ! 1169: if (trace) ! 1170: fprintf(trace, "addmac(src='%s', dest='%s', dname='%s', mp=%x\n", src, dest, dname, mp); ! 1171: #endif ! 1172: if (dest && mp==arrows) { ! 1173: /* Make sure user doesn't screw himself */ ! 1174: /* ! 1175: * Prevent tail recursion. We really should be ! 1176: * checking to see if src is a suffix of dest ! 1177: * but this makes mapping involving escapes that ! 1178: * is reasonable mess up. ! 1179: */ ! 1180: if (src[1] == 0 && src[0] == dest[strlen(dest)-1]) ! 1181: error("No tail recursion"); ! 1182: /* ! 1183: * We don't let the user rob himself of ":", and making ! 1184: * multi char words is a bad idea so we don't allow it. ! 1185: * Note that if user sets mapinput and maps all of return, ! 1186: * linefeed, and escape, he can screw himself. This is ! 1187: * so weird I don't bother to check for it. ! 1188: */ ! 1189: if (isalpha(src[0]) && src[1] || any(src[0],":")) ! 1190: error("Too dangerous to map that"); ! 1191: } ! 1192: else if (dest) { ! 1193: /* check for tail recursion in input mode: fussier */ ! 1194: if (eq(src, dest+strlen(dest)-strlen(src))) ! 1195: error("No tail recursion"); ! 1196: } ! 1197: /* ! 1198: * If the src were null it would cause the dest to ! 1199: * be mapped always forever. This is not good. ! 1200: */ ! 1201: if (src == NOSTR || src[0] == 0) ! 1202: error("Missing lhs"); ! 1203: ! 1204: /* see if we already have a def for src */ ! 1205: zer = -1; ! 1206: for (slot=0; mp[slot].mapto; slot++) { ! 1207: if (mp[slot].cap) { ! 1208: if (eq(src, mp[slot].cap) || eq(src, mp[slot].mapto)) ! 1209: break; /* if so, reuse slot */ ! 1210: } else { ! 1211: zer = slot; /* remember an empty slot */ ! 1212: } ! 1213: } ! 1214: ! 1215: if (dest == NOSTR) { ! 1216: /* unmap */ ! 1217: if (mp[slot].cap) { ! 1218: mp[slot].cap = NOSTR; ! 1219: mp[slot].descr = NOSTR; ! 1220: } else { ! 1221: error("Not mapped|That macro wasn't mapped"); ! 1222: } ! 1223: return; ! 1224: } ! 1225: ! 1226: /* reuse empty slot, if we found one and src isn't already defined */ ! 1227: if (zer >= 0 && mp[slot].mapto == 0) ! 1228: slot = zer; ! 1229: ! 1230: /* if not, append to end */ ! 1231: if (slot >= MAXNOMACS) ! 1232: error("Too many macros"); ! 1233: if (msnext == 0) /* first time */ ! 1234: msnext = mapspace; ! 1235: /* Check is a bit conservative, we charge for dname even if reusing src */ ! 1236: if (msnext - mapspace + strlen(dest) + strlen(src) + strlen(dname) + 3 > MAXCHARMACS) ! 1237: error("Too much macro text"); ! 1238: CP(msnext, src); ! 1239: mp[slot].cap = msnext; ! 1240: msnext += strlen(src) + 1; /* plus 1 for null on the end */ ! 1241: CP(msnext, dest); ! 1242: mp[slot].mapto = msnext; ! 1243: msnext += strlen(dest) + 1; ! 1244: if (dname) { ! 1245: CP(msnext, dname); ! 1246: mp[slot].descr = msnext; ! 1247: msnext += strlen(dname) + 1; ! 1248: } else { ! 1249: /* default descr to string user enters */ ! 1250: mp[slot].descr = src; ! 1251: } ! 1252: } ! 1253: ! 1254: /* ! 1255: * Implements macros from command mode. c is the buffer to ! 1256: * get the macro from. ! 1257: */ ! 1258: cmdmac(c) ! 1259: char c; ! 1260: { ! 1261: char macbuf[BUFSIZ]; ! 1262: line *ad, *a1, *a2; ! 1263: char *oglobp; ! 1264: char pk; ! 1265: bool oinglobal; ! 1266: ! 1267: lastmac = c; ! 1268: oglobp = globp; ! 1269: oinglobal = inglobal; ! 1270: pk = peekc; peekc = 0; ! 1271: if (inglobal < 2) ! 1272: inglobal = 1; ! 1273: regbuf(c, macbuf, sizeof(macbuf)); ! 1274: a1 = addr1; a2 = addr2; ! 1275: for (ad=a1; ad<=a2; ad++) { ! 1276: globp = macbuf; ! 1277: dot = ad; ! 1278: commands(1,1); ! 1279: } ! 1280: globp = oglobp; ! 1281: inglobal = oinglobal; ! 1282: peekc = pk; ! 1283: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.