Return to buf.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove

Annotation of 43BSDReno/contrib/jove/buf.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: /* Contains commands that deal with creating, selecting, killing and
        !             9:    listing buffers, and buffer modes, and find-file, etc. */
        !            10: 
        !            11: #include "jove.h"
        !            12: #include "ctype.h"
        !            13: #include "disp.h"
        !            14: #if defined(IPROCS)
        !            15: # include "fp.h"
        !            16: # include "iproc.h"
        !            17: #endif
        !            18: 
        !            19: #ifdef MAC
        !            20: # include "mac.h"
        !            21: #else
        !            22: # include <sys/stat.h>
        !            23: #endif
        !            24: 
        !            25: private Buffer
        !            26:        *buf_alloc proto((void)),
        !            27:        *mak_buf proto((void));
        !            28: 
        !            29: private char *line_cnt proto((Buffer *, char *));
        !            30: 
        !            31: private void
        !            32:        defb_wind proto((Buffer *)),
        !            33:        kill_buf proto((Buffer *)),
        !            34:        mkbuflist proto((char **));
        !            35: 
        !            36: private char   *Mainbuf = "Main",
        !            37:        *NoName = "Sans un nom!";
        !            38: 
        !            39: Buffer *world = 0,             /* First in the list */
        !            40:        *curbuf = 0,    /* pointer into world for current buffer */
        !            41:        *lastbuf = 0;   /* Last buffer we were in so we have a default
        !            42:                           buffer during a select buffer. */
        !            43: 
        !            44: /* Toggle BIT in the current buffer's minor mode flags.  If argument is
        !            45:    supplied, a positive one always turns on the mode and zero argument
        !            46:    always turns it off. */
        !            47: 
        !            48: void
        !            49: TogMinor(bit)
        !            50: int    bit;
        !            51: {
        !            52:        if (is_an_arg()) {
        !            53:                if (arg_value() == 0)
        !            54:                        curbuf->b_minor &= ~bit;
        !            55:                else
        !            56:                        curbuf->b_minor |= bit;
        !            57:        } else
        !            58:                curbuf->b_minor ^= bit;
        !            59:        UpdModLine = YES;
        !            60: }
        !            61: 
        !            62: /* Creates a new buffer, links it at the end of the buffer chain, and
        !            63:    returns it. */
        !            64: 
        !            65: private Buffer *
        !            66: buf_alloc()
        !            67: {
        !            68:        register Buffer *b,
        !            69:                        *lastbp;
        !            70: 
        !            71:        lastbp = 0;
        !            72:        for (b = world; b != 0; lastbp = b, b = b->b_next)
        !            73:                ;
        !            74: 
        !            75:        b = (Buffer *) emalloc(sizeof (Buffer));
        !            76:        if (lastbp)
        !            77:                lastbp->b_next = b;
        !            78:        else
        !            79:                world = b;
        !            80:        b->b_first = 0;
        !            81:        b->b_next = 0;
        !            82: #if defined(MAC)
        !            83:        b->Type = BUFFER;       /* kludge, but simplifies menu handlers */
        !            84:        b->Name = 0;
        !            85: #endif
        !            86:        return b;
        !            87: }
        !            88: 
        !            89: /* Makes a buffer and initializes it.  Obsolete.  Used to take two
        !            90:    arguments, a buffer name and a file name. */
        !            91: 
        !            92: private Buffer *
        !            93: mak_buf()
        !            94: {
        !            95:        register Buffer *newb;
        !            96:        register int    i;
        !            97: 
        !            98:        newb = buf_alloc();
        !            99:        newb->b_fname = 0;
        !           100:        newb->b_name = NoName;
        !           101:        set_ino(newb);
        !           102:        newb->b_marks = 0;
        !           103:        newb->b_themark = 0;            /* Index into markring */
        !           104:        /* No marks yet */
        !           105:        for (i = 0; i < NMARKS; i++)
        !           106:                newb->b_markring[i] = 0;
        !           107:        newb->b_modified = 0;
        !           108:        newb->b_type = B_FILE;  /* File until proven SCRATCH */
        !           109:        newb->b_ntbf = 0;
        !           110:        newb->b_minor = 0;
        !           111:        newb->b_major = TEXT;
        !           112:        newb->b_first = 0;
        !           113:        newb->b_map = 0;
        !           114: #if defined(IPROCS)
        !           115:        newb->b_process = 0;
        !           116: #endif
        !           117:        initlist(newb);
        !           118: #if defined(MAC)
        !           119:        Bufchange = 1;
        !           120: #endif
        !           121:        return newb;
        !           122: }
        !           123: 
        !           124: void
        !           125: ReNamBuf()
        !           126: {
        !           127:        register char   *new = 0,
        !           128:                        *prompt = ProcFmt,
        !           129:                        *second = "%s already exists; new name? ";
        !           130: 
        !           131:        for (;;) {
        !           132:                new = ask((char *) 0, prompt, new);
        !           133:                if (!buf_exists(new))
        !           134:                        break;
        !           135:                prompt = second;
        !           136:        }
        !           137:        setbname(curbuf, new);
        !           138: }
        !           139: 
        !           140: void
        !           141: FindFile()
        !           142: {
        !           143:        register char   *name;
        !           144:        char    fnamebuf[FILESIZE];
        !           145: 
        !           146:        name = ask_file((char *) 0, curbuf->b_fname, fnamebuf);
        !           147:        SetABuf(curbuf);
        !           148:        SetBuf(do_find(curwind, name, 0));
        !           149: }
        !           150: 
        !           151: private void
        !           152: mkbuflist(bnamp)
        !           153: register char  **bnamp;
        !           154: {
        !           155:        register Buffer *b;
        !           156: 
        !           157:        for (b = world; b != 0; b = b->b_next)
        !           158:                if (b->b_name != 0)
        !           159:                        *bnamp++ = b->b_name;
        !           160:        *bnamp = 0;
        !           161: }
        !           162: 
        !           163: char *
        !           164: ask_buf(def)
        !           165: Buffer *def;
        !           166: {
        !           167:        char    *bnames[100];
        !           168:        register char   *bname;
        !           169:        register int    offset;
        !           170:        char    prompt[100];
        !           171: 
        !           172:        if (def != 0 && def->b_name != 0)
        !           173:                swritef(prompt, ": %f (default %s) ", def->b_name);
        !           174:        else
        !           175:                swritef(prompt, ProcFmt);
        !           176:        mkbuflist(bnames);
        !           177:        offset = complete(bnames, prompt, RET_STATE);
        !           178:        if (offset == EOF)
        !           179:                complain((char *) 0);
        !           180:        if (offset == ORIGINAL || offset == AMBIGUOUS)
        !           181:                bname = Minibuf;
        !           182:        else if (offset == NULLSTRING) {
        !           183:                if (def)
        !           184:                        bname = def->b_name;
        !           185:                else
        !           186:                        complain((char *) 0);
        !           187:        } else if (offset < 0)
        !           188:                complain((char *) 0);
        !           189:        else
        !           190:                bname = bnames[offset];
        !           191: 
        !           192:        return bname;
        !           193: }
        !           194: 
        !           195: void
        !           196: BufSelect()
        !           197: {
        !           198:        register char   *bname;
        !           199: 
        !           200:        bname = ask_buf(lastbuf);
        !           201:        SetABuf(curbuf);
        !           202:        SetBuf(do_select(curwind, bname));
        !           203: }
        !           204: 
        !           205: #if defined(MSDOS)
        !           206: 
        !           207: private void
        !           208: BufNSelect(n)
        !           209: {
        !           210:        char *bnames[100];
        !           211:        char *bname;
        !           212:        int i;
        !           213: 
        !           214:        mkbuflist(bnames);
        !           215:        for (i=0; i<n; i++)
        !           216:            if (bnames[i] == 0)
        !           217:               complain("[No such buffer]");
        !           218:        bname = bnames[n-1];
        !           219:        SetABuf(curbuf);
        !           220:        SetBuf(do_select(curwind, bname));
        !           221: }
        !           222: 
        !           223: void Buf1Select() { BufNSelect(1); }
        !           224: void Buf2Select() { BufNSelect(2); }
        !           225: void Buf3Select() { BufNSelect(3); }
        !           226: void Buf4Select() { BufNSelect(4); }
        !           227: void Buf5Select() { BufNSelect(5); }
        !           228: void Buf6Select() { BufNSelect(6); }
        !           229: void Buf7Select() { BufNSelect(7); }
        !           230: void Buf8Select() { BufNSelect(8); }
        !           231: void Buf9Select() { BufNSelect(9); }
        !           232: void Buf10Select() { BufNSelect(10); }
        !           233: 
        !           234: #endif /* MSDOS */
        !           235: 
        !           236: private void
        !           237: defb_wind(b)
        !           238: register Buffer *b;
        !           239: {
        !           240:        register Window *w = fwind;
        !           241:        char    *alt;
        !           242: 
        !           243:        if (lastbuf == b || lastbuf == 0) {
        !           244:                lastbuf = 0;
        !           245:                alt = (b->b_next != 0) ? b->b_next->b_name : Mainbuf;
        !           246:        } else
        !           247:                alt = lastbuf->b_name;
        !           248: 
        !           249:        do {
        !           250:                if (w->w_bufp == b) {
        !           251:                        if (one_windp() || alt != Mainbuf)
        !           252:                                (void) do_select(w, alt);
        !           253:                        else {
        !           254:                                Window  *save = w->w_next;
        !           255: 
        !           256:                                del_wind(w);
        !           257:                                w = save->w_prev;
        !           258:                        }
        !           259:                }
        !           260:                w = w->w_next;
        !           261:        } while (w != fwind || w->w_bufp == b);
        !           262: }
        !           263: 
        !           264: private Buffer *
        !           265: getNMbuf()
        !           266: {
        !           267:        register Buffer *delbuf;
        !           268:        register char   *bname;
        !           269: 
        !           270:        bname = ask_buf(curbuf);
        !           271:        if ((delbuf = buf_exists(bname)) == 0)
        !           272:                complain("[No such buffer]");
        !           273:        if (delbuf->b_modified)
        !           274:                confirm("%s modified, are you sure? ", bname);
        !           275:        return delbuf;
        !           276: }
        !           277: 
        !           278: void
        !           279: BufErase()
        !           280: {
        !           281:        register Buffer *delbuf;
        !           282: 
        !           283:        if ((delbuf = getNMbuf()) != NIL) {
        !           284:                initlist(delbuf);
        !           285:                delbuf->b_modified = 0;
        !           286:        }
        !           287: }
        !           288: 
        !           289: private void
        !           290: kill_buf(delbuf)
        !           291: register Buffer        *delbuf;
        !           292: {
        !           293:        register Buffer *b,
        !           294:                        *lastb = 0;
        !           295: 
        !           296: #if defined(IPROCS)
        !           297:        pbuftiedp(delbuf);      /* check for lingering processes */
        !           298: #endif
        !           299:        /* clean up windows associated with this buffer */
        !           300:        if (delbuf == curbuf)
        !           301:                curbuf = NULL;
        !           302:        if (delbuf == lastbuf)
        !           303:                lastbuf = curbuf;       /* even if NULL */
        !           304:        defb_wind(delbuf);
        !           305:        if (curbuf == NULL)
        !           306:                SetBuf(curwind->w_bufp);
        !           307: 
        !           308:        /* unlink the buffer */
        !           309:        for (b = world; b != 0; lastb = b, b = b->b_next)
        !           310:                if (b == delbuf)
        !           311:                        break;
        !           312:        if (lastb)
        !           313:                lastb->b_next = delbuf->b_next;
        !           314:        else
        !           315:                world = delbuf->b_next;
        !           316: 
        !           317: #if !defined(MAC)
        !           318:        if (perr_buf == delbuf) {
        !           319:                ErrFree();
        !           320:                perr_buf = 0;
        !           321:        }
        !           322: #endif
        !           323: 
        !           324:        lfreelist(delbuf->b_first);
        !           325:        if (delbuf->b_name)
        !           326:                free(delbuf->b_name);
        !           327:        if (delbuf->b_fname)
        !           328:                free(delbuf->b_fname);
        !           329:        flush_marks(delbuf);
        !           330:        free((char *) delbuf);
        !           331: 
        !           332: #if defined(MAC)
        !           333:        Bufchange = 1;
        !           334: #endif
        !           335: }
        !           336: 
        !           337: /* offer to kill some buffers */
        !           338: 
        !           339: void
        !           340: KillSome()
        !           341: {
        !           342:        register Buffer *b,
        !           343:                        *next;
        !           344:        Buffer  *oldb;
        !           345:        register char   *y_or_n;
        !           346: 
        !           347:        for (b = world; b != 0; b = next) {
        !           348:                next = b->b_next;
        !           349:                if (yes_or_no_p("Kill %s? ", b->b_name) == NO)
        !           350:                        continue;
        !           351:                if (IsModified(b)) {
        !           352:                        y_or_n = ask("No", "%s modified; should I save it? ", b->b_name);
        !           353:                        if (CharUpcase(*y_or_n) == 'Y') {
        !           354:                                oldb = curbuf;
        !           355:                                SetBuf(b);
        !           356:                                SaveFile();
        !           357:                                SetBuf(oldb);
        !           358:                        }
        !           359:                }
        !           360:                kill_buf(b);
        !           361:        }
        !           362: }
        !           363: 
        !           364: void
        !           365: BufKill()
        !           366: {
        !           367:        Buffer  *b;
        !           368: 
        !           369:        if ((b = getNMbuf()) == 0)
        !           370:                return;
        !           371:        kill_buf(b);
        !           372: }
        !           373: 
        !           374: private char *
        !           375: line_cnt(b, buf)
        !           376: register Buffer        *b;
        !           377: char   *buf;
        !           378: {
        !           379:        register int    nlines = 0;
        !           380:        register Line   *lp;
        !           381: 
        !           382:        for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
        !           383:                ;
        !           384:        swritef(buf, "%d", nlines);
        !           385:        return buf;
        !           386: }
        !           387: 
        !           388: private const char     *const TypeNames[] = {
        !           389:        0,
        !           390:        "Scratch",
        !           391:        "File",
        !           392:        "Process",
        !           393: };
        !           394: 
        !           395: void
        !           396: BufList()
        !           397: {
        !           398:        register char   *fmt = "%-2s %-5s %-11s %-1s %-*s  %-s";
        !           399:        register Buffer *b;
        !           400:        int     bcount = 1,             /* To give each buffer a number */
        !           401:                buf_width = 11;
        !           402:        char    nbuf[10];
        !           403: 
        !           404:        for (b = world; b != 0; b = b->b_next)
        !           405:                buf_width = max(buf_width, (int)strlen(b->b_name));
        !           406: 
        !           407:        TOstart("Buffer list", TRUE);   /* true means auto-newline */
        !           408: 
        !           409:        Typeout("(* means buffer needs saving)");
        !           410:        Typeout("(+ means file hasn't been read yet)");
        !           411:        Typeout(NullStr);
        !           412:        Typeout(fmt, "NO", "Lines", "Type", NullStr, buf_width, "Name", "File");
        !           413:        Typeout(fmt, "--", "-----", "----", NullStr, buf_width, "----", "----");
        !           414:        for (b = world; b != 0; b = b->b_next) {
        !           415:                Typeout(fmt, itoa(bcount++),
        !           416:                                line_cnt(b, nbuf),
        !           417:                                TypeNames[b->b_type],
        !           418:                                IsModified(b) ? "*" :
        !           419:                                         b->b_ntbf ? "+" : NullStr,
        !           420:                                buf_width,
        !           421:                                /* For the * (variable length field) */
        !           422:                                b->b_name,
        !           423:                                filename(b));
        !           424: 
        !           425:                if (TOabort)
        !           426:                        break;
        !           427:        }
        !           428:        TOstop();
        !           429: }
        !           430: 
        !           431: void
        !           432: bufname(b)
        !           433: register Buffer        *b;
        !           434: {
        !           435:        char    tmp[100],
        !           436:                *cp;
        !           437:        int     try = 1;
        !           438: 
        !           439:        if (b->b_fname == 0)
        !           440:                complain("[No file name]");
        !           441:        cp = basename(b->b_fname);
        !           442:        strcpy(tmp, cp);
        !           443:        while (buf_exists(tmp)) {
        !           444:                swritef(tmp, "%s.%d", cp, try);
        !           445:                try += 1;
        !           446:        }
        !           447:        setbname(b, tmp);
        !           448: }
        !           449: 
        !           450: void
        !           451: initlist(b)
        !           452: register Buffer        *b;
        !           453: {
        !           454:        lfreelist(b->b_first);
        !           455:        b->b_first = b->b_dot = b->b_last = 0;
        !           456:        (void) listput(b, b->b_first);
        !           457: 
        !           458:        SavLine(b->b_dot, NullStr);
        !           459:        b->b_char = 0;
        !           460:        AllMarkSet(b, b->b_dot, 0);
        !           461:        if (b == curbuf)
        !           462:                getDOT();
        !           463: }
        !           464: 
        !           465: /* Returns pointer to buffer with name NAME, or if NAME is a string of digits
        !           466:    returns the buffer whose number equals those digits.  Otherwise, returns
        !           467:    0. */
        !           468: 
        !           469: Buffer *
        !           470: buf_exists(name)
        !           471: register char  *name;
        !           472: {
        !           473:        register Buffer *bp;
        !           474:        int     n;
        !           475: 
        !           476:        if (name == 0)
        !           477:                return 0;
        !           478: 
        !           479:        for (bp = world; bp != 0; bp = bp->b_next)
        !           480:                if (strcmp(bp->b_name, name) == 0)
        !           481:                        return bp;
        !           482: 
        !           483:        /* Doesn't match any names.  Try for a buffer number... */
        !           484: 
        !           485:        if (chr_to_int(name, 10, YES, &n) != INT_BAD) {
        !           486:                for (bp = world; n > 1; bp = bp->b_next) {
        !           487:                        if (bp == 0)
        !           488:                                break;
        !           489:                        n -= 1;
        !           490:                }
        !           491:                return bp;
        !           492:        }
        !           493: 
        !           494:        return 0;
        !           495: }
        !           496: 
        !           497: /* Returns buffer pointer with a file name NAME, if one exists.  Stat's the
        !           498:    file and compares inodes, in case NAME is a link, as well as the actual
        !           499:    characters that make up the file name. */
        !           500: 
        !           501: Buffer *
        !           502: file_exists(name)
        !           503: register char  *name;
        !           504: {
        !           505:        struct stat     stbuf;
        !           506:        register struct stat    *s = &stbuf;
        !           507:        register Buffer *b = 0;
        !           508:        char    fnamebuf[FILESIZE];
        !           509: 
        !           510: #if defined(MSDOS)
        !           511:        strlwr(name);
        !           512: #endif /* MSDOS */
        !           513:        if (name) {
        !           514:                PathParse(name, fnamebuf);
        !           515:                if (stat(fnamebuf, s) == -1)
        !           516:                        s->st_ino = 0;
        !           517:                for (b = world; b != 0; b = b->b_next) {
        !           518:                        if (
        !           519: #if !defined(MSDOS)
        !           520:                            (b->b_ino != 0 && b->b_ino == s->st_ino &&
        !           521:                             b->b_dev != 0 && b->b_dev == s->st_dev) ||
        !           522: #endif /* MSDOS */
        !           523:                            (b->b_fname != 0 &&
        !           524:                             strcmp(b->b_fname, fnamebuf) == 0))
        !           525:                                break;
        !           526:                }
        !           527:        }
        !           528:        return b;
        !           529: }
        !           530: 
        !           531: void
        !           532: setbname(b, name)
        !           533: register Buffer        *b;
        !           534: register char  *name;
        !           535: {
        !           536:        UpdModLine = YES;       /* Kludge ... but speeds things up considerably */
        !           537:        if (name) {
        !           538:                if (b->b_name == NoName)
        !           539:                        b->b_name = 0;
        !           540:                b->b_name = ralloc(b->b_name, strlen(name) + 1);
        !           541:                strcpy(b->b_name, name);
        !           542:        } else
        !           543:                b->b_name = 0;
        !           544: #if defined(MAC)
        !           545:        Bufchange = 1;
        !           546: #endif
        !           547: }
        !           548: 
        !           549: void
        !           550: setfname(b, name)
        !           551: register Buffer        *b;
        !           552: register char  *name;
        !           553: {
        !           554:        char    wholename[FILESIZE],
        !           555:                oldname[FILESIZE],
        !           556:                *oldptr = oldname;
        !           557:        Buffer  *save = curbuf;
        !           558: 
        !           559:        SetBuf(b);
        !           560:        UpdModLine = YES;       /* Kludge ... but speeds things up considerably */
        !           561:        if (b->b_fname == 0)
        !           562:                oldptr = 0;
        !           563:        else
        !           564:                strcpy(oldname, b->b_fname);
        !           565:        if (name) {
        !           566: #if defined(MSDOS)
        !           567:                strlwr(name);
        !           568: #endif /* MSDOS */
        !           569:                PathParse(name, wholename);
        !           570:                curbuf->b_fname = ralloc(curbuf->b_fname, strlen(wholename) + 1);
        !           571:                strcpy(curbuf->b_fname, wholename);
        !           572:        } else
        !           573:                b->b_fname = 0;
        !           574:        DoAutoExec(curbuf->b_fname, oldptr);
        !           575:        curbuf->b_mtime = curbuf->b_dev = curbuf->b_ino = 0;    /* until they're known. */
        !           576:        SetBuf(save);
        !           577: #if defined(MAC)
        !           578:        Bufchange = 1;
        !           579: #endif
        !           580: }
        !           581: 
        !           582: void
        !           583: set_ino(b)
        !           584: register Buffer        *b;
        !           585: {
        !           586:        struct stat     stbuf;
        !           587: 
        !           588:        if (b->b_fname == 0 || stat(pr_name(b->b_fname, NO), &stbuf) == -1) {
        !           589:                b->b_dev = 0;
        !           590:                b->b_ino = 0;
        !           591:                b->b_mtime = 0;
        !           592:        } else {
        !           593:                b->b_dev = stbuf.st_dev;
        !           594:                b->b_ino = stbuf.st_ino;
        !           595:                b->b_mtime = stbuf.st_mtime;
        !           596:        }
        !           597: }
        !           598: 
        !           599: /* Find the file `fname' into buf and put in in window `w' */
        !           600: 
        !           601: Buffer *
        !           602: do_find(w, fname, force)
        !           603: register Window        *w;
        !           604: register char  *fname;
        !           605: int    force;
        !           606: {
        !           607:        register Buffer *b;
        !           608: 
        !           609:        b = file_exists(fname);
        !           610:        if (b == 0) {
        !           611:                b = mak_buf();
        !           612:                setfname(b, fname);
        !           613:                bufname(b);
        !           614:                set_ino(b);
        !           615:                b->b_ntbf = 1;
        !           616:        }
        !           617:        if (force) {
        !           618:                Buffer  *oldb = curbuf;
        !           619: 
        !           620:                SetBuf(b);      /* this'll read the file */
        !           621:                SetBuf(oldb);
        !           622:        }
        !           623:        if (w)
        !           624:                tiewind(w, b);
        !           625:        return b;
        !           626: }
        !           627: 
        !           628: /* set alternate buffer */
        !           629: 
        !           630: void
        !           631: SetABuf(b)
        !           632: Buffer *b;
        !           633: {
        !           634:        if (b != 0)
        !           635:                lastbuf = b;
        !           636: }
        !           637: 
        !           638: 
        !           639: /* check to see if BP is a valid buffer pointer */
        !           640: private int
        !           641: valid_bp(bp)
        !           642: register Buffer        *bp;
        !           643: {
        !           644:        register Buffer *b;
        !           645: 
        !           646:        for (b = world; b != 0; b = b->b_next)
        !           647:                if (b == bp)
        !           648:                        break;
        !           649:        return b != 0;
        !           650: }
        !           651: 
        !           652: void
        !           653: SetBuf(newbuf)
        !           654: register Buffer        *newbuf;
        !           655: {
        !           656:        if (newbuf == curbuf || newbuf == 0)
        !           657:                return;
        !           658: 
        !           659:        if (!valid_bp(newbuf))
        !           660:                complain("Internal error: (0x%x) is not a valid buffer pointer!", newbuf);
        !           661:        lsave();
        !           662:        curbuf = newbuf;
        !           663:        curline = newbuf->b_dot;
        !           664:        curchar = newbuf->b_char;
        !           665:        getDOT();
        !           666:        /* do the read now ... */
        !           667:        if (curbuf->b_ntbf)
        !           668:                read_file(curbuf->b_fname, 0);
        !           669: #if defined(MAC)
        !           670:        Modechange = 1;
        !           671: #endif
        !           672: }
        !           673: 
        !           674: Buffer *
        !           675: do_select(w, name)
        !           676: register Window        *w;
        !           677: register char  *name;
        !           678: {
        !           679:        register Buffer *new;
        !           680: 
        !           681:        if ((new = buf_exists(name)) == 0) {
        !           682:                new = mak_buf();
        !           683:                setfname(new, (char *) 0);
        !           684:                setbname(new, name);
        !           685:        }
        !           686:        if (w)
        !           687:                tiewind(w, new);
        !           688:        return new;
        !           689: }
        !           690: 
        !           691: void
        !           692: buf_init()
        !           693: {
        !           694:        SetBuf(do_select(curwind, Mainbuf));
        !           695: }

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