![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vops2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex|
Return to ex_vops2.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char *sccsid = "@(#)ex_vops2.c 6.10 (Berkeley) 1/2/88"; ! 9: #endif not lint ! 10: ! 11: #include "ex.h" ! 12: #include "ex_tty.h" ! 13: #include "ex_vis.h" ! 14: ! 15: /* ! 16: * Low level routines for operations sequences, ! 17: * and mostly, insert mode (and a subroutine ! 18: * to read an input line, including in the echo area.) ! 19: */ ! 20: extern char *vUA1, *vUA2; /* mjm: extern; also in ex_vops.c */ ! 21: extern char *vUD1, *vUD2; /* mjm: extern; also in ex_vops.c */ ! 22: ! 23: /* ! 24: * Obleeperate characters in hardcopy ! 25: * open with \'s. ! 26: */ ! 27: bleep(i, cp) ! 28: register int i; ! 29: char *cp; ! 30: { ! 31: ! 32: i -= column(cp); ! 33: do ! 34: ex_putchar('\\' | QUOTE); ! 35: while (--i >= 0); ! 36: rubble = 1; ! 37: } ! 38: ! 39: /* ! 40: * Common code for middle part of delete ! 41: * and change operating on parts of lines. ! 42: */ ! 43: vdcMID() ! 44: { ! 45: register char *cp; ! 46: ! 47: squish(); ! 48: setLAST(); ! 49: if (FIXUNDO) ! 50: vundkind = VCHNG, CP(vutmp, linebuf); ! 51: if (wcursor < cursor) ! 52: cp = wcursor, wcursor = cursor, cursor = cp; ! 53: vUD1 = vUA1 = vUA2 = cursor; vUD2 = wcursor; ! 54: return (column(wcursor - 1)); ! 55: } ! 56: ! 57: /* ! 58: * Take text from linebuf and stick it ! 59: * in the VBSIZE buffer BUF. Used to save ! 60: * deleted text of part of line. ! 61: */ ! 62: takeout(BUF) ! 63: char *BUF; ! 64: { ! 65: register char *cp; ! 66: ! 67: if (wcursor < linebuf) ! 68: wcursor = linebuf; ! 69: if (cursor == wcursor) { ! 70: beep(); ! 71: return; ! 72: } ! 73: if (wcursor < cursor) { ! 74: cp = wcursor; ! 75: wcursor = cursor; ! 76: cursor = cp; ! 77: } ! 78: ex_setBUF(BUF); ! 79: if ((BUF[0] & (QUOTE|TRIM)) == OVERBUF) ! 80: beep(); ! 81: } ! 82: ! 83: /* ! 84: * Are we at the end of the printed representation of the ! 85: * line? Used internally in hardcopy open. ! 86: */ ! 87: ateopr() ! 88: { ! 89: register int i, c; ! 90: register char *cp = vtube[destline] + destcol; ! 91: ! 92: for (i = WCOLS - destcol; i > 0; i--) { ! 93: c = *cp++; ! 94: if (c == 0) ! 95: return (1); ! 96: if (c != ' ' && (c & QUOTE) == 0) ! 97: return (0); ! 98: } ! 99: return (1); ! 100: } ! 101: ! 102: /* ! 103: * Append. ! 104: * ! 105: * This routine handles the top level append, doing work ! 106: * as each new line comes in, and arranging repeatability. ! 107: * It also handles append with repeat counts, and calculation ! 108: * of autoindents for new lines. ! 109: */ ! 110: bool vaifirst; ! 111: bool gobbled; ! 112: char *ogcursor; ! 113: ! 114: vappend(ch, cnt, indent) ! 115: int ch; /* mjm: char --> int */ ! 116: int cnt, indent; ! 117: { ! 118: register int i; ! 119: register char *gcursor; ! 120: bool escape; ! 121: int repcnt, savedoomed; ! 122: short oldhold = hold; ! 123: #ifdef SIGWINCH ! 124: int oldmask; ! 125: #endif ! 126: ! 127: /* ! 128: * Before a move in hardopen when the line is dirty ! 129: * or we are in the middle of the printed representation, ! 130: * we retype the line to the left of the cursor so the ! 131: * insert looks clean. ! 132: */ ! 133: if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) { ! 134: rubble = 1; ! 135: gcursor = cursor; ! 136: i = *gcursor; ! 137: *gcursor = ' '; ! 138: wcursor = gcursor; ! 139: vmove(); ! 140: *gcursor = i; ! 141: } ! 142: vaifirst = indent == 0; ! 143: ! 144: /* ! 145: * Handle replace character by (eventually) ! 146: * limiting the number of input characters allowed ! 147: * in the vgetline routine. ! 148: */ ! 149: if (ch == 'r') ! 150: repcnt = 2; ! 151: else ! 152: repcnt = 0; ! 153: ! 154: /* ! 155: * If an autoindent is specified, then ! 156: * generate a mixture of blanks to tabs to implement ! 157: * it and place the cursor after the indent. ! 158: * Text read by the vgetline routine will be placed in genbuf, ! 159: * so the indent is generated there. ! 160: */ ! 161: if (value(AUTOINDENT) && indent != 0) { ! 162: gcursor = genindent(indent); ! 163: *gcursor = 0; ! 164: vgotoCL(qcolumn(cursor - 1, genbuf)); ! 165: } else { ! 166: gcursor = genbuf; ! 167: *gcursor = 0; ! 168: if (ch == 'o') ! 169: vfixcurs(); ! 170: } ! 171: ! 172: /* ! 173: * Prepare for undo. Pointers delimit inserted portion of line. ! 174: */ ! 175: vUA1 = vUA2 = cursor; ! 176: ! 177: /* ! 178: * If we are not in a repeated command and a ^@ comes in ! 179: * then this means the previous inserted text. ! 180: * If there is none or it was too long to be saved, ! 181: * then beep() and also arrange to undo any damage done ! 182: * so far (e.g. if we are a change.) ! 183: */ ! 184: if ((vglobp && *vglobp == 0) || peekbr()) { ! 185: if ((INS[0] & (QUOTE|TRIM)) == OVERBUF) { ! 186: beep(); ! 187: if (!splitw) ! 188: ungetkey('u'); ! 189: doomed = 0; ! 190: hold = oldhold; ! 191: return; ! 192: } ! 193: /* ! 194: * Unread input from INS. ! 195: * An escape will be generated at end of string. ! 196: * Hold off n^^2 type update on dumb terminals. ! 197: */ ! 198: vglobp = INS; ! 199: hold |= HOLDQIK; ! 200: } else if (vglobp == 0) ! 201: /* ! 202: * Not a repeated command, get ! 203: * a new inserted text for repeat. ! 204: */ ! 205: INS[0] = 0; ! 206: ! 207: /* ! 208: * For wrapmargin to hack away second space after a '.' ! 209: * when the first space caused a line break we keep ! 210: * track that this happened in gobblebl, which says ! 211: * to gobble up a blank silently. ! 212: */ ! 213: gobblebl = 0; ! 214: ! 215: #ifdef SIGWINCH ! 216: oldmask = sigblock(sigmask(SIGWINCH)); ! 217: #endif ! 218: /* ! 219: * Text gathering loop. ! 220: * New text goes into genbuf starting at gcursor. ! 221: * cursor preserves place in linebuf where text will eventually go. ! 222: */ ! 223: if (*cursor == 0 || state == CRTOPEN) ! 224: hold |= HOLDROL; ! 225: for (;;) { ! 226: if (ch == 'r' && repcnt == 0) ! 227: escape = 0; ! 228: else { ! 229: gcursor = vgetline(repcnt, gcursor, &escape, ch); ! 230: ! 231: /* ! 232: * After an append, stick information ! 233: * about the ^D's and ^^D's and 0^D's in ! 234: * the repeated text buffer so repeated ! 235: * inserts of stuff indented with ^D as backtab's ! 236: * can work. ! 237: */ ! 238: if (HADUP) ! 239: addtext("^"); ! 240: else if (HADZERO) ! 241: addtext("0"); ! 242: while (CDCNT > 0) ! 243: addtext("\204"), CDCNT--; ! 244: if (gobbled) ! 245: addtext(" "); ! 246: addtext(ogcursor); ! 247: } ! 248: repcnt = 0; ! 249: ! 250: /* ! 251: * Smash the generated and preexisting indents together ! 252: * and generate one cleanly made out of tabs and spaces ! 253: * if we are using autoindent. ! 254: */ ! 255: if (!vaifirst && value(AUTOINDENT)) { ! 256: i = fixindent(indent); ! 257: if (!HADUP) ! 258: indent = i; ! 259: gcursor = strend(genbuf); ! 260: } ! 261: ! 262: /* ! 263: * Limit the repetition count based on maximum ! 264: * possible line length; do output implied ! 265: * by further count (> 1) and cons up the new line ! 266: * in linebuf. ! 267: */ ! 268: cnt = vmaxrep(ch, cnt); ! 269: CP(gcursor + 1, cursor); ! 270: do { ! 271: CP(cursor, genbuf); ! 272: if (cnt > 1) { ! 273: int oldhold = hold; ! 274: ! 275: Outchar = vinschar; ! 276: hold |= HOLDQIK; ! 277: ex_printf("%s", genbuf); ! 278: hold = oldhold; ! 279: Outchar = vputchar; ! 280: } ! 281: cursor += gcursor - genbuf; ! 282: } while (--cnt > 0); ! 283: endim(); ! 284: vUA2 = cursor; ! 285: if (escape != '\n') ! 286: CP(cursor, gcursor + 1); ! 287: ! 288: /* ! 289: * If doomed characters remain, clobber them, ! 290: * and reopen the line to get the display exact. ! 291: */ ! 292: if (state != HARDOPEN) { ! 293: DEPTH(vcline) = 0; ! 294: savedoomed = doomed; ! 295: if (doomed > 0) { ! 296: register int cind = cindent(); ! 297: ! 298: physdc(cind, cind + doomed); ! 299: doomed = 0; ! 300: } ! 301: i = vreopen(LINE(vcline), lineDOT(), vcline); ! 302: #ifdef TRACE ! 303: if (trace) ! 304: fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed); ! 305: #endif ! 306: if (ch == 'R') ! 307: doomed = savedoomed; ! 308: } ! 309: ! 310: /* ! 311: * All done unless we are continuing on to another line. ! 312: */ ! 313: if (escape != '\n') ! 314: break; ! 315: ! 316: /* ! 317: * Set up for the new line. ! 318: * First save the current line, then construct a new ! 319: * first image for the continuation line consisting ! 320: * of any new autoindent plus the pushed ahead text. ! 321: */ ! 322: killU(); ! 323: addtext(gobblebl ? " " : "\n"); ! 324: vsave(); ! 325: cnt = 1; ! 326: if (value(AUTOINDENT)) { ! 327: #ifdef LISPCODE ! 328: if (value(LISP)) ! 329: indent = lindent(dot + 1); ! 330: else ! 331: #endif ! 332: if (!HADUP && vaifirst) ! 333: indent = whitecnt(linebuf); ! 334: vaifirst = 0; ! 335: strcLIN(vpastwh(gcursor + 1)); ! 336: gcursor = genindent(indent); ! 337: *gcursor = 0; ! 338: if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2]) ! 339: gcursor = genbuf; ! 340: CP(gcursor, linebuf); ! 341: } else { ! 342: CP(genbuf, gcursor + 1); ! 343: gcursor = genbuf; ! 344: } ! 345: ! 346: /* ! 347: * If we started out as a single line operation and are now ! 348: * turning into a multi-line change, then we had better yank ! 349: * out dot before it changes so that undo will work ! 350: * correctly later. ! 351: */ ! 352: if (FIXUNDO && vundkind == VCHNG) { ! 353: vremote(1, yank, 0); ! 354: undap1--; ! 355: } ! 356: ! 357: /* ! 358: * Now do the append of the new line in the buffer, ! 359: * and update the display. If slowopen ! 360: * we don't do very much. ! 361: */ ! 362: vdoappend(genbuf); ! 363: vundkind = VMANYINS; ! 364: vcline++; ! 365: if (state != VISUAL) ! 366: vshow(dot, NOLINE); ! 367: else { ! 368: i += LINE(vcline - 1); ! 369: vopen(dot, i); ! 370: if (value(SLOWOPEN)) ! 371: vscrap(); ! 372: else ! 373: vsync1(LINE(vcline)); ! 374: } ! 375: strcLIN(gcursor); ! 376: *gcursor = 0; ! 377: cursor = linebuf; ! 378: vgotoCL(qcolumn(cursor - 1, genbuf)); ! 379: } ! 380: ! 381: /* ! 382: * All done with insertion, position the cursor ! 383: * and sync the screen. ! 384: */ ! 385: hold = oldhold; ! 386: if (cursor > linebuf) ! 387: cursor--; ! 388: if (state != HARDOPEN) ! 389: vsyncCL(); ! 390: else if (cursor > linebuf) ! 391: back1(); ! 392: doomed = 0; ! 393: wcursor = cursor; ! 394: vmove(); ! 395: #ifdef SIGWINCH ! 396: (void)sigsetmask(oldmask); ! 397: #endif ! 398: } ! 399: ! 400: /* ! 401: * Subroutine for vgetline to back up a single character position, ! 402: * backwards around end of lines (vgoto can't hack columns which are ! 403: * less than 0 in general). ! 404: */ ! 405: back1() ! 406: { ! 407: ! 408: vgoto(destline - 1, WCOLS + destcol - 1); ! 409: } ! 410: ! 411: /* ! 412: * Get a line into genbuf after gcursor. ! 413: * Cnt limits the number of input characters ! 414: * accepted and is used for handling the replace ! 415: * single character command. Aescaped is the location ! 416: * where we stick a termination indicator (whether we ! 417: * ended with an ESCAPE or a newline/return. ! 418: * ! 419: * We do erase-kill type processing here and also ! 420: * are careful about the way we do this so that it is ! 421: * repeatable. (I.e. so that your kill doesn't happen, ! 422: * when you repeat an insert if it was escaped with \ the ! 423: * first time you did it. commch is the command character ! 424: * involved, including the prompt for readline. ! 425: */ ! 426: char * ! 427: vgetline(cnt, gcursor, aescaped, commch) ! 428: int cnt; ! 429: register char *gcursor; ! 430: bool *aescaped; ! 431: char commch; ! 432: { ! 433: register int c, ch; ! 434: register char *cp; ! 435: int x, y, iwhite, backsl=0; ! 436: char *iglobp; ! 437: char cstr[2]; ! 438: int (*OO)() = Outchar; ! 439: ! 440: /* ! 441: * Clear the output state and counters ! 442: * for autoindent backwards motion (counts of ^D, etc.) ! 443: * Remember how much white space at beginning of line so ! 444: * as not to allow backspace over autoindent. ! 445: */ ! 446: *aescaped = 0; ! 447: ogcursor = gcursor; ! 448: flusho(); ! 449: CDCNT = 0; ! 450: HADUP = 0; ! 451: HADZERO = 0; ! 452: gobbled = 0; ! 453: iwhite = whitecnt(genbuf); ! 454: iglobp = vglobp; ! 455: ! 456: /* ! 457: * Carefully avoid using vinschar in the echo area. ! 458: */ ! 459: if (splitw) ! 460: Outchar = vputchar; ! 461: else { ! 462: Outchar = vinschar; ! 463: vprepins(); ! 464: } ! 465: for (;;) { ! 466: backsl = 0; ! 467: if (gobblebl) ! 468: gobblebl--; ! 469: if (cnt != 0) { ! 470: cnt--; ! 471: if (cnt == 0) ! 472: goto vadone; ! 473: } ! 474: c = getkey(); ! 475: if (c != ATTN) ! 476: c &= (QUOTE|TRIM); ! 477: ch = c; ! 478: maphopcnt = 0; ! 479: if (vglobp == 0 && Peek_key == 0 && commch != 'r') ! 480: while ((ch = map(c, immacs)) != c) { ! 481: c = ch; ! 482: if (!value(REMAP)) ! 483: break; ! 484: if (++maphopcnt > 256) ! 485: error("Infinite macro loop"); ! 486: } ! 487: if (!iglobp) { ! 488: ! 489: /* ! 490: * Erase-kill type processing. ! 491: * Only happens if we were not reading ! 492: * from untyped input when we started. ! 493: * Map users erase to ^H, kill to -1 for switch. ! 494: */ ! 495: #ifndef USG3TTY ! 496: if (c == tty.sg_erase) ! 497: c = CTRL('h'); ! 498: else if (c == tty.sg_kill) ! 499: c = -1; ! 500: #else ! 501: if (c == tty.c_cc[VERASE]) ! 502: c = CTRL('h'); ! 503: else if (c == tty.c_cc[VKILL]) ! 504: c = -1; ! 505: #endif ! 506: switch (c) { ! 507: ! 508: /* ! 509: * ^? Interrupt drops you back to visual ! 510: * command mode with an unread interrupt ! 511: * still in the input buffer. ! 512: * ! 513: * ^\ Quit does the same as interrupt. ! 514: * If you are a ex command rather than ! 515: * a vi command this will drop you ! 516: * back to command mode for sure. ! 517: */ ! 518: case ATTN: ! 519: case QUIT: ! 520: ungetkey(c); ! 521: goto vadone; ! 522: ! 523: /* ! 524: * ^H Backs up a character in the input. ! 525: * ! 526: * BUG: Can't back around line boundaries. ! 527: * This is hard because stuff has ! 528: * already been saved for repeat. ! 529: */ ! 530: case CTRL('h'): ! 531: bakchar: ! 532: cp = gcursor - 1; ! 533: if (cp < ogcursor) { ! 534: if (splitw) { ! 535: /* ! 536: * Backspacing over readecho ! 537: * prompt. Pretend delete but ! 538: * don't beep. ! 539: */ ! 540: ungetkey(c); ! 541: goto vadone; ! 542: } ! 543: beep(); ! 544: continue; ! 545: } ! 546: goto vbackup; ! 547: ! 548: /* ! 549: * ^W Back up a white/non-white word. ! 550: */ ! 551: case CTRL('w'): ! 552: wdkind = 1; ! 553: for (cp = gcursor; cp > ogcursor && isspace(cp[-1]); cp--) ! 554: continue; ! 555: for (c = wordch(cp - 1); ! 556: cp > ogcursor && wordof(c, cp - 1); cp--) ! 557: continue; ! 558: goto vbackup; ! 559: ! 560: /* ! 561: * users kill Kill input on this line, back to ! 562: * the autoindent. ! 563: */ ! 564: case -1: ! 565: cp = ogcursor; ! 566: vbackup: ! 567: if (cp == gcursor) { ! 568: beep(); ! 569: continue; ! 570: } ! 571: endim(); ! 572: *cp = 0; ! 573: c = cindent(); ! 574: vgotoCL(qcolumn(cursor - 1, genbuf)); ! 575: if (doomed >= 0) ! 576: doomed += c - cindent(); ! 577: gcursor = cp; ! 578: continue; ! 579: ! 580: /* ! 581: * \ Followed by erase or kill ! 582: * maps to just the erase or kill. ! 583: */ ! 584: case '\\': ! 585: x = destcol, y = destline; ! 586: ex_putchar('\\'); ! 587: vcsync(); ! 588: c = getkey(); ! 589: #ifndef USG3TTY ! 590: if (c == tty.sg_erase || c == tty.sg_kill) ! 591: #else ! 592: if (c == tty.c_cc[VERASE] ! 593: || c == tty.c_cc[VKILL]) ! 594: #endif ! 595: { ! 596: vgoto(y, x); ! 597: if (doomed >= 0) ! 598: doomed++; ! 599: goto def; ! 600: } ! 601: ungetkey(c), c = '\\'; ! 602: backsl = 1; ! 603: break; ! 604: ! 605: /* ! 606: * ^Q Super quote following character ! 607: * Only ^@ is verboten (trapped at ! 608: * a lower level) and \n forces a line ! 609: * split so doesn't really go in. ! 610: * ! 611: * ^V Synonym for ^Q ! 612: */ ! 613: case CTRL('q'): ! 614: case CTRL('v'): ! 615: x = destcol, y = destline; ! 616: ex_putchar('^'); ! 617: vgoto(y, x); ! 618: c = getkey(); ! 619: #ifdef TIOCSETC ! 620: if (c == ATTN) ! 621: c = nttyc.t_intrc; ! 622: #endif ! 623: if (c != NL) { ! 624: if (doomed >= 0) ! 625: doomed++; ! 626: goto def; ! 627: } ! 628: break; ! 629: } ! 630: } ! 631: ! 632: /* ! 633: * If we get a blank not in the echo area ! 634: * consider splitting the window in the wrapmargin. ! 635: */ ! 636: if (c != NL && !splitw) { ! 637: if (c == ' ' && gobblebl) { ! 638: gobbled = 1; ! 639: continue; ! 640: } ! 641: if (value(WRAPMARGIN) && ! 642: (outcol >= OCOLUMNS - value(WRAPMARGIN) || ! 643: backsl && outcol==0) && ! 644: commch != 'r') { ! 645: /* ! 646: * At end of word and hit wrapmargin. ! 647: * Move the word to next line and keep going. ! 648: */ ! 649: wdkind = 1; ! 650: *gcursor++ = c; ! 651: if (backsl) ! 652: *gcursor++ = getkey(); ! 653: *gcursor = 0; ! 654: /* ! 655: * Find end of previous word if we are past it. ! 656: */ ! 657: for (cp=gcursor; cp>ogcursor && isspace(cp[-1]); cp--) ! 658: ; ! 659: if (outcol+(backsl?OCOLUMNS:0) - (gcursor-cp) >= OCOLUMNS - value(WRAPMARGIN)) { ! 660: /* ! 661: * Find beginning of previous word. ! 662: */ ! 663: for (; cp>ogcursor && !isspace(cp[-1]); cp--) ! 664: ; ! 665: if (cp <= ogcursor) { ! 666: /* ! 667: * There is a single word that ! 668: * is too long to fit. Just ! 669: * let it pass, but beep for ! 670: * each new letter to warn ! 671: * the luser. ! 672: */ ! 673: c = *--gcursor; ! 674: *gcursor = 0; ! 675: beep(); ! 676: goto dontbreak; ! 677: } ! 678: /* ! 679: * Save it for next line. ! 680: */ ! 681: macpush(cp, 0); ! 682: cp--; ! 683: } ! 684: macpush("\n", 0); ! 685: /* ! 686: * Erase white space before the word. ! 687: */ ! 688: while (cp > ogcursor && isspace(cp[-1])) ! 689: cp--; /* skip blank */ ! 690: gobblebl = 3; ! 691: goto vbackup; ! 692: } ! 693: dontbreak:; ! 694: } ! 695: ! 696: /* ! 697: * Word abbreviation mode. ! 698: */ ! 699: cstr[0] = c; ! 700: if (anyabbrs && gcursor > ogcursor && !wordch(cstr) && wordch(gcursor-1)) { ! 701: int wdtype, abno; ! 702: ! 703: cstr[1] = 0; ! 704: wdkind = 1; ! 705: cp = gcursor - 1; ! 706: for (wdtype = wordch(cp - 1); ! 707: cp > ogcursor && wordof(wdtype, cp - 1); cp--) ! 708: ; ! 709: *gcursor = 0; ! 710: for (abno=0; abbrevs[abno].mapto; abno++) { ! 711: if (eq(cp, abbrevs[abno].cap)) { ! 712: macpush(cstr, 0); ! 713: macpush(abbrevs[abno].mapto, 1); ! 714: goto vbackup; ! 715: } ! 716: } ! 717: } ! 718: ! 719: switch (c) { ! 720: ! 721: /* ! 722: * ^M Except in repeat maps to \n. ! 723: */ ! 724: case CR: ! 725: if (vglobp) ! 726: goto def; ! 727: c = '\n'; ! 728: /* presto chango ... */ ! 729: ! 730: /* ! 731: * \n Start new line. ! 732: */ ! 733: case NL: ! 734: *aescaped = c; ! 735: goto vadone; ! 736: ! 737: /* ! 738: * escape End insert unless repeat and more to repeat. ! 739: */ ! 740: case ESCAPE: ! 741: if (lastvgk) ! 742: goto def; ! 743: goto vadone; ! 744: ! 745: /* ! 746: * ^D Backtab. ! 747: * ^T Software forward tab. ! 748: * ! 749: * Unless in repeat where this means these ! 750: * were superquoted in. ! 751: */ ! 752: case CTRL('d'): ! 753: case CTRL('t'): ! 754: if (vglobp) ! 755: goto def; ! 756: /* fall into ... */ ! 757: ! 758: /* ! 759: * ^D|QUOTE Is a backtab (in a repeated command). ! 760: */ ! 761: case CTRL('d') | QUOTE: ! 762: *gcursor = 0; ! 763: cp = vpastwh(genbuf); ! 764: c = whitecnt(genbuf); ! 765: if (ch == CTRL('t')) { ! 766: /* ! 767: * ^t just generates new indent replacing ! 768: * current white space rounded up to soft ! 769: * tab stop increment. ! 770: */ ! 771: if (cp != gcursor) ! 772: /* ! 773: * BUG: Don't hack ^T except ! 774: * right after initial ! 775: * white space. ! 776: */ ! 777: continue; ! 778: cp = genindent(iwhite = backtab(c + value(SHIFTWIDTH) + 1)); ! 779: ogcursor = cp; ! 780: goto vbackup; ! 781: } ! 782: /* ! 783: * ^D works only if we are at the (end of) the ! 784: * generated autoindent. We count the ^D for repeat ! 785: * purposes. ! 786: */ ! 787: if (c == iwhite && c != 0) ! 788: if (cp == gcursor) { ! 789: iwhite = backtab(c); ! 790: CDCNT++; ! 791: ogcursor = cp = genindent(iwhite); ! 792: goto vbackup; ! 793: } else if (&cp[1] == gcursor && ! 794: (*cp == '^' || *cp == '0')) { ! 795: /* ! 796: * ^^D moves to margin, then back ! 797: * to current indent on next line. ! 798: * ! 799: * 0^D moves to margin and then ! 800: * stays there. ! 801: */ ! 802: HADZERO = *cp == '0'; ! 803: ogcursor = cp = genbuf; ! 804: HADUP = 1 - HADZERO; ! 805: CDCNT = 1; ! 806: endim(); ! 807: back1(); ! 808: vputchar(' '); ! 809: goto vbackup; ! 810: } ! 811: if (vglobp && vglobp - iglobp >= 2 && ! 812: (vglobp[-2] == '^' || vglobp[-2] == '0') ! 813: && gcursor == ogcursor + 1) ! 814: goto bakchar; ! 815: continue; ! 816: ! 817: default: ! 818: /* ! 819: * Possibly discard control inputs. ! 820: */ ! 821: if (!vglobp && junk(c)) { ! 822: beep(); ! 823: continue; ! 824: } ! 825: def: ! 826: if (!backsl) { ! 827: ex_putchar(c); ! 828: flush(); ! 829: } ! 830: if (gcursor > &genbuf[LBSIZE - 2]) ! 831: error("Line too long"); ! 832: *gcursor++ = c & TRIM; ! 833: vcsync(); ! 834: if (value(SHOWMATCH) && !iglobp) ! 835: if (c == ')' || c == '}') ! 836: lsmatch(gcursor); ! 837: continue; ! 838: } ! 839: } ! 840: vadone: ! 841: *gcursor = 0; ! 842: if (Outchar != termchar) ! 843: Outchar = OO; ! 844: endim(); ! 845: return (gcursor); ! 846: } ! 847: ! 848: int vgetsplit(); ! 849: char *vsplitpt; ! 850: ! 851: /* ! 852: * Append the line in buffer at lp ! 853: * to the buffer after dot. ! 854: */ ! 855: vdoappend(lp) ! 856: char *lp; ! 857: { ! 858: register int oing = inglobal; ! 859: ! 860: vsplitpt = lp; ! 861: inglobal = 1; ! 862: ignore(append(vgetsplit, dot)); ! 863: inglobal = oing; ! 864: } ! 865: ! 866: /* ! 867: * Subroutine for vdoappend to pass to append. ! 868: */ ! 869: vgetsplit() ! 870: { ! 871: ! 872: if (vsplitpt == 0) ! 873: return (EOF); ! 874: strcLIN(vsplitpt); ! 875: vsplitpt = 0; ! 876: return (0); ! 877: } ! 878: ! 879: /* ! 880: * Vmaxrep determines the maximum repetitition factor ! 881: * allowed that will yield total line length less than ! 882: * LBSIZE characters and also does hacks for the R command. ! 883: */ ! 884: vmaxrep(ch, cnt) ! 885: char ch; ! 886: register int cnt; ! 887: { ! 888: register int len, replen; ! 889: ! 890: if (cnt > LBSIZE - 2) ! 891: cnt = LBSIZE - 2; ! 892: replen = strlen(genbuf); ! 893: if (ch == 'R') { ! 894: len = strlen(cursor); ! 895: if (replen < len) ! 896: len = replen; ! 897: CP(cursor, cursor + len); ! 898: vUD2 += len; ! 899: } ! 900: len = strlen(linebuf); ! 901: if (len + cnt * replen <= LBSIZE - 2) ! 902: return (cnt); ! 903: cnt = (LBSIZE - 2 - len) / replen; ! 904: if (cnt == 0) { ! 905: vsave(); ! 906: error("Line too long"); ! 907: } ! 908: return (cnt); ! 909: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.