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