Return to insert.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove

Annotation of 43BSDTahoe/new/jove/insert.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.