![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to insert.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to insert.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 ! root 1: /*************************************************************************** ! 2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE * ! 3: * is provided to you without charge, and with no warranty. You may give * ! 4: * away copies of JOVE, including sources, provided that this notice is * ! 5: * included in all the files. * ! 6: ***************************************************************************/ ! 7: ! 8: #include "jove.h" ! 9: #include "ctype.h" ! 10: #include "list.h" ! 11: #include "chars.h" ! 12: #include "disp.h" ! 13: ! 14: private int ! 15: newchunk proto((void)); ! 16: private void ! 17: DoNewline proto((int indentp)), ! 18: init_specials proto((void)); ! 19: ! 20: /* Make a newline after AFTER in buffer BUF, UNLESS after is 0, ! 21: in which case we insert the newline before after. */ ! 22: ! 23: Line * ! 24: listput(buf, after) ! 25: register Buffer *buf; ! 26: register Line *after; ! 27: { ! 28: register Line *newline = nbufline(); ! 29: ! 30: if (after == 0) { /* Before the first line */ ! 31: newline->l_next = buf->b_first; ! 32: newline->l_prev = 0; ! 33: buf->b_first = newline; ! 34: } else { ! 35: newline->l_prev = after; ! 36: newline->l_next = after->l_next; ! 37: after->l_next = newline; ! 38: } ! 39: if (newline->l_next) ! 40: newline->l_next->l_prev = newline; ! 41: else ! 42: if (buf) ! 43: buf->b_last = newline; ! 44: if (buf && buf->b_dot == 0) ! 45: buf->b_dot = newline; ! 46: return newline; ! 47: } ! 48: ! 49: /* Divide the current line and move the current line to the next one */ ! 50: ! 51: void ! 52: LineInsert(num) ! 53: register int num; ! 54: { ! 55: char newline[LBSIZE]; ! 56: register Line *newdot, ! 57: *olddot; ! 58: int oldchar; ! 59: ! 60: olddot = curline; ! 61: oldchar = curchar; ! 62: ! 63: newdot = curline; ! 64: while (--num >= 0) { ! 65: newdot = listput(curbuf, newdot); ! 66: SavLine(newdot, NullStr); ! 67: } ! 68: ! 69: modify(); ! 70: if (curchar != 0) { ! 71: strcpy(newline, &linebuf[curchar]); ! 72: linebuf[curchar] = '\0'; /* Shorten this line */ ! 73: SavLine(curline, linebuf); ! 74: strcpy(linebuf, newline); ! 75: } else { /* Redisplay optimization */ ! 76: newdot->l_dline = curline->l_dline; ! 77: SavLine(curline, NullStr); ! 78: } ! 79: ! 80: makedirty(curline); ! 81: curline = newdot; ! 82: curchar = 0; ! 83: makedirty(curline); ! 84: IFixMarks(olddot, oldchar, curline, curchar); ! 85: } ! 86: ! 87: /* Inserts tabs and spaces to move the cursor to column GOAL. It ! 88: Uses the most optimal number of tabs and spaces no matter what ! 89: was there before hand. */ ! 90: ! 91: void ! 92: n_indent(goal) ! 93: register int goal; ! 94: { ! 95: int dotcol, ! 96: incrmt; ! 97: ! 98: DelWtSpace(); ! 99: dotcol = calc_pos(linebuf, curchar); ! 100: ! 101: for (;;) { ! 102: incrmt = (tabstop - (dotcol % tabstop)); ! 103: if (dotcol + incrmt > goal) ! 104: break; ! 105: insert_c('\t', 1); ! 106: dotcol += incrmt; ! 107: } ! 108: if (dotcol != goal) ! 109: insert_c(' ', (goal - dotcol)); ! 110: } ! 111: ! 112: #ifdef ABBREV ! 113: void ! 114: MaybeAbbrevExpand() ! 115: { ! 116: if (MinorMode(Abbrev) && !ismword(LastKeyStruck) && ! 117: !bolp() && ismword(linebuf[curchar - 1])) ! 118: AbbrevExpand(); ! 119: } ! 120: #endif ! 121: ! 122: void ! 123: SelfInsert() ! 124: { ! 125: #ifdef ABBREV ! 126: MaybeAbbrevExpand(); ! 127: #endif ! 128: if (LastKeyStruck != CTL('J') && MinorMode(OverWrite)) { ! 129: register int num, ! 130: i; ! 131: ! 132: for (i = 0, num = arg_value(); i < num; i++) { ! 133: int pos = calc_pos(linebuf, curchar); ! 134: ! 135: if (!eolp()) { ! 136: if (linebuf[curchar] == '\t') { ! 137: if ((pos + 1) == ((pos + tabstop) - (pos % tabstop))) ! 138: del_char(FORWARD, 1, NO); ! 139: } else ! 140: del_char(FORWARD, 1, NO); ! 141: } ! 142: insert_c(LastKeyStruck, 1); ! 143: } ! 144: } else ! 145: Insert(LastKeyStruck); ! 146: ! 147: if (MinorMode(Fill) && (curchar >= RMargin || ! 148: (calc_pos(linebuf, curchar) >= RMargin))) { ! 149: int margin; ! 150: Bufpos save; ! 151: ! 152: if (MinorMode(Indent)) { ! 153: DOTsave(&save); ! 154: ToIndent(); ! 155: margin = calc_pos(linebuf, curchar); ! 156: SetDot(&save); ! 157: } else ! 158: margin = LMargin; ! 159: DoJustify(curline, 0, curline, ! 160: curchar + (int)strlen(&linebuf[curchar]), 1, margin); ! 161: } ! 162: } ! 163: ! 164: void ! 165: Insert(c) ! 166: int c; ! 167: { ! 168: if (c == CTL('J')) ! 169: LineInsert(arg_value()); ! 170: else ! 171: insert_c(c, arg_value()); ! 172: } ! 173: ! 174: /* insert character C N times at point */ ! 175: void ! 176: insert_c(c, n) ! 177: int c, ! 178: n; ! 179: { ! 180: if (n <= 0) ! 181: return; ! 182: modify(); ! 183: makedirty(curline); ! 184: ins_c(c, linebuf, curchar, n, LBSIZE); ! 185: IFixMarks(curline, curchar, curline, curchar + n); ! 186: curchar += n; ! 187: } ! 188: ! 189: /* Tab in to the right place for C mode */ ! 190: ! 191: void ! 192: Tab() ! 193: { ! 194: #ifdef LISP ! 195: if (MajorMode(LISPMODE) && (bolp() || !eolp())) { ! 196: int dotchar = curchar; ! 197: Mark *m = 0; ! 198: ! 199: ToIndent(); ! 200: if (dotchar > curchar) ! 201: m = MakeMark(curline, dotchar, M_FLOATER); ! 202: (void) lisp_indent(); ! 203: if (m) { ! 204: ToMark(m); ! 205: DelMark(m); ! 206: } else ! 207: ToIndent(); ! 208: return; ! 209: } ! 210: #endif ! 211: if (MajorMode(CMODE)) { ! 212: if (within_indent()) ! 213: (void) c_indent(NO); ! 214: else { ! 215: int curpos, ! 216: tabbed_pos; ! 217: ! 218: skip_wht_space(); ! 219: curpos = calc_pos(linebuf, curchar); ! 220: tabbed_pos = curpos + (CIndIncrmt - (curpos % CIndIncrmt)); ! 221: n_indent(tabbed_pos); ! 222: } ! 223: } else ! 224: SelfInsert(); ! 225: } ! 226: ! 227: void ! 228: QuotChar() ! 229: { ! 230: int c, ! 231: slow = NO; ! 232: ! 233: c = waitchar(&slow); ! 234: if (c != CTL('@')) ! 235: Insert(c); ! 236: } ! 237: ! 238: /* Insert the paren. If in C mode and c is a '}' then insert the ! 239: '}' in the "right" place for C indentation; that is indented ! 240: the same amount as the matching '{' is indented. */ ! 241: ! 242: int PDelay = 5, /* 1/2 a second */ ! 243: CIndIncrmt = 8; ! 244: ! 245: void ! 246: DoParen() ! 247: { ! 248: Bufpos *bp; ! 249: int tried = NO, ! 250: nx, ! 251: c = LastKeyStruck; ! 252: ! 253: if (!isclosep(c)) { ! 254: SelfInsert(); ! 255: return; ! 256: } ! 257: ! 258: if (MajorMode(CMODE) && c == '}' && within_indent()) { ! 259: bp = c_indent(YES); ! 260: tried = TRUE; ! 261: } ! 262: #ifdef LISP ! 263: if (MajorMode(LISPMODE) && c == ')' && blnkp(linebuf)) { ! 264: bp = lisp_indent(); ! 265: tried = TRUE; ! 266: } ! 267: #endif ! 268: SelfInsert(); ! 269: #ifdef MAC ! 270: if (MinorMode(ShowMatch) && !in_macro()) { ! 271: #else ! 272: if (MinorMode(ShowMatch) && !charp() && !in_macro()) { ! 273: #endif ! 274: b_char(1); /* Back onto the ')' */ ! 275: if (!tried) ! 276: bp = m_paren(c, BACKWARD, NO, YES); ! 277: f_char(1); ! 278: if (bp != 0) { ! 279: nx = in_window(curwind, bp->p_line); ! 280: if (nx != -1) { /* is visible */ ! 281: Bufpos b; ! 282: ! 283: DOTsave(&b); ! 284: SetDot(bp); ! 285: SitFor(PDelay); ! 286: SetDot(&b); ! 287: } else ! 288: s_mess("%s", lcontents(bp->p_line)); ! 289: } ! 290: mp_error(); /* display error message */ ! 291: } ! 292: } ! 293: ! 294: void ! 295: LineAI() ! 296: { ! 297: DoNewline(TRUE); ! 298: } ! 299: ! 300: void ! 301: Newline() ! 302: { ! 303: DoNewline(MinorMode(Indent)); ! 304: } ! 305: ! 306: private void ! 307: DoNewline(indentp) ! 308: int indentp; ! 309: { ! 310: Bufpos save; ! 311: int indent; ! 312: ! 313: /* first we calculate the indent of the current line */ ! 314: DOTsave(&save); ! 315: ToIndent(); ! 316: indent = calc_pos(linebuf, curchar); ! 317: SetDot(&save); ! 318: ! 319: #ifdef ABBREV ! 320: MaybeAbbrevExpand(); ! 321: #endif ! 322: #ifdef LISP ! 323: if (MajorMode(LISPMODE)) ! 324: DelWtSpace(); ! 325: else ! 326: #endif ! 327: if (indentp || blnkp(linebuf)) ! 328: DelWtSpace(); ! 329: ! 330: /* If there is more than 2 blank lines in a row then don't make ! 331: a newline, just move down one. */ ! 332: if (arg_value() == 1 && eolp() && TwoBlank()) ! 333: SetLine(curline->l_next); ! 334: else ! 335: LineInsert(arg_value()); ! 336: ! 337: if (indentp) ! 338: #ifdef LISP ! 339: if (MajorMode(LISPMODE)) ! 340: (void) lisp_indent(); ! 341: else ! 342: #endif ! 343: { ! 344: Bol(); ! 345: n_indent((LMargin == 0) ? indent : LMargin); ! 346: } ! 347: } ! 348: ! 349: void ! 350: ins_str(str, ok_nl) ! 351: register char *str; ! 352: int ok_nl; ! 353: { ! 354: register char c; ! 355: Bufpos save; ! 356: int llen; ! 357: ! 358: if (*str == 0) ! 359: return; /* ain't nothing to insert! */ ! 360: DOTsave(&save); ! 361: llen = strlen(linebuf); ! 362: while ((c = *str++) != '\0') { ! 363: if (c == '\n' || (ok_nl && llen >= LBSIZE - 2)) { ! 364: IFixMarks(save.p_line, save.p_char, curline, curchar); ! 365: modify(); ! 366: makedirty(curline); ! 367: LineInsert(1); ! 368: DOTsave(&save); ! 369: llen = strlen(linebuf); ! 370: } ! 371: if (c != '\n') { ! 372: ins_c(c, linebuf, curchar++, 1, LBSIZE); ! 373: llen += 1; ! 374: } ! 375: } ! 376: IFixMarks(save.p_line, save.p_char, curline, curchar); ! 377: modify(); ! 378: makedirty(curline); ! 379: } ! 380: ! 381: void ! 382: open_lines(n) ! 383: int n; ! 384: { ! 385: Bufpos dot; ! 386: ! 387: DOTsave(&dot); ! 388: LineInsert(n); /* Open the lines... */ ! 389: SetDot(&dot); ! 390: } ! 391: ! 392: void ! 393: OpenLine() ! 394: { ! 395: open_lines(arg_value()); ! 396: } ! 397: ! 398: /* Take the region FLINE/FCHAR to TLINE/TCHAR and insert it at ! 399: ATLINE/ATCHAR in WHATBUF. */ ! 400: ! 401: Bufpos * ! 402: DoYank(fline, fchar, tline, tchar, atline, atchar, whatbuf) ! 403: Line *fline, ! 404: *tline, ! 405: *atline; ! 406: int fchar, ! 407: tchar, ! 408: atchar; ! 409: Buffer *whatbuf; ! 410: { ! 411: register Line *newline; ! 412: static Bufpos bp; ! 413: char save[LBSIZE], ! 414: buf[LBSIZE]; ! 415: Line *startline = atline; ! 416: int startchar = atchar; ! 417: ! 418: lsave(); ! 419: if (whatbuf) ! 420: modify(); ! 421: (void) ltobuf(atline, genbuf); ! 422: strcpy(save, &genbuf[atchar]); ! 423: ! 424: (void) ltobuf(fline, buf); ! 425: if (fline == tline) ! 426: buf[tchar] = '\0'; ! 427: ! 428: linecopy(genbuf, atchar, &buf[fchar]); ! 429: atline->l_dline = putline(genbuf); ! 430: makedirty(atline); ! 431: ! 432: fline = fline->l_next; ! 433: while (fline != tline->l_next) { ! 434: newline = listput(whatbuf, atline); ! 435: newline->l_dline = fline->l_dline; ! 436: makedirty(newline); ! 437: fline = fline->l_next; ! 438: atline = newline; ! 439: atchar = 0; ! 440: } ! 441: ! 442: getline(atline->l_dline, genbuf); ! 443: atchar += tchar; ! 444: linecopy(genbuf, atchar, save); ! 445: atline->l_dline = putline(genbuf); ! 446: makedirty(atline); ! 447: IFixMarks(startline, startchar, atline, atchar); ! 448: bp.p_line = atline; ! 449: bp.p_char = atchar; ! 450: this_cmd = YANKCMD; ! 451: getDOT(); /* Whatever used to be in linebuf */ ! 452: return &bp; ! 453: } ! 454: ! 455: void ! 456: YankPop() ! 457: { ! 458: Line *line, ! 459: *last; ! 460: Mark *mp = CurMark(); ! 461: Bufpos *dot; ! 462: int dir = -1; /* Direction to rotate the ring */ ! 463: ! 464: if (last_cmd != YANKCMD) ! 465: complain("Yank something first!"); ! 466: ! 467: lfreelist(reg_delete(mp->m_line, mp->m_char, curline, curchar)); ! 468: ! 469: /* Now must find a recently killed region. */ ! 470: ! 471: if (arg_value() < 0) ! 472: dir = 1; ! 473: ! 474: killptr += dir; ! 475: for (;;) { ! 476: if (killptr < 0) ! 477: killptr = NUMKILLS - 1; ! 478: else if (killptr >= NUMKILLS) ! 479: killptr = 0; ! 480: if (killbuf[killptr]) ! 481: break; ! 482: killptr += dir; ! 483: } ! 484: ! 485: this_cmd = YANKCMD; ! 486: ! 487: line = killbuf[killptr]; ! 488: last = lastline(line); ! 489: dot = DoYank(line, 0, last, length(last), curline, curchar, curbuf); ! 490: MarkSet(CurMark(), curline, curchar); ! 491: SetDot(dot); ! 492: } ! 493: ! 494: /* This is an attempt to reduce the amount of memory taken up by each line. ! 495: Without this each malloc of a line uses sizeof (line) + sizeof(HEADER) ! 496: where line is 3 words and HEADER is 1 word. ! 497: This is going to allocate memory in chucks of CHUNKSIZE * sizeof (line) ! 498: and divide each chuck into lineS. A line is free in a chunk when its ! 499: line->l_dline == 0, so freeline sets dline to 0. */ ! 500: ! 501: #define CHUNKSIZE 300 ! 502: ! 503: struct chunk { ! 504: int c_nlines; /* Number of lines in this chunk (so they ! 505: don't all have to be CHUNKSIZE long). */ ! 506: Line *c_block; /* Chunk of memory */ ! 507: struct chunk *c_nextfree; /* Next chunk of lines */ ! 508: }; ! 509: ! 510: private struct chunk *fchunk = 0; ! 511: private Line *ffline = 0; /* First free line */ ! 512: ! 513: void ! 514: freeline(line) ! 515: register Line *line; ! 516: { ! 517: line->l_dline = 0; ! 518: line->l_next = ffline; ! 519: if (ffline) ! 520: ffline->l_prev = line; ! 521: line->l_prev = 0; ! 522: ffline = line; ! 523: } ! 524: ! 525: void ! 526: lfreelist(first) ! 527: register Line *first; ! 528: { ! 529: if (first) ! 530: lfreereg(first, lastline(first)); ! 531: } ! 532: ! 533: /* Append region from line1 to line2 onto the free list of lines */ ! 534: ! 535: void ! 536: lfreereg(line1, line2) ! 537: register Line *line1, ! 538: *line2; ! 539: { ! 540: register Line *next, ! 541: *last = line2->l_next; ! 542: ! 543: while (line1 != last) { ! 544: next = line1->l_next; ! 545: freeline(line1); ! 546: line1 = next; ! 547: } ! 548: } ! 549: ! 550: private int ! 551: newchunk() ! 552: { ! 553: register Line *newline; ! 554: register int i; ! 555: struct chunk *f; ! 556: int nlines = CHUNKSIZE; ! 557: ! 558: f = (struct chunk *) emalloc(sizeof (struct chunk)); ! 559: if (f == 0) ! 560: return 0; ! 561: ! 562: if ((f->c_block = (Line *) malloc((unsigned) (sizeof (Line) * nlines))) == 0) { ! 563: while (nlines > 0) { ! 564: f->c_block = (Line *) malloc((unsigned) (sizeof (Line) * nlines)); ! 565: if (f->c_block != 0) ! 566: break; ! 567: nlines /= 2; ! 568: } ! 569: } ! 570: ! 571: if (nlines <= 0) ! 572: return 0; ! 573: ! 574: f->c_nlines = nlines; ! 575: for (i = 0, newline = f->c_block; i < nlines; newline++, i++) ! 576: freeline(newline); ! 577: f->c_nextfree = fchunk; ! 578: fchunk = f; ! 579: return 1; ! 580: } ! 581: ! 582: /* New BUFfer LINE */ ! 583: ! 584: Line * ! 585: nbufline() ! 586: { ! 587: register Line *newline; ! 588: ! 589: if (ffline == 0) /* No free list */ ! 590: if (newchunk() == 0) ! 591: complain("[Out of lines] "); ! 592: newline = ffline; ! 593: ffline = ffline->l_next; ! 594: if (ffline) ! 595: ffline->l_prev = 0; ! 596: return newline; ! 597: } ! 598: ! 599: /* Remove the free lines, in chunk c, from the free list because they are ! 600: no longer free. */ ! 601: ! 602: private void ! 603: remfreelines(c) ! 604: register struct chunk *c; ! 605: { ! 606: register Line *lp; ! 607: register int i; ! 608: ! 609: for (lp = c->c_block, i = 0; i < c->c_nlines; i++, lp++) { ! 610: if (lp->l_prev) ! 611: lp->l_prev->l_next = lp->l_next; ! 612: else ! 613: ffline = lp->l_next; ! 614: if (lp->l_next) ! 615: lp->l_next->l_prev = lp->l_prev; ! 616: } ! 617: } ! 618: ! 619: /* This is used to garbage collect the chunks of lines when malloc fails ! 620: and we are NOT looking for a new buffer line. This goes through each ! 621: chunk, and if every line in a given chunk is not allocated, the entire ! 622: chunk is `free'd by "free()". */ ! 623: ! 624: void ! 625: GCchunks() ! 626: { ! 627: register struct chunk *cp; ! 628: struct chunk *prev = 0, ! 629: *next = 0; ! 630: register int i; ! 631: register Line *newline; ! 632: ! 633: for (cp = fchunk; cp != 0; cp = next) { ! 634: for (i = 0, newline = cp->c_block; i < cp->c_nlines; newline++, i++) ! 635: if (newline->l_dline != 0) ! 636: break; ! 637: ! 638: next = cp->c_nextfree; ! 639: ! 640: if (i == cp->c_nlines) { /* Unlink it!!! */ ! 641: if (prev) ! 642: prev->c_nextfree = cp->c_nextfree; ! 643: else ! 644: fchunk = cp->c_nextfree; ! 645: remfreelines(cp); ! 646: free((char *) cp->c_block); ! 647: free((char *) cp); ! 648: } else ! 649: prev = cp; ! 650: } ! 651: } ! 652: ! 653: #ifdef LISP ! 654: ! 655: #include "re.h" ! 656: ! 657: /* Grind S-Expr */ ! 658: ! 659: void ! 660: GSexpr() ! 661: { ! 662: Bufpos dot, ! 663: end; ! 664: ! 665: if (linebuf[curchar] != '(') ! 666: complain((char *) 0); ! 667: DOTsave(&dot); ! 668: FSexpr(); ! 669: DOTsave(&end); ! 670: SetDot(&dot); ! 671: for (;;) { ! 672: if (curline == end.p_line) ! 673: break; ! 674: line_move(FORWARD, 1, NO); ! 675: if (!blnkp(linebuf)) ! 676: (void) lisp_indent(); ! 677: } ! 678: SetDot(&dot); ! 679: } ! 680: ! 681: /* lisp_indent() indents a new line in Lisp Mode, according to where ! 682: the matching close-paren would go if we typed that (sort of). */ ! 683: ! 684: private List *specials = NIL; ! 685: ! 686: private void ! 687: init_specials() ! 688: { ! 689: static char *const words[] = { ! 690: "case", ! 691: "def", ! 692: "dolist", ! 693: "fluid-let", ! 694: "lambda", ! 695: "let", ! 696: "lexpr", ! 697: "macro", ! 698: "named-l", /* named-let and named-lambda */ ! 699: "nlambda", ! 700: "prog", ! 701: "selectq", ! 702: 0 ! 703: }; ! 704: char *const *wordp = words; ! 705: ! 706: while (*wordp) ! 707: list_push(&specials, (Element *) *wordp++); ! 708: } ! 709: ! 710: void ! 711: AddSpecial() ! 712: { ! 713: char *word; ! 714: register List *lp; ! 715: ! 716: if (specials == NIL) ! 717: init_specials(); ! 718: word = ask((char *) 0, ProcFmt); ! 719: for (lp = specials; lp != NIL; lp = list_next(lp)) ! 720: if (strcmp((char *) list_data(lp), word) == 0) ! 721: return; /* already in list */ ! 722: (void) list_push(&specials, (Element *) copystr(word)); ! 723: } ! 724: ! 725: Bufpos * ! 726: lisp_indent() ! 727: { ! 728: Bufpos *bp, ! 729: savedot; ! 730: int goal; ! 731: ! 732: bp = m_paren(')', BACKWARD, NO, YES); ! 733: ! 734: if (bp == NULL) ! 735: return NULL; ! 736: ! 737: /* We want to end up ! 738: ! 739: (atom atom atom ... ! 740: ^ here. ! 741: */ ! 742: ! 743: DOTsave(&savedot); ! 744: SetDot(bp); ! 745: f_char(1); ! 746: if (linebuf[curchar] != '(') { ! 747: register List *lp; ! 748: ! 749: if (specials == NIL) ! 750: init_specials(); ! 751: for (lp = specials; lp != NIL; lp = list_next(lp)) ! 752: if (casencmp((char *) list_data(lp), ! 753: &linebuf[curchar], ! 754: strlen((char *) list_data(lp))) == 0) ! 755: break; ! 756: if (lp == NIL) { /* not special */ ! 757: int c_char = curchar; ! 758: ! 759: WITH_TABLE(curbuf->b_major) ! 760: f_word(1); ! 761: END_TABLE(); ! 762: if (LookingAt("[ \t]*;\\|[ \t]*$", linebuf, curchar)) ! 763: curchar = c_char; ! 764: else while (linebuf[curchar] == ' ') ! 765: curchar += 1; ! 766: } else ! 767: curchar += 1; ! 768: } ! 769: goal = calc_pos(linebuf, curchar); ! 770: SetDot(&savedot); ! 771: Bol(); ! 772: n_indent(goal); ! 773: ! 774: return bp; ! 775: } ! 776: #endif /* LISP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.