Return to emacs_buf.c CVS log

Up to [Research Unix] / researchv9 / cmd / emacs

Annotation of researchv9/cmd/emacs/emacs_buf.c, revision 1.1

1.1     ! root        1: /* EMACS_MODES: c !fill */
        !             2: #include <signal.h>
        !             3: #include <sys/types.h>
        !             4: #ifndef PC
        !             5: #include <sys/stat.h>
        !             6: #endif PC
        !             7: #include "emacs_io.h"
        !             8: #include "emacs_gb.h"
        !             9: #include "emacs_buf.h"
        !            10: 
        !            11: 
        !            12: 
        !            13: /* leng * length of a line in the buffer */
        !            14: 
        !            15: leng(line)
        !            16: 
        !            17: register int line;
        !            18: 
        !            19: {
        !            20: /* Keywords: line-representation:10 length */
        !            21:        
        !            22:        register char *lp;
        !            23:        register char *olp;
        !            24: 
        !            25:        olp = lp = mkline(line);
        !            26:        while (*lp++ != EOL);
        !            27:        return(lp-olp-1);
        !            28: }
        !            29: 
        !            30: allout ()                              /* break all links */
        !            31: 
        !            32: {
        !            33:        register unsigned *outp;
        !            34:        register int xptr;
        !            35:        register int q;
        !            36: /* Keywords: buffer-representation:50 line-representation:5 paging buffer-changing:10 */
        !            37:        
        !            38:        for (outp = ptrs+nlines; outp > ptrs; outp--) {
        !            39:                xptr = *outp;
        !            40:                if (xptr&01) {
        !            41:                        q = xptr-1;
        !            42:                        *outp = ((bblock[q>>BSHIFT]<<BRSHIFT) + ((q&BMASK)>>LSSHIFT))<<1;
        !            43:                }
        !            44:        }
        !            45: }
        !            46:        
        !            47: 
        !            48: /* mkline -- make a pointer to the current line */
        !            49: 
        !            50: /* pages in the line if out of core, makes a null string for an empty
        !            51: line */
        !            52: 
        !            53: char *
        !            54: 
        !            55: ckline(line,len)
        !            56: int line;
        !            57: int len;
        !            58: /* Keywords: buffer-representation:50 line-representation:50 paging:20 buffer-allocation */
        !            59: 
        !            60: {
        !            61:        register char *lp;
        !            62:        char *lp1;
        !            63:        register char *q;
        !            64:        register int fileadd;
        !            65:        int x;
        !            66:        int s;
        !            67:        
        !            68:        lp = mkline(line);
        !            69:        if (len <= (LSMALL*(*(lp-1))-2)) return(lp);
        !            70:        
        !            71:                                        /* current line is too small */
        !            72:        
        !            73: 
        !            74:        if ((len+2) >= MAXEL) {
        !            75:                error(WARN,33,line,MAXEL-1); /* report problems */
        !            76:                return(NULL);           /* line too long, let caller handle */
        !            77:        }
        !            78:        s = (len+1+LSMALL)>>LSSHIFT;
        !            79:        x = ptrs[line]-1;
        !            80:        
        !            81:        fileadd = (bblock[x>>BSHIFT]<<BRSHIFT) + ((x&BMASK)>>LSSHIFT);
        !            82:        
        !            83:        if ((fileadd + bbuf[0][x]) == BUFEND) {
        !            84:                if ((fileadd & BRMASK) == ((fileadd+s-1)&BRMASK)) {
        !            85:                        
        !            86:                                        /* current line extends in place */
        !            87:                        BUFEND = fileadd + s;
        !            88:                        bbuf [0] [x] = s;
        !            89:                        TRACE(TRCKEX);
        !            90:                        TRACE(line);
        !            91:                        TRACE(s);
        !            92: 
        !            93:                        return (&bbuf[0][x+1]);
        !            94:                }
        !            95:        }
        !            96:        
        !            97:                                        /* must copy to new buffer */
        !            98:        
        !            99:        if ((BUFEND&BRMASK) != ((BUFEND-1+s)&BRMASK)) {
        !           100:                BUFEND = (BUFEND&BRMASK)+BFACT;
        !           101:        }
        !           102:        ptrs[0] = BUFEND<<1;
        !           103:        BUFEND += s;
        !           104:        TRACE(TRCKCP);
        !           105:        TRACE(line);
        !           106:        TRACE(s);
        !           107:        xline = line;                   /* Mark the real line in ptrs[0] */
        !           108:        holdin(0,line);                 /* get both lines in memory */
        !           109:        q = &(bbuf[0][ptrs[line]]);     /* old line buffer */
        !           110:        lp = lp1 = &(bbuf[0][ptrs[0]]);         /* new buffer */
        !           111:        *(lp-1) = s;
        !           112:        s = (*(q-1)*LSMALL);            /* old length */
        !           113:        while (s--) if ((*lp++ = *q++) == EOL) break;
        !           114:        ptrs[line] = ptrs[0];
        !           115:        ptrs[0] = 0;
        !           116:        modify(line);
        !           117:        return(lp1);
        !           118: }
        !           119: 
        !           120: char *
        !           121: 
        !           122: mkl(line)
        !           123: register int line;
        !           124: 
        !           125: {
        !           126:        register char *p;
        !           127:        register int i;
        !           128:        int block;
        !           129:        int newf;
        !           130: /* Keywords: buffer-representation paging line-representation buffer-allocation */
        !           131:        
        !           132:        while (line>nlines) {
        !           133:                sputl(nlines+1,0,line);
        !           134:                if (line >= NPTRS) {
        !           135:                        if (!growbuf(line)) return(NULL);
        !           136:                }
        !           137:                nlines++;
        !           138:                ptrs[nlines] = 0;
        !           139:        }
        !           140: 
        !           141:        if (INMEM(line)) return (&bbuf[0][ptrs[line]]);
        !           142: 
        !           143:        /* no current line */
        !           144: 
        !           145:        nmkline++;                      /* count for stats */
        !           146: 
        !           147:        TRACE(TRMAKE);
        !           148:        TRACE(line);
        !           149: 
        !           150:        if (BUFILE == NULL) {
        !           151:                BUFILE = gtemp(curbf); /* get a temp file */
        !           152:                BUFEND = BFACT;         /* remember 0 == NULL */
        !           153:        }
        !           154:        if (ptrs[line] == 0) {
        !           155:                ptrs[line] = (BUFEND++)<<1; /* assign new buffer */
        !           156:                newf = 1;
        !           157:                TRACE(TRMKEM);
        !           158:        } else newf = 0;
        !           159:        block = ((ptrs[line]))>>(BRSHIFT+1);
        !           160: 
        !           161: /* first see if desired block is in memory already */
        !           162: 
        !           163:        for (i = fbkno; i < NBLOCK; i++) if (block == bblock[i]) {
        !           164:                goto bfill;
        !           165:        }
        !           166: 
        !           167:                                        /* now try to swap in */
        !           168:        
        !           169:        for (i = fbkno; i <= NBLOCK+1; i++) {
        !           170:                if (++nxtflsh >= NBLOCK) nxtflsh = fbkno;
        !           171:                if (bstat[nxtflsh] == 0) {
        !           172:                        bgrab(nxtflsh,block); /* get block in (won't fail)*/
        !           173:                        i = nxtflsh;
        !           174:                        if (line)lowpt[i]=hipt[i]=line;
        !           175:                        else lowpt[i]=hipt[i]=xline;
        !           176:                        goto bfill;
        !           177:                } else bflush(nxtflsh); /* try to force out block */
        !           178:        }
        !           179:        
        !           180: /* can't find a buffer to flush */
        !           181: 
        !           182:        error(FATAL,34);                /* File buffers broken */
        !           183: 
        !           184:        
        !           185: bfill:
        !           186:        p= &bbuf[i][LSMALL*((ptrs[line]>>1)&BRESID)+1];
        !           187:        ptrs[line] = p-bbuf[0];
        !           188:        if (newf) {
        !           189:                *(p-1) = 1;             /* line size */
        !           190:                *(p) = EOL;
        !           191:                modify(line);           /* make sure line is flushed */
        !           192:        }
        !           193:        if (line==0) line = xline;
        !           194:        if (line<lowpt[i])lowpt[i]=line;
        !           195:        if (line > hipt[i])hipt[i] = line;
        !           196:        return(p);
        !           197: }
        !           198: 
        !           199: 
        !           200: /* gtemp -- get a temp file, and unlink it */
        !           201: 
        !           202: gtemp(fn)
        !           203: int fn;
        !           204: {
        !           205: /* Keywords: temporary-files filenames:50 */
        !           206:        
        !           207:        char tfile [64];
        !           208:        register int tf;
        !           209: #ifdef PC
        !           210: retry: seprintf(tfile,"%s:emt.%d",BTEMPATH,fn);
        !           211:        tf = creat(tfile,6);
        !           212:        if (tf < 0) {
        !           213:                ctfile();
        !           214:                goto retry;
        !           215:        }
        !           216: #else
        !           217:        seprintf(tfile,"%s/em.%o.%o",BTEMPATH,fn,getpid());
        !           218:        while ((tf = creat(tfile,0600)) < 0) {
        !           219:                if ((errno != 4) && (errno != 23)) break;
        !           220:        }
        !           221:        close(tf);
        !           222:        while ((tf = open(tfile,2)) < 0) {
        !           223:                if ((errno != 4) && (errno != 23)) break;
        !           224:        }
        !           225:        if (tf < 0) {
        !           226:                error(FATAL,errno,"temp file");
        !           227:        }
        !           228: #ifdef MINFILES
        !           229:        if (fn == NBUF) unlink(tfile);  /* lose the file */
        !           230: #else
        !           231:        unlink(tfile);  /* lose the file */
        !           232: #endif
        !           233: #endif
        !           234:        return(tf);
        !           235: }
        !           236: 
        !           237: #ifdef PC
        !           238: rmtemp()
        !           239: {
        !           240: /* Keywords: temporary-files filenames:20 */
        !           241:        
        !           242:        char tfile[64];
        !           243:        int i;
        !           244:        btmpfile[curbf] = BUFILE;               /* set up for current buffer */
        !           245:        for (i = 0; i < NBUF; i++) if (btmpfile[i]) close(btmpfile[i]);
        !           246:        if (kfile) close(kfile);
        !           247:        for (i = 0; i <= NBUF; i++) {
        !           248:                seprintf(tfile,"%s:emt.%d",BTEMPATH,i);
        !           249:                unlink(tfile);
        !           250:        }
        !           251: }
        !           252: 
        !           253: /* Called on out of space errors, asks for file to delete and continues */
        !           254: 
        !           255: mkspace()
        !           256: {
        !           257:        char *cp;
        !           258:        char filebuf[64];
        !           259:        char tmp[128];
        !           260: /* Keywords: PC-only temporary-files deletion:10 user-interface:50 */
        !           261:        
        !           262:        if (error(WARN,76,BTEMPATH) == 0)  {
        !           263:                cp = getname("File to delete on temp file disk?");
        !           264:                if (cp) {
        !           265:                        mstrcpy(tmp,fnbuf); /* Preserve fnbuf */
        !           266:                        seprintf(filebuf,"%s:%s",BTEMPATH,cp);
        !           267:                        if (unlink(filebuf) == 0) {
        !           268:                                mstrcpy(fnbuf,tmp);
        !           269:                                return(1);
        !           270:                        }
        !           271:                        mstrcpy(fnbuf,tmp);
        !           272:                }
        !           273:        }
        !           274:        return(0);
        !           275: }
        !           276: #endif PC
        !           277: 
        !           278: #ifdef MINFILES
        !           279: rmtemp()
        !           280: {
        !           281: /* Keywords: temporary-files filenames:20 */
        !           282:        char tfile [64];
        !           283:        register int fn;
        !           284:        btmpfile[curbf] = BUFILE;               /* set up for current buffer */
        !           285:        for (fn = 0; fn < NBUF; fn++) {
        !           286:                if (btmpfile[fn]) {
        !           287:                        rftmp(fn);
        !           288:                }
        !           289:        }
        !           290:        rftmp(NBUF);
        !           291: }
        !           292: rftmp(fn)
        !           293: register int fn;
        !           294: {
        !           295: /* Keywords: temporary-files filenames:20 MINFILES-version */
        !           296:        char tfile[64];
        !           297:        seprintf(tfile,"%s/em.%o.%o",BTEMPATH,fn,getpid());
        !           298:        unlink(tfile);
        !           299: }
        !           300: 
        !           301: otemp(fn)
        !           302: int fn;
        !           303: {
        !           304: /* Keywords: temporary-files filenames:20 MINFILES-version */
        !           305:        char tfile [64];
        !           306:        register int tf;
        !           307:        seprintf(tfile,"%s/em.%o.%o",BTEMPATH,fn,getpid());
        !           308:        while ((tf = open(tfile,2)) < 0) {
        !           309:                if ((errno != 4) && (errno != 23)) break;
        !           310:        }
        !           311:        if (tf < 0) {
        !           312:                error(FATAL,errno,"temp file");
        !           313:        }
        !           314:        return(tf);
        !           315: }
        !           316: #endif 
        !           317: 
        !           318: /* utility program to insure that both lines are in memory before proceeding */
        !           319: 
        !           320: holdin(line1,line2)
        !           321: 
        !           322: register int line1,line2;
        !           323: /* Keywords: paging line-representation:10 */
        !           324: 
        !           325: {
        !           326: 
        !           327:        while (OUTMEM(line1) || OUTMEM(line2)) {
        !           328:                 mkline(line1);
        !           329:                 mkline(line2);
        !           330:        }
        !           331: }
        !           332: 
        !           333: /* growbuf -- grow the amount of buffer storage */
        !           334: growbuf(iline)
        !           335: 
        !           336: int iline;
        !           337: /* Keywords: buffer-representation memory-allocation */
        !           338: 
        !           339: {
        !           340:        register unsigned *ndadd;
        !           341:        register int line;
        !           342: 
        !           343:        
        !           344:        line = (iline&BRKMSK)+01000;            /* round up to next multiple
        !           345:                                         * of 512 */
        !           346:        
        !           347:        ndadd = &ptrs[line];            /* new need address */
        !           348: #ifdef PC
        !           349:        if (line >= MPTRS) {
        !           350: #else
        !           351:        if (brk(ndadd) != 0) {
        !           352: #endif PC
        !           353:                line = iline+4;         /* try for less */
        !           354:                ndadd = &ptrs[line];
        !           355: #ifdef PC
        !           356:                if (line >= MPTRS) {
        !           357: #else
        !           358:                if (brk(ndadd) != 0) {
        !           359: #endif PC
        !           360:                        error(NORM,35); /* Too Many lines */
        !           361:                        return(0);
        !           362:                }
        !           363:        }
        !           364:        NPTRS = line;
        !           365:        return(1);
        !           366: 
        !           367: }
        !           368: 
        !           369: 
        !           370: 
        !           371:                
        !           372: /* bgrab -- fill a specific buffer with a specific block */
        !           373: 
        !           374: bgrab(x,blkno)
        !           375: /* Keywords: buffer-representation paging paging-I/O encryption:10 */
        !           376: 
        !           377: register int x;
        !           378: int blkno;
        !           379: {
        !           380:        register int base;
        !           381:        register unsigned *p;
        !           382:        register unsigned *endp;
        !           383: #ifndef pdp11
        !           384:        unsigned bsblock;
        !           385: #else
        !           386:        unsigned short bsblock;
        !           387: #endif
        !           388:        int rstat;
        !           389:        long seekpos;
        !           390:        
        !           391:        TRACE(TRBGRAB);
        !           392:        TRACE(x);
        !           393:        TRACE(blkno);
        !           394:        if (bblock[x]) {                /* if block is occupied */
        !           395:                if (bstat[x]) {
        !           396:                        if (bflush(x)== 0) return(0);
        !           397:                }
        !           398:                base = x*BLEN+1;
        !           399:                bsblock = bblock[x]<<(1+BRSHIFT);
        !           400:                if (hipt[x] > nlines) hipt[x]=nlines; /* Make sure it's in bounds! */
        !           401:                if (lowpt[x] < 0) lowpt[x] = 0; /* likewise */
        !           402:                endp = &ptrs[lowpt[x]];         
        !           403:                for (p= &ptrs[hipt[x]]; p>=endp; p--) {
        !           404:                        if((*p &01) && (((*p - base)&(~BMASK)) == NULL)) {
        !           405:                                *p = bsblock + ((*p - base)>>(LSSHIFT-1));
        !           406:                        }
        !           407:                }
        !           408:                        /* break all links to block */
        !           409: 
        !           410:        }
        !           411:        bblock[x] = blkno;
        !           412:        if (blkno&& (blkno<=mostwrit)) {
        !           413:                if (blkno != sblk) { /* if we must seek */
        !           414:                        TRACE(TRSEEK);
        !           415:                        TRACE(sblk);
        !           416:                        TRACE(blkno);
        !           417:                        seekpos = (long) BLEN * (long) blkno;
        !           418:                        nbseek++;
        !           419:                        lseek(BUFILE,seekpos,0);
        !           420:                }
        !           421:                nbread++;
        !           422:                TRACE(TRREAD);
        !           423:                TRACE(x);
        !           424:                TRACE(blkno);
        !           425:                while ((rstat =read(BUFILE,bbuf[x],BLEN)) != BLEN) {
        !           426:                        if (errno != 4) break;
        !           427:                }
        !           428:                if (rstat != BLEN) error(FATAL,errno,"reading buffer");
        !           429: #ifdef CRYPTO
        !           430:                if (bbuf[x][0]&0200) {
        !           431: 
        !           432: /* First byte of buffer is always a count, and thus shouldn't have the */
        !           433: /* 0200 bit on.  This insures that enciphered bufferes are deciphered */
        !           434: 
        !           435:                        cryptic(&bbuf[x][0]);
        !           436:                        bbuf[x][0] &= 0177; /* Make sure high order bit is off */
        !           437:                }
        !           438: #endif
        !           439:                sblk = blkno+1;
        !           440:        }
        !           441:        return(1);
        !           442: }
        !           443: #ifdef CRYPTO
        !           444: cryptic(cp)
        !           445: register long *cp;                     /* Types deliberately mismatched */
        !           446: {
        !           447: /* Keywords: buffer-representation encryption paging:10 */
        !           448:        
        !           449:        long x;
        !           450:        register long *endp;
        !           451:        
        !           452:        endp = cp + BLEN/sizeof(x);
        !           453:        while (cp < endp) *cp++ ^= bufkey;
        !           454: }
        !           455: #endif
        !           456: /* bflush -- flush contents of a buffer */ 
        !           457: 
        !           458: bflush(x)
        !           459: /* Keywords: buffer-representation paging paging-I/O encryption:10 */
        !           460: 
        !           461: register int x;
        !           462: {
        !           463:        
        !           464:        long seekpos;
        !           465:        if (bstat[x]) {
        !           466: retry:
        !           467:                if (sblk != bblock[x]) {
        !           468:                        seekpos = (long) bblock[x] * (long) BLEN;
        !           469:                        TRACE(TRSEEK);
        !           470:                        TRACE(sblk);
        !           471:                        TRACE(bblock[x]);
        !           472:                        nbseek++;
        !           473:                        lseek(BUFILE,seekpos,0);
        !           474:                }
        !           475: #ifdef CRYPTO
        !           476:                if (crypt) {
        !           477:                        cryptic(&bbuf[x][0]);
        !           478:                        bbuf[x][0] |= 0200;
        !           479:                }
        !           480: #endif CRYPTO
        !           481:                while(write(BUFILE,bbuf[x],BLEN) != BLEN) {
        !           482: #ifdef PC
        !           483:                        if (mkspace()) {
        !           484:                                bblock[x] = -1; /* Don't know where we are */
        !           485:                                goto retry;
        !           486:                        }
        !           487:                        return(0);
        !           488: #else
        !           489:                        if (errno != 4) error(FATAL,errno,"buffer file");
        !           490: #endif                 
        !           491:                }
        !           492: #ifdef CRYPTO
        !           493:                if (bbuf[x][0]&0200) {
        !           494:                        cryptic(&bbuf[x][0]);
        !           495:                        bbuf[x][0] &= 0177; /* Make sure high order bit is off */
        !           496:                }
        !           497: #endif CRYPTO
        !           498:                nbwrite++;
        !           499:                TRACE(TRWRIT);
        !           500:                TRACE(x);
        !           501:                TRACE(bblock[x]);
        !           502:                sblk = bblock[x]+1;
        !           503:                if (bblock[x] > mostwrit) mostwrit = bblock[x];
        !           504:                bstat[x] = 0;
        !           505:        }
        !           506:        return(1);
        !           507: }
        !           508: 
        !           509: /* initializes line buffer free list, ptrs array to empty */
        !           510: 
        !           511: 
        !           512: 
        !           513: bufinit()
        !           514: /* Keywords: buffer-changing:10 buffer-representation buffer-allocation:50 */
        !           515: 
        !           516: {
        !           517:        register int i;
        !           518:        register unsigned *p;
        !           519: 
        !           520: /* now set up buffer stuff */
        !           521: 
        !           522: 
        !           523:        for (p = &ptrs[NPTRS-1]; p >= ptrs; p--) { /* clear ptrs */
        !           524:                *p = 0;
        !           525:        }
        !           526: 
        !           527:        /* set up free buffer line list */
        !           528: 
        !           529:        for (i = fbkno; i < NBLOCK; i++) bstat[i] = bblock[i] = 0;
        !           530:        nxtflsh= NBLOCK;                        /* initial buffer to use */
        !           531:        nlines = 1;
        !           532:        mostwrit = 0;
        !           533:        sblk = 0;
        !           534:        curln = 1;
        !           535:        column = 0;
        !           536:        curblk = 0;
        !           537:        if (BUFILE) BUFEND = BFACT;     /* re-use buffer */
        !           538: }
        !           539: #ifdef PC
        !           540: 
        !           541: /*     change temp file -- change place where temp files are put. */
        !           542: 
        !           543: 
        !           544: ctfile()
        !           545: {
        !           546: /* Keywords: PC-only buffer-representation temporary-files filenames:10 */
        !           547: 
        !           548:        char *cp;
        !           549:        cp = getname("Tempfile Directory? ");
        !           550:        if (cp) {
        !           551:                *BTEMPATH = *cp;
        !           552:        }
        !           553:        if (mostwrit == 0) {
        !           554:                                        /* Re-allocate current buffer */
        !           555:                close(BUFILE);
        !           556:                BUFILE = gtemp(curbf);
        !           557:        }
        !           558: }
        !           559: 
        !           560: #endif PC
        !           561: /* wout -- write out file */
        !           562: 
        !           563: wout(name,aflag)
        !           564: /* Keywords: writing buffer-representation:50 commands:10 PC-only:10 macro-hooks:10 */
        !           565: /* Keywords: encryption:20 unix-interface:10 dired:20 user-interface:10 */
        !           566: 
        !           567: char *name;
        !           568: int aflag;
        !           569: {
        !           570:        FILE outbuf[1];
        !           571:        register FILE *outfile;
        !           572:        register int i;
        !           573:        int nosave;                     /* return value from backup link */
        !           574:        char backb[128];                /* buffer for name of backup file */
        !           575:        char *backp;
        !           576:        char *bp;
        !           577:        register char *cp;
        !           578: #ifndef PC
        !           579:        struct stat inode;              /* status buffer */
        !           580: #endif
        !           581:        int status;
        !           582:        int xstat;      
        !           583:        
        !           584:        if (hooks[Pre_Write_Hook]) {
        !           585:                stkstr(name);
        !           586:                if (hook(Pre_Write_Hook)==0) {
        !           587:                        unprompt();
        !           588:                        return(0);
        !           589:                }
        !           590:                retrvs(fnbuf,FNLEN);
        !           591:                name=fnbuf;
        !           592:        }
        !           593: 
        !           594: #ifdef DIRED
        !           595:        if (diron) return(dclean());
        !           596: #endif
        !           597:        if (*name == NULL) return(0);
        !           598:        bp = name;
        !           599:        cp = backp = backb;
        !           600:        while (*cp = *bp++) {
        !           601:                if (*cp++ == '/') backp = cp;
        !           602:        }
        !           603:        strcpy(backp,"EMACS_save");
        !           604:        nosave = 1;
        !           605:        prompt1("Wait");
        !           606: #ifndef PC
        !           607:        mflush(stdout);
        !           608:        status = stat(name,&inode);             /* get old file modes */
        !           609:                                        /* don't care if file not there */
        !           610: /*     if ((status==0) && (((inode.st_mode &0200) == 0) || (inode.st_uid != myuid))) {*/
        !           611:        if (status == 0) {
        !           612:                if (inode.st_mode & S_IFDIR)  {/* Writing a directory, yuck */
        !           613:                        error(WARN,81,name,name,filename);
        !           614:                        return(0);
        !           615:                }
        !           616:                if (access(name,02) != 0) {
        !           617:                        if (gyn("File not explicitly writeable, write anyway?")<=0) return(0);
        !           618:                }
        !           619:        }
        !           620: #endif PC
        !           621:        if ((aflag>1)||(aflag<-1)) {
        !           622:                outfile = xopen (outbuf,name,"ba");
        !           623:                if (status == 0) goto wfile1; /* if file was there */
        !           624:        }
        !           625: #ifndef PC
        !           626:        if ((status == 0) && streq(filename,name) && 
        !           627:        (mtime[bfnumb()]) && (mtime[bfnumb()] != inode.st_mtime)) {
        !           628:                        
        !           629:                error(WARN,78,name);
        !           630:                return(0);
        !           631:        } 
        !           632:        /* don't prompt if user wants file links saved */
        !           633:        if (savelink) goto wfile;
        !           634:        if ((status== 0) && (inode.st_nlink != 1)) {
        !           635: 
        !           636:                i = gyn("File %s is linked to another, write to both (y) or only to %s ?",name,name);
        !           637:                if (i < 0) return(0);
        !           638:                if (i > 0) goto wfile;
        !           639:        }
        !           640:        
        !           641:        nosave = streq(name,backb);     /* see if we are trying to link backup */
        !           642:        if (nosave==0) {
        !           643:                nosave = link (name,backb);
        !           644: 
        !           645:                /* make backup link to file in case */
        !           646:                /* we crash.  Old copy will be in  
        !           647:                 * EMACS_save if crash occurs during write */
        !           648:                if (nosave == 0) unlink(name);  /* remove old file */
        !           649:        }
        !           650: #endif PC
        !           651: wfile: outfile = xopen (outbuf,name,"bw");
        !           652: wfile1:        if (outfile == NULL) {
        !           653:                error(WARN,errno,name);
        !           654:                return(0);
        !           655:        }
        !           656:        prompt1("Writing");
        !           657:        mflush(stdout);
        !           658: 
        !           659: #ifdef CRYPTO
        !           660:        if (crypt) {
        !           661:                char crbuf[32];
        !           662:                seprintf(crbuf,"crypt %s",cryptkey);
        !           663:                splfile = outfile ->_frn;
        !           664:                if (unx(crbuf,6)<0) return(0);
        !           665:                outfile->_frn = splfile;
        !           666:        }
        !           667: #endif 
        !           668: 
        !           669:        for (i = 1; i <= nlines; i++) {
        !           670:                if (i != 1) {
        !           671: #ifdef PC
        !           672:                        if (BINMODE == 0) putc(CTRLM,outfile);
        !           673: #endif PC
        !           674:                        putc('\n',outfile);
        !           675:                }
        !           676:                cp = mkline(i);
        !           677:                while (*cp != EOL) {
        !           678:                        if (PICMODE && (*cp == ' ')) {
        !           679:                                register int x;
        !           680:                                for (x = 1; cp[x]==' '; x++);
        !           681:                                if (cp[x] == EOL) break;
        !           682:                                while (x--) {
        !           683:                                        putc(*cp,outfile);
        !           684:                                        cp++;
        !           685:                                }
        !           686:                        } else {
        !           687:                                putc(*cp,outfile);
        !           688:                                cp++;
        !           689:                        }
        !           690:                }
        !           691:        }
        !           692:        if (EOFNL) {
        !           693:                cp = mkline(nlines);
        !           694:                if (*cp!=EOL) {
        !           695:                        putc('\n', outfile);
        !           696: #ifdef PC
        !           697:                        if (BINMODE == 0) putc(CTRLM,outfile);
        !           698: #endif PC
        !           699:                }
        !           700:        }
        !           701: #ifdef PC
        !           702:        if (BINMODE == 0) putc('\032',outfile);
        !           703:        mclose(outfile);
        !           704: #else
        !           705:        if (mclose(outfile)) {          /* Error occurred during write */
        !           706:                                        /* Try to put back old file */
        !           707:                if (nosave==0) { /* error writing saved file */
        !           708:                        unlink(name);
        !           709:                        link(backb,name); /* Put everything back */
        !           710:                        unlink(backb);
        !           711:                        prompt1("No write: %s", name);
        !           712:                        return(0);
        !           713:                }
        !           714:                prompt1("File errors: %s", name);
        !           715:                mtime[bfnumb()] = 0; 
        !           716:                return(0);
        !           717:        }
        !           718: 
        !           719: #ifdef CRYPTO
        !           720:        if (crypt) wait(&xstat);        /* Eliminate zombies */
        !           721: #endif
        !           722:        if (nosave == 0) unlink(backb);  /* remove backup link */
        !           723: 
        !           724:        if (status == 0) {
        !           725:                chmod(name,inode.st_mode);/* set modes right */
        !           726:                chown(name,inode.st_uid,inode.st_gid); /* set owner and group */
        !           727:        } else {
        !           728:                chmod(name,0666 & ~mymask);/* Modes by umask */
        !           729:        }
        !           730: #endif PC
        !           731:        if ((aflag<2)&&(aflag>-2)) {
        !           732:                prompt1("Written: %s", name);
        !           733:        }
        !           734:        else prompt1("Appended: %s", name);
        !           735:        NSCHAR=0;
        !           736:        if (aflag>0) {
        !           737:                strcpy(filename,name);
        !           738:                bufmod = 0;
        !           739:        }
        !           740: #ifndef PC
        !           741:        if (streq(filename,name)) {
        !           742:                
        !           743:                if (stat(name,&inode) != 0) {
        !           744:                        error(WARN,errno,name);
        !           745:                } else {
        !           746:                        mtime[bfnumb()] = inode.st_mtime;
        !           747:                }
        !           748:        }
        !           749: #endif
        !           750:        dispmod();
        !           751:        move(curln,column);             /* Restore state information */
        !           752:        return(1);
        !           753: }
        !           754: 
        !           755: /* read in a file into the buffer */
        !           756: /* re-initializes buffer first */
        !           757: 
        !           758: 
        !           759: readin(fn,reinit)
        !           760: 
        !           761: char *fn;
        !           762: int reinit;
        !           763: {
        !           764: 
        !           765: /* Keywords: reading encryption:20 PC-only:10 dired:10 unix-interface:10 commands:10 macro-hooks:10 */
        !           766: 
        !           767:        FILE *filein;
        !           768:        FILE finbuf[1];
        !           769: #ifndef PC
        !           770:        struct stat inode;
        !           771:        int xstat;
        !           772: #endif
        !           773: #ifdef DIRED
        !           774:        extern char dired_args[];
        !           775: #endif
        !           776: 
        !           777:        if (fn[0] == 0) fn =  filename;                 /* default to previous file */
        !           778:        if (fn[0] == 0) return(0);              /* no default */
        !           779: 
        !           780:        if (VERBOSE) {
        !           781:                prompt1 ("Wait");
        !           782:                mflush(stdout);
        !           783:        }
        !           784:        if (hooks[Pre_Read_Hook]) {
        !           785:                stkstr(fn);
        !           786:                if (hook(Pre_Read_Hook) == 0) {
        !           787:                        unprompt();
        !           788:                        return(0);
        !           789:                }
        !           790:                retrvs(fnbuf,FNLEN);
        !           791:                fn = fnbuf;
        !           792:        }
        !           793:        filein = xopen( finbuf,fn,"br");
        !           794:        if (filein == NULL) {
        !           795:                unprompt();
        !           796:                if (reinit>0) error(WARN,errno,fn);
        !           797:                if (filename[0] == 0) {
        !           798:                        strcpy(filename,fn); /* copy name */
        !           799:                        dispmod();
        !           800:                }
        !           801:                return(0);
        !           802:        }
        !           803: #ifndef PC
        !           804:        if (fstat(filein->_frn,&inode) != 0) {
        !           805:                error(WARN,errno,fn);
        !           806:                return(0);
        !           807:        }
        !           808:        if (inode.st_size >= MAXFS) { /* Check for grossly huge file */
        !           809:                error(WARN,77,fn);
        !           810:                return(0);
        !           811:        }
        !           812: #ifndef DIRED
        !           813:        if (inode.st_mode & S_IFDIR) {
        !           814:                                        /* Reading a directory, check to be sure */
        !           815:                if (error(WARN,82,fn)) return(0);
        !           816:                                        /* go ahead and read it if the user wants to */
        !           817:        }
        !           818: #endif
        !           819: #endif
        !           820: #ifdef DIRED
        !           821:        if (inode.st_mode & S_IFDIR) {
        !           822:                char dircom[128];
        !           823:                diron = 1;
        !           824:                splfile = filein ->_frn;
        !           825:                seprintf(dircom,"ls %s %s", dired_args,fn);
        !           826:                if (unx(dircom,7) < 0) return(0);
        !           827:                filein->_frn = splfile;
        !           828:        } else diron = 0;
        !           829: #endif
        !           830:        if (VERBOSE) {
        !           831:                prompt1("Reading");
        !           832:                mflush(stdout);
        !           833:        }
        !           834:        if (reinit == -1) reinit = 1;
        !           835:        if (reinit == 1) bufinit();
        !           836: #ifdef CRYPTO
        !           837:        if (crypt) {
        !           838:                char crbuf[32];
        !           839:                seprintf(crbuf,"crypt %s",cryptkey);
        !           840:                splfile = filein->_frn;
        !           841:                if (unx(crbuf ,7)<0) return(0);
        !           842:                filein->_frn = splfile;
        !           843:        }
        !           844: #endif 
        !           845:        readsub(filein,reinit,fn,0);            /* do the reading */
        !           846: #ifdef CRYPTO
        !           847:        if (crypt) wait(&xstat);                        /* Eliminate zombies */
        !           848: #endif 
        !           849: #ifdef DIRED
        !           850:        if (diron) wait(&xstat);        /* Eliminate zombies */
        !           851: #endif 
        !           852: #ifndef PC
        !           853:        if (streq(filename,fn)) {
        !           854:                struct stat ninode;
        !           855:                mtime[bfnumb()] = inode.st_mtime;
        !           856:                if (stat(fn,&ninode) != 0) {
        !           857:                        error(WARN,errno,fn);
        !           858:                } else {
        !           859:                        if ((ninode.st_mtime != inode.st_mtime)||
        !           860:                            (ninode.st_ino   != inode.st_ino))  {
        !           861:                                error(WARN,79,fn);
        !           862:                        }
        !           863:                }
        !           864:        }
        !           865: #endif
        !           866:        unprompt();
        !           867:        ttfill();                       /* try to read ahead*/
        !           868:        if (hooks[Post_Read_Hook]) hook (Post_Read_Hook);
        !           869:        return(1);
        !           870: }
        !           871: 
        !           872: 
        !           873: readsub(filein,reinit,fn,cpyflag)
        !           874: /* Keywords: reading buffer-representation:5 unix-interface:20 dired:30 file-modes:10 */
        !           875: 
        !           876: int reinit;
        !           877: #ifndef pdp11
        !           878: register
        !           879: #endif
        !           880: int cpyflag;
        !           881: register FILE *filein;
        !           882: char *fn;
        !           883: {
        !           884:        register int c;
        !           885:        int i;
        !           886:        char fbuf[MAXEL];
        !           887:        register char *fp;
        !           888:        register char *endbuf;
        !           889:        int warnl;
        !           890:        
        !           891:        i = curln;
        !           892:        if (reinit != 1) {
        !           893:                RARE = 1;                       /* turn off trouble */
        !           894:                while ((c = getc(filein)) != EOF) {
        !           895: #ifdef PC
        !           896:                        if (BINMODE == 0){
        !           897:                                if (c == '\032') break;
        !           898:                                if (c == '\n') bdel(1); /* Wipe out spurious cr */
        !           899:                                
        !           900:                        }
        !           901: #endif PC
        !           902:                        if (cpyflag) putchar(c); /* output character */
        !           903:                        put(c);
        !           904:                        if (c == EOL) clptr = mkline(curln);
        !           905:                }
        !           906:        } else {
        !           907:                if (BUFILE == NULL) {
        !           908:                        BUFILE = gtemp(curbf); /* get a temp file */
        !           909:                }
        !           910:                BUFEND = BFACT;         /* remember 0 == NULL */
        !           911:                fp = &fbuf[0];  
        !           912:                endbuf = fbuf+MAXEL-2;
        !           913:                warnl = -1;                     /* last "line too long" */
        !           914:                while ((c = getc(filein)) != EOF) {
        !           915: #ifdef PC
        !           916:                        if (BINMODE == 0){
        !           917:                                if (c == '\032') break;
        !           918:                                if (c == '\n') fp--; /* Wipe out trailing CR */
        !           919:                        }
        !           920: #endif PC
        !           921:                        if (cpyflag) putchar(c); /* echo to terminal */
        !           922: 
        !           923:                        if (c == '\n') {
        !           924:                                *fp = EOL;
        !           925:                                if (addline(fbuf,fp-fbuf,i++)==0) goto eof;
        !           926:                                fp = &fbuf[0];
        !           927:                        } else {
        !           928: #ifdef DIRED
        !           929:                                if (diron) while (fp-fbuf < 4) *fp++ = ' '; /* make room for markings */
        !           930: 
        !           931: #endif
        !           932:                                *fp++ = c;
        !           933:                                if (fp >= endbuf) {
        !           934:                                        fp--;
        !           935:                                        if (i == warnl) continue;
        !           936:                                        warnl = i;
        !           937:                                        if(error(NORM,33,i,MAXEL-1)) goto eof;
        !           938:                                        continue;
        !           939:                                }
        !           940:                        }
        !           941:                }
        !           942: eof:           *fp = EOL;
        !           943:                addline(fbuf,fp-fbuf,i);
        !           944:                move(1,0);
        !           945:                strncpy(filename,fn,FNLEN); /* Copy name written */
        !           946:                bufmod = 0;             /* buffer up to date */
        !           947:        }
        !           948:        mclose(filein);
        !           949:        if (cpyflag) mflush(stdout);    /* Force output to come out */
        !           950:        NSCHAR = 0;
        !           951:        bfmodes();      /* set buffer modes */
        !           952:        fclear();       /* file is now bad */
        !           953:        RARE = 0;       /* normal modes back on */
        !           954: }
        !           955: 
        !           956: /* Express access to the buffer.  This code plunks in one line at
        !           957:  * the end of the buffer, manipulating all appropriate data, much
        !           958:  * swifter than the usual ckline-bgrab sequence.  What is assumed by
        !           959:  * this function is that it is called after bufinit and no other
        !           960:  * intervening buffer manipulations.  It leaves the ptrs array set
        !           961:  * up with no lines in memory, but with the last n blocks of the
        !           962:  * file in bbuf and properly initialized.   */
        !           963: 
        !           964: 
        !           965: 
        !           966: 
        !           967: addline(cp,len,line)
        !           968: register char *cp;
        !           969: int len;
        !           970: int line;
        !           971: {
        !           972: /* Keywords: buffer-representation:50 line-representation:20 reading:10 buffer-allocation:20 */
        !           973: 
        !           974:        register char *lp;
        !           975:        register int x;
        !           976:        register int s;
        !           977: 
        !           978:        if (line >= NPTRS) {
        !           979:                if (!growbuf(line)) {
        !           980:                        error(NORM,35);
        !           981:                        return(0);
        !           982:                }
        !           983:        }
        !           984:        nlines=line;
        !           985:        
        !           986:        s = (len+1+LSMALL)>>LSSHIFT;
        !           987:        if (((BUFEND-1) & BRMASK) != ((BUFEND+s-1)&BRMASK)) {
        !           988: 
        !           989: /* Need to go into the next block */
        !           990:                
        !           991:                nxtflsh++;
        !           992:                if (nxtflsh>=NBLOCK) nxtflsh=fbkno;
        !           993:                x = nxtflsh;
        !           994:                bflush(x);
        !           995:                BUFEND=((BUFEND-1)&BRMASK)+BFACT;
        !           996:                bstat[x]=1;
        !           997:                lowpt[x]=hipt[x]=line;
        !           998:                bblock[x]=(BUFEND>>BRSHIFT);
        !           999:        }
        !          1000:        ptrs[nlines] = BUFEND<<1;
        !          1001:        lp = &bbuf[nxtflsh][((BUFEND&BRESID)<<LSSHIFT)];
        !          1002:        *lp++ = s;                      /* save size */
        !          1003:        while ((*lp++ = *cp++) != EOL); /* copy the line */
        !          1004:        BUFEND += s;
        !          1005:        return(1);
        !          1006: }
        !          1007: 
        !          1008: 
        !          1009: 
        !          1010: /* findf -- go forward to find row and columns */
        !          1011: 
        !          1012: /* leaves kline, kcol pointing at the character count characters ahead
        !          1013: of curln, column */
        !          1014: 
        !          1015: 
        !          1016: findf(count)
        !          1017: 
        !          1018: register int count;
        !          1019: /* Keywords: buffer-representation:10 movement:20 commands:10 forwards */
        !          1020: 
        !          1021: {
        !          1022:        kmark();
        !          1023:        while (count--) {
        !          1024:                if (*klptr++ != EOL) kcol++;
        !          1025:                else {
        !          1026:                        if (kline == nlines) return(0);
        !          1027:                        kcol = 0;
        !          1028:                        ++kline;
        !          1029:                        klptr = mkline(kline);
        !          1030:                }
        !          1031:        }
        !          1032:        return(1);
        !          1033: }
        !          1034: 
        !          1035: /* findb -- go back n chars */
        !          1036: 
        !          1037: /* leaves kline, kcol pointing at the character count characters before
        !          1038: the current character */
        !          1039: /* Keywords: buffer-representation:10 movement:20 commands:10 backwards */
        !          1040: findb(count)
        !          1041: 
        !          1042: register int count;
        !          1043: 
        !          1044: {
        !          1045:        kline = curln;
        !          1046:        kcol = column;
        !          1047:        
        !          1048:        while (count) {
        !          1049:                if (count > kcol) {
        !          1050:                        count-=(kcol+1);        /*plus one for the nl */
        !          1051:                        kcol = 0;
        !          1052:                        if (kline == 1) return(0);
        !          1053:                        kline--;
        !          1054:                        kcol = leng(kline);
        !          1055:                } else {
        !          1056:                        kcol -= count;
        !          1057:                        return(1);
        !          1058:                }
        !          1059:        }
        !          1060:        return(1);
        !          1061: }
        !          1062: 
        !          1063: 
        !          1064: /* mark a line as modified (also re-displays mode line if necessary) */
        !          1065: 
        !          1066: 
        !          1067: modify(line)
        !          1068: /* Keywords: buffer-representation:10 dired:20 mode-line:10 deletion:10 insertion:10 */
        !          1069: 
        !          1070: register int line;
        !          1071: 
        !          1072: {
        !          1073:        
        !          1074:        if (INMEM(line)) {
        !          1075:                bstat[(ptrs[line])>>BSHIFT] = 1;
        !          1076:        }
        !          1077: #ifdef DIRED
        !          1078:        if (diron) {
        !          1079:                register char *lp;
        !          1080:                lp = mkline(line);
        !          1081:                if ((column > 4) && (column < 14)) {
        !          1082:                        lp[1] = 'M';
        !          1083:                } else if ((column > 18) && (column < 36)) {
        !          1084:                        lp[2] = 'O';
        !          1085:                }
        !          1086:                sputl(line,1,line);     /* refresh */
        !          1087:        }
        !          1088: #endif
        !          1089:        if (bufmod == 0) {
        !          1090:                bufmod++;
        !          1091:                dispmod();
        !          1092:        }
        !          1093: }
        !          1094: 
        !          1095: /* stack text segment on kill stack */
        !          1096: 
        !          1097: /* the kill stack holds up to NKILLP segments, or a total of KBSIZE
        !          1098:  * characters.  killstk adds the segment delimited by its arguments to
        !          1099:  * this stack */
        !          1100: 
        !          1101: killstk(a,b,c,d)
        !          1102: /* Keywords: killstack stacking picture-mode:10 deletion:10 */
        !          1103: 
        !          1104: register int a;
        !          1105: register int b;
        !          1106: int c;
        !          1107: int d;
        !          1108: 
        !          1109: {
        !          1110:        register char *ap;
        !          1111:        
        !          1112:        if (kbapp) {                    /* if appending */
        !          1113:                kend--;                 /* backspace over the \0 */
        !          1114:        } else {
        !          1115:                if (nkp == NKILLP)  {   /* no more kill pointers available */
        !          1116:                        mvdown();
        !          1117:                }
        !          1118:                nkp++;
        !          1119:                kstk[nkp] = kend;               /* start of saved text */
        !          1120:        }
        !          1121:        kget(kend);
        !          1122: 
        !          1123:        if (PICMODE) {
        !          1124:                int x;
        !          1125:                if (b>d) {
        !          1126:                        x=d;
        !          1127:                        d=b;
        !          1128:                        b=x;
        !          1129:                }
        !          1130:                while (a <= c) {
        !          1131:                        ap = mkline(a);
        !          1132:                        a++;
        !          1133:                        for (x = 0; x < d; x++) {
        !          1134:                                if (x<b) {
        !          1135:                                        if (*ap != EOL) ap++;
        !          1136:                                } else {
        !          1137:                                        if (*ap != EOL) {
        !          1138:                                                kbuf[kptr++] = *ap++;
        !          1139:                                        } else {
        !          1140:                                                kbuf[kptr++] = ' ';
        !          1141:                                        }
        !          1142:                                        kbmod=1;
        !          1143:                                        if (kptr>=KBSIZE) knext();
        !          1144:                                }        
        !          1145:                        }         
        !          1146:                        if (a<=c) {
        !          1147:                                kbmod=1;
        !          1148:                                kbuf[kptr++] = EOL;
        !          1149:                                if (kptr>=KBSIZE) knext();
        !          1150:                        }        
        !          1151:                }         
        !          1152:        } else {    
        !          1153:                ap = mkline(a);
        !          1154:                while ((a < c) || (b < d) ) {
        !          1155:                        if ((kbuf[kptr] = ap[b++]) == EOL) {
        !          1156:                                ++a;     
        !          1157:                                ap = mkline(a);
        !          1158:                                b = 0;  
        !          1159:                        }        
        !          1160:                        kbmod = 1;
        !          1161:                        if (++kptr>=KBSIZE) {
        !          1162:                                knext();
        !          1163:                        }        
        !          1164:                }         
        !          1165:        }          
        !          1166:        kbapp = 0;                      /* don't turn on append for now */
        !          1167:        kbuf[kptr++] = 0;
        !          1168:        kbmod = 1; 
        !          1169:        if (kptr>=KBSIZE) {
        !          1170:                knext();  
        !          1171:        }          
        !          1172:        kend = (long)kptr + kbase;
        !          1173: }
        !          1174: stkstr(sp)
        !          1175: /* Keywords: killstack stacking macro-programming:50 */
        !          1176: 
        !          1177: register char *sp;
        !          1178: {
        !          1179:        register char c;
        !          1180:        
        !          1181:        if (kbapp) {                    /* if appending */
        !          1182:                kend--;                 /* backspace over the \0 */
        !          1183:        } else {
        !          1184:                if (nkp == NKILLP)  {   /* no more kill pointers available */
        !          1185:                        mvdown();
        !          1186:                }
        !          1187:                nkp++;
        !          1188:                kstk[nkp] = kend;               /* start of saved text */
        !          1189:        }
        !          1190:        kget(kend);
        !          1191:        do {
        !          1192:                c = kbuf[kptr++] = *sp++;
        !          1193:                kbmod = 1;
        !          1194:                if (kptr>=KBSIZE) knext();
        !          1195:        } while (c);
        !          1196:        kend = (long)kptr + kbase;
        !          1197:        kbapp = 0;
        !          1198: }
        !          1199: 
        !          1200: kput(ptr)
        !          1201: unsigned int ptr;
        !          1202: {
        !          1203: /* Keywords: killstack stacking string-variables macro-programming:20 */
        !          1204:        
        !          1205:        long real_ptr;
        !          1206:        int x;
        !          1207: 
        !          1208:        if (sizeof(x) < 4) {            /* If int's are only 16 bits, adjust ptr */
        !          1209:                
        !          1210:                real_ptr = kend & 0177777;
        !          1211:                if (real_ptr > ptr) real_ptr = ((long) ptr) + (kend & 037777600000);
        !          1212:                else real_ptr = ((long) ptr) + (kend & 037777600000) -65536;
        !          1213:        } else real_ptr = ptr;
        !          1214: 
        !          1215:        if ((real_ptr < 0) || (real_ptr >= kend)) {
        !          1216:                error (WARN,82);
        !          1217:                real_ptr = 0;
        !          1218:        }
        !          1219:        if (nkp == NKILLP)  {   /* no more kill pointers available */
        !          1220:                mvdown();
        !          1221:        }
        !          1222:        nkp++;
        !          1223:        kstk[nkp] = real_ptr;           /* start of saved text */
        !          1224: }
        !          1225: kgptr()
        !          1226: {
        !          1227: /* Keywords: killstack stacking insertion:10 retrieval:10 string-variables:10 */
        !          1228:        if (nkp>-1) {
        !          1229:                nkp--;
        !          1230:                return(kstk[nkp+1]);
        !          1231:        } else {
        !          1232:                return(0);                      /* Error, too many pops */
        !          1233:        }
        !          1234: }
        !          1235: 
        !          1236:        
        !          1237: 
        !          1238: /* kapp -- append to kill buffer */
        !          1239: 
        !          1240: kapp()
        !          1241: {
        !          1242: /* Keywords: commands killstack appending */
        !          1243:        
        !          1244:        kbapp = 2;                      /* force next kill to append */
        !          1245: }
        !          1246: 
        !          1247: /*knext -- next kill buffer*/
        !          1248: 
        !          1249: 
        !          1250: knext()
        !          1251: {
        !          1252:        long nbase;
        !          1253: /* Keywords: killstack paging */
        !          1254:        
        !          1255:        nbase = kbase + (long) KBSIZE;
        !          1256:        if (nbase >= KBLIM) nbase = 0;
        !          1257:        kget(nbase);
        !          1258: }
        !          1259: 
        !          1260: 
        !          1261: /* kget get next kill buffer */
        !          1262: 
        !          1263: kget(nbase)
        !          1264: long nbase;
        !          1265: {
        !          1266: /* Keywords: killstack paging paging-I/O */
        !          1267:        
        !          1268:        register long xbase;
        !          1269:        int st;
        !          1270:        
        !          1271: #ifdef univac                                          /* MZ */
        !          1272:        xbase = nbase & 0xffffffe00;    /* Univac uses one's compliment. */
        !          1273: #else                                  /* MZ */
        !          1274:        xbase = nbase &( (long) -KBSIZE);
        !          1275: #endif                                 /* MZ */
        !          1276: 
        !          1277:        if (xbase == kbase) {
        !          1278:                kptr = nbase - kbase;
        !          1279:                return;
        !          1280:        }
        !          1281:        if (kfile == 0) {
        !          1282:                kfile = gtemp(NBUF);
        !          1283:        }
        !          1284:        if (kbmod) {
        !          1285: retry:         lseek(kfile,kbase,0);
        !          1286:                while(write(kfile,kbuf,KBSIZE) != KBSIZE) {
        !          1287: #ifdef PC
        !          1288:                        if (mkspace()) goto retry;
        !          1289:                        break;
        !          1290: #else
        !          1291:                        if (errno != 4) error(FATAL,errno,"kill buffer");
        !          1292: #endif
        !          1293:                }
        !          1294:                if (kbase >= kbwrt) kbwrt = kbase+KBSIZE;
        !          1295:                kbmod = 0;
        !          1296:        }
        !          1297:        if (nbase < kbwrt) {
        !          1298:                lseek(kfile,xbase,0);
        !          1299:                while((st=read(kfile,kbuf,KBSIZE) != KBSIZE)) {
        !          1300:                        if (errno != 4) {
        !          1301:                                error(FATAL,errno,"reading kill buffer");
        !          1302:                                return;
        !          1303:                        }
        !          1304:                }
        !          1305:        }
        !          1306:        kbase = xbase;
        !          1307:        kptr = nbase-xbase;
        !          1308:        return;
        !          1309: }
        !          1310: 
        !          1311: /* mvdown pushes the bottom text segment off of the kill stack */
        !          1312: 
        !          1313: 
        !          1314: 
        !          1315: mvdown()               /* move down kill stack */
        !          1316: /* Keywords: killstack stacking */
        !          1317: 
        !          1318: {
        !          1319:        register int i;
        !          1320:        for (i = 0; i <= nkp; i++) kstk[i] = kstk[i+1];
        !          1321:        nkp--;
        !          1322: }
        !          1323: 
        !          1324: /* retrv retrieves the top text segment from the kill stack and inserts
        !          1325:   * it into the buffer at the current location */
        !          1326: 
        !          1327: 
        !          1328: retrv()        /* retrieve from kill stack */
        !          1329: /* Keywords: commands killstack picture-mode:20 insertion:10 retrieval */
        !          1330: 
        !          1331: {
        !          1332:        register char c;
        !          1333:        register int oldcol,oldln;
        !          1334:        
        !          1335:        if (nkp <0) return(0);          /* nothing in the kill stack */
        !          1336:        RARE = 1;                       /* turn off trouble */
        !          1337:        oldln = curln;
        !          1338:        oldcol = column;
        !          1339:        kget(kstk[nkp]);
        !          1340:        while (c= kbuf[kptr]) {
        !          1341:                if (PICMODE) {
        !          1342:                        if (c==EOL) {
        !          1343:                                move(++curln,0);
        !          1344:                                lext(curln,oldcol);
        !          1345:                        } else {
        !          1346:                                insertc(1,c);
        !          1347:                        }
        !          1348:                } else {
        !          1349:                        if(put(c)==0) break;
        !          1350:                }
        !          1351:                if (++kptr >= KBSIZE) {
        !          1352:                        knext();
        !          1353:                }
        !          1354:        }
        !          1355:        RARE = 0;                       /* normal modes back on */
        !          1356:        unins(oldln,oldcol);
        !          1357:        return(1);                              /* done */
        !          1358: }
        !          1359: 
        !          1360: retrvs(strp,mc)                        /* retrieve from kill stack */
        !          1361: /* Keywords: commands killstack macro-programming retrieval */
        !          1362: 
        !          1363: register char *strp;
        !          1364: register int mc;
        !          1365: {
        !          1366:        register int nc;
        !          1367: 
        !          1368:        nc = 0;
        !          1369: 
        !          1370: 
        !          1371:        kget(kstk[nkp]);
        !          1372:        while (*strp++ = kbuf[kptr]) {
        !          1373:                if (++nc >= mc) {
        !          1374:                        *(--strp) = 0; /* finish off string */
        !          1375:                        error(WARN,63); /* file name too big */
        !          1376:                        break;          /* break loop */
        !          1377:                }
        !          1378:                if (++kptr >= KBSIZE) {
        !          1379:                        knext();
        !          1380:                }
        !          1381:        }
        !          1382:        kpop();                         /* pop the kill stack */
        !          1383:        if (etrace) {
        !          1384:                putout("Retrieved %s from kill stack",strp-nc-1);
        !          1385:        }
        !          1386:        return(nc);                             /* done */
        !          1387: }
        !          1388: 
        !          1389: /* kpop pops the top item off of the kill stack */
        !          1390: kpop()
        !          1391: /* Keywords: commands killstack stacking popping */
        !          1392: 
        !          1393: {
        !          1394:        if (nkp>-1) {
        !          1395:                nkp--;
        !          1396:                return(1);
        !          1397:        } else return(0);
        !          1398: }
        !          1399: 
        !          1400: /* fsave saves the buffer if it has been modified since last read or write */
        !          1401: 
        !          1402: 
        !          1403: fsave(arg)
        !          1404: register int arg;
        !          1405: {
        !          1406: /* Keywords: commands buffers files writing:50 saving dired:10 */
        !          1407:        
        !          1408:        if ((arg == 0) && (streq(bbfname[curbf],".exec"))) return(0);
        !          1409: 
        !          1410: #ifdef DIRED
        !          1411:        if (diron) return(dclean());
        !          1412: #endif
        !          1413:        if (READONLY) {
        !          1414:                if (arg) error(WARN,71);
        !          1415:                return(0);
        !          1416:        }
        !          1417:        if (bufmod && (*filename== 0)) {
        !          1418:                if (infrn == 0) return(fright(1)); /* no file name */
        !          1419:                error(WARN,65,bufname); /* Don't read the file name in a macro */
        !          1420:                return(0);
        !          1421:        }
        !          1422: 
        !          1423:        if (bufmod) {
        !          1424:                return(wout(filename,1));
        !          1425:        } else {
        !          1426:                if (arg == 0) return(1);
        !          1427:                prompt1("File %s is up to date",filename);
        !          1428:                return(1);
        !          1429:        }
        !          1430: }
        !          1431: 
        !          1432: /* fname, bname, and modded return the current file, buffer, and buffer
        !          1433:  * modified flags */
        !          1434: 
        !          1435: 
        !          1436: char *
        !          1437: fname()
        !          1438: {
        !          1439:        return(filename);
        !          1440: }
        !          1441: char *
        !          1442: bname()
        !          1443: {
        !          1444:        return(bufname);
        !          1445: }
        !          1446: int
        !          1447: bfnumb()
        !          1448: {
        !          1449:        return(curbf);
        !          1450: }
        !          1451: int
        !          1452: modded()
        !          1453: {
        !          1454:        if (bufmod) return(1);
        !          1455:        else return(0);
        !          1456: }
        !          1457: 
        !          1458: /* chbuf moves to a new buffer denoted by the buffer number of its
        !          1459:  * argument */
        !          1460: 
        !          1461: /* each buffer has a filename, buffername, modified flag, current
        !          1462:  * position, and size,  The ptrs array of a non-active buffer is stored in
        !          1463:  * the temp file for the buffer.
        !          1464:  */
        !          1465: 
        !          1466: chbuf(x)
        !          1467: 
        !          1468: register int x;
        !          1469: /* Keywords: buffers:50 buffer-representation buffer-changing unix-interface macro-hooks:10 */
        !          1470: 
        !          1471: {
        !          1472:        register int i;
        !          1473:        register int rx;
        !          1474:        unsigned cpointer;
        !          1475: 
        !          1476:        
        !          1477:        if (SAVEMD) IGNORE(fsave(0)); /* save buffer */
        !          1478:        if (hooks[Leave_Buffer_Hook]) hook(Leave_Buffer_Hook);
        !          1479:        for (i = fbkno; i < NBLOCK; i++) bflush(i);
        !          1480:        allout();
        !          1481:        NSCHAR = 0;
        !          1482:        btmpfile[curbf] = BUFILE;
        !          1483:        btmpfree[curbf] = BUFEND;
        !          1484:        bcurln[curbf] = curln;
        !          1485:        bcolumn[curbf] = column;
        !          1486:        if (BUFILE) {
        !          1487:                while (1) {
        !          1488:                        lseek(BUFILE,(long)((long) BUFEND * (long) LSMALL),0);
        !          1489:                        rx = write(BUFILE,(char *)ptrs,(nlines+1)*(sizeof cpointer));
        !          1490:                        if (rx == (nlines+1)*(sizeof cpointer)) break;
        !          1491: #ifdef PC
        !          1492:                        mkspace();
        !          1493: #endif
        !          1494:                }
        !          1495:        }
        !          1496:        bnlines[curbf] = nlines;
        !          1497: #ifdef MINFILES
        !          1498:        if (BUFILE) close(BUFILE);
        !          1499:        if (btmpfile[x]) btmpfile[x] = otemp(x);
        !          1500: #endif 
        !          1501:        curbf = x;
        !          1502:        bufinit();
        !          1503:        
        !          1504:        BUFEND = btmpfree[x];
        !          1505:        mostwrit = ((BUFEND-1)/BFACT);
        !          1506:        BUFILE = btmpfile[x];
        !          1507:        nlines = bnlines[x];
        !          1508:        if (BUFILE) {
        !          1509:                while (1) {
        !          1510:                        lseek(BUFILE, (long)((long) BUFEND * (long) LSMALL),  0);
        !          1511:                        rx = read(BUFILE,(char *)ptrs, (nlines+1)*(sizeof cpointer));
        !          1512:                        if (rx ==(nlines+1)*(sizeof cpointer)) break;
        !          1513:                        if (errno != 4) error (FATAL,errno,"Reading line pointers");
        !          1514:                }
        !          1515:        }
        !          1516:        
        !          1517:        bfmodes();                      /* set buffer modes */
        !          1518:        move(bcurln[x],bcolumn[x]);
        !          1519:        if (bnlines[x] == 0) bufmod = 0; /* EMPTY BUFFERS CAN'T HAVE BEEN MODIFIED!!!! */
        !          1520:        if (hooks[Enter_Buffer_Hook]) hook(Enter_Buffer_Hook);
        !          1521: }
        !          1522: 
        !          1523: /* chgbuf changes buffers by name.  If no buffer of the right name
        !          1524:  * exists, one is made */
        !          1525: 
        !          1526: 
        !          1527: chgbuf(sp)
        !          1528: /* Keywords: buffers commands:10 buffer-representation:20 */
        !          1529: 
        !          1530: char *sp;
        !          1531: 
        !          1532: {
        !          1533:        int i;
        !          1534:        i = finbuf(sp,1);
        !          1535:        if (i >= 0) {
        !          1536:                chbuf(i);
        !          1537:                return(1);
        !          1538:        }
        !          1539:        return(0);
        !          1540: }
        !          1541: 
        !          1542: 
        !          1543: finbuf(sp,crflg)
        !          1544: /* Keywords: commands:20 buffers:50 files:50 reading:20 buffer-changing */
        !          1545: 
        !          1546: char *sp;
        !          1547: int crflg;
        !          1548: {
        !          1549:        register int ep = -1;
        !          1550:        register int i;
        !          1551:        
        !          1552:        if (*sp == 0) {
        !          1553:                error(WARN,36);
        !          1554:                return(-1);
        !          1555:                }
        !          1556:        for (i = 0; i < NBUF; i++) {
        !          1557:                if (streq(sp,bbfname[i])) {
        !          1558:                        return(i);
        !          1559:                }
        !          1560:                if ((ep < 0) && (bbfname[i] [0] == 0)) ep = i;
        !          1561:        }
        !          1562:        i = aint(sp);                   /* try numeric buffer name */
        !          1563:        if ((i < NBUF) && (i >= 0)) {
        !          1564:                if (bbfname[i] [0] == 0) {
        !          1565:                        inibuf(i);
        !          1566:                        seprintf(bbfname[i],"%d",i); /* name buffer */
        !          1567:                }
        !          1568:                return(i);
        !          1569:        }
        !          1570:        if (crflg == 0) return(-1);     /* Don't create new buffer */
        !          1571:        if (crflg < 0) {                /* Complain about buffer */
        !          1572:                error(WARN,39,sp);
        !          1573:                return(-1);
        !          1574:        }
        !          1575:        
        !          1576: /* Buffer does not now exist, create it */
        !          1577:        
        !          1578:        if (ep>=0) {
        !          1579:                inibuf(ep);
        !          1580:                if (streq(sp,"...")) seprintf(bbfname[ep],"%d",ep);
        !          1581:                else strcpy(bbfname[ep],sp);
        !          1582:                return(ep);
        !          1583:        } else {
        !          1584:                error(WARN,37,NBUF);
        !          1585:                return(-1);
        !          1586:        }
        !          1587: }
        !          1588: 
        !          1589: /* inibuf -- initialize buffer data */
        !          1590: 
        !          1591: inibuf(ep)
        !          1592: register int ep;                               /* buffer number  */
        !          1593: /* Keywords: buffer-representation buffers commands:10 */
        !          1594: 
        !          1595: {
        !          1596:        bbfname[ep] [0] = 0;
        !          1597:        btmpfree[ep] = 0;
        !          1598:        bcurln[ep] = bcolumn[ep] = 0;
        !          1599:        bnlines[ep] = 0;
        !          1600:        bbfmod[ep] = 0;
        !          1601:        bfilname[ep] [0] = 0;
        !          1602:        mtime[ep] = 0;
        !          1603: }
        !          1604: 
        !          1605: /* edbuf is the find file command, it asks for a filename, finds a
        !          1606:  * buffer containing the file if it exists, otherwise it makes a new buffer
        !          1607:  * to hold the file */
        !          1608: 
        !          1609: edbuf(arg)
        !          1610: /* Keywords: commands buffers buffer-changing reading:10 files dired:20 */
        !          1611: 
        !          1612: int arg;
        !          1613: {
        !          1614:        register int i;
        !          1615:        int retv;
        !          1616:        int exists;
        !          1617:        char *sp;
        !          1618: #ifdef DIRED
        !          1619:        char nbuf[256];
        !          1620: #endif
        !          1621:        exists = 0;
        !          1622:        sp = expenv(getname("Filename to Find? "));
        !          1623:        if (sp == NULL) return(0);
        !          1624: #ifdef DIRED
        !          1625:        if (*sp != '/') {
        !          1626:                catstr(nbuf,filename,sp); /* relative path */
        !          1627:                if ((nbuf[0] == '.') && (nbuf[1] == '/')) sp = nbuf+2;
        !          1628:                else sp = nbuf;
        !          1629:        }
        !          1630: #endif
        !          1631:        for (i = 0; i < NBUF; i++) {
        !          1632:                if (streq(bfilname[i], sp)) {
        !          1633:                        chbuf(i);
        !          1634:                        if (arg > 1) return(readin(sp,1));
        !          1635:                        return(1);
        !          1636:                }
        !          1637:                if (streq(bbfname[i], sp)) {
        !          1638:                        exists = 1;
        !          1639:                }
        !          1640:        }
        !          1641:        if (exists) retv = chgbuf("...");
        !          1642:        else retv = chgbuf(sp);
        !          1643:        if (retv) retv=readin(sp,arg);
        !          1644:        return(retv);
        !          1645: }
        !          1646: 
        !          1647: /* cpbuf is the change buffer command, it prompts for a buffer name and
        !          1648:  * mmoves to  it unless the name is '*', in which case a list of active
        !          1649:  * buffers is displayed */
        !          1650: 
        !          1651: cpbuf(arg)
        !          1652: /* Keywords: commands buffer-changing files:10 */
        !          1653: int arg;
        !          1654: {
        !          1655:        int i;
        !          1656:        i = fndbuf(arg);
        !          1657:        if (arg && (i >= 0)) chbuf(i);
        !          1658:        return(i>= 0);
        !          1659: }
        !          1660: buflist()                              /* list active buffers */
        !          1661: /* Keywords: commands buffers user-interface informational-displays */
        !          1662: 
        !          1663: {
        !          1664:        register int i;
        !          1665:        char c;
        !          1666:        
        !          1667:        mtop();
        !          1668:        putout("Buffers used:");
        !          1669:        putout ("");
        !          1670:        for(i = 0; i < NBUF; i++) {
        !          1671:                if (bbfname[i] [0] ) {
        !          1672:                        if (i == curbf) c = '*';
        !          1673:                        else c = ' ';
        !          1674:                        putout ("%c (%d) %s  %c  %s",
        !          1675:                        c,i,bbfname[i],mdchar[bbfmod[i]], bfilname[i]);
        !          1676:                }
        !          1677:        }
        !          1678:        putout (endput);
        !          1679:        return(contin());
        !          1680: }
        !          1681: 
        !          1682: 
        !          1683: /* fndbuf finds/creates a buffer with a given name */
        !          1684: 
        !          1685: 
        !          1686: fndbuf(crflg)
        !          1687: int crflg;
        !          1688: {
        !          1689: /* Keywords: commands:20 buffers files:20 windows:10 */
        !          1690:        
        !          1691: 
        !          1692:        register char *bn;
        !          1693:        
        !          1694: again: bn = getname("Buffer Name? ");
        !          1695:        
        !          1696:        if (bn == NULL) return(-1);
        !          1697:        if ((*bn == 0) || (*bn == '*')) {
        !          1698:                if(buflist()) return(-1);
        !          1699:                else goto again;
        !          1700:        }
        !          1701:        return(finbuf(bn,crflg));
        !          1702: }      
        !          1703: 
        !          1704: /* bufmove -- pipe text from one buffer to another */
        !          1705: 
        !          1706: /* sends the text in the region to a specified buffer */
        !          1707: 
        !          1708: bfsend(arg)
        !          1709: 
        !          1710: int arg;
        !          1711: {
        !          1712:        register int i;
        !          1713:        register int j;
        !          1714:        
        !          1715: /* Keywords: commands buffers regions insertion:20 buffer-changing:50 */
        !          1716:        
        !          1717:        i = fndbuf(1);
        !          1718:        if (i >= 0) {
        !          1719:                pickup(arg);            /* pick up the region */
        !          1720:                j = curbf;
        !          1721:                chbuf(i);
        !          1722:                if (i == procbuf) {
        !          1723:                        bot(); /* Force insertion to the bottom */
        !          1724:                        mark(curbf); /* Force mark to end of buffer */
        !          1725:                }
        !          1726:                retrv();
        !          1727:                kpop();
        !          1728: #ifndef PC
        !          1729:                if (i == procbuf) {
        !          1730:                        exch(curbf);
        !          1731:                        while (curln < nlines) {
        !          1732:                                sendproc (mkline(curln)+column,leng(curln)+1-column);
        !          1733:                                curln++;
        !          1734:                                column=0;
        !          1735:                        }
        !          1736:                        sendproc (mkline(curln)+column,leng(curln)-column);
        !          1737:                        bot();
        !          1738:                }
        !          1739: #endif
        !          1740:                chbuf(j);               /* back to old buffer */
        !          1741:        }
        !          1742: }
        !          1743: 
        !          1744: /* rnbuf -- rename buffer or buffer file */
        !          1745: 
        !          1746: 
        !          1747: rnbuf(arg)
        !          1748: 
        !          1749: int arg;
        !          1750: /* Keywords: commands buffers:50 files:50 naming */
        !          1751: 
        !          1752: {
        !          1753:        register char *sp;
        !          1754:        int bn;
        !          1755:        
        !          1756:        sp = expenv(getname("New Name? "));
        !          1757:        if ((sp== NULL) || ((arg == 1) && (*sp == NULL))) return;
        !          1758:        if (arg == 1) {                 /* change buffer name */
        !          1759:                bn = finbuf(sp,0);
        !          1760:                if ((bn >= 0) && (bn != curbf)) {
        !          1761:                                        /* (allow change to current name */
        !          1762:                        error(WARN,38,sp); /* Buffer name in use */
        !          1763:                        return;
        !          1764:                }
        !          1765:                strcpy(bbfname[curbf],sp);
        !          1766:        } else {
        !          1767:                strcpy(bfilname[curbf],sp);
        !          1768:                mtime[curbf]=0;         /* Buffer wasn't read from this file */
        !          1769: 
        !          1770:        }
        !          1771:        dispmod();
        !          1772: }
        !          1773: 
        !          1774: /* rmbuf prompts for a buffer name and removes the buffer */
        !          1775: 
        !          1776: 
        !          1777: rmbuf()
        !          1778: /* Keywords: buffers commands deletion */
        !          1779: 
        !          1780: {
        !          1781:        register int i;
        !          1782:        
        !          1783:        if ((i = fndbuf(-1)) >= 0) {
        !          1784:                klbfr(i);
        !          1785:                return(1);
        !          1786:        } 
        !          1787:        return(0);
        !          1788: }
        !          1789: klbfr(i)
        !          1790: 
        !          1791: register int i;
        !          1792: /* Keywords: commands:10 buffers buffer-representation:20 deletion unix-interface:10 shell-escape:20 */
        !          1793: 
        !          1794: {
        !          1795:        if (i == curbf) {
        !          1796:                IGNORE(error (WARN,40));
        !          1797:                return;
        !          1798:        }
        !          1799: #ifndef PC
        !          1800:        if (i == procbuf) flushproc();
        !          1801: #endif
        !          1802:        if (i == windbuf()) onewind();          /* killing other window */
        !          1803: 
        !          1804:        if (btmpfile[i]) {
        !          1805: #ifdef MINFILES
        !          1806:                rftmp(i);
        !          1807: #else
        !          1808:                close(btmpfile[i]);
        !          1809: #endif
        !          1810:                btmpfile[i] = 0;
        !          1811:        }
        !          1812:        inibuf(i);
        !          1813: }
        !          1814: 
        !          1815: /* clean up unwritten buffers.  bclean checks for unwritten buffers, and
        !          1816:  * if any are found, writes them out if the user wishes */
        !          1817: 
        !          1818: bclean()
        !          1819: /* Keywords: dired:20 saving:70 exit-processing files:30 user-interface:10 */
        !          1820: 
        !          1821: {
        !          1822:        register int i;
        !          1823:        
        !          1824:        bbfmod[curbf] = bufmod;
        !          1825:        bnlines[curbf] = nlines;
        !          1826: #ifdef DIRED
        !          1827:        if (diron) fsave(0);
        !          1828: #endif 
        !          1829:        for (i = 0; i < NBUF; i++) {
        !          1830:                if ((bbfmod[i]) && (bbfname[i] [0]) &&
        !          1831:                        (bnlines[i] > 1) &&
        !          1832:                        (READONLY == 0) &&
        !          1833:                        (streq(bbfname[i],".exec") == 0)){
        !          1834: 
        !          1835: 
        !          1836:                        if (SAVEMD) {
        !          1837:                                chbuf(i);
        !          1838:                                fsave(0);
        !          1839:                                
        !          1840:                        } else {
        !          1841:                                switch (gyn("buffer %s modified since last write to file %s, write?",
        !          1842:                                        &(bbfname[i][0]),&(bfilname[i][0]))) {
        !          1843:                                case 0:
        !          1844:                                        break; /* no  */
        !          1845:                                case 1:
        !          1846:                                        /* yes answer */
        !          1847:                                        chbuf(i);
        !          1848:                                        if(fsave(1)<= 0) return(-1);
        !          1849:                                        break;
        !          1850:                                case -1:
        !          1851:                                default:
        !          1852:                                        unprompt(); /* clean up msg */
        !          1853:                                        return(-1);
        !          1854:                                }
        !          1855:                        }
        !          1856:                }
        !          1857:        }
        !          1858:        return(0);
        !          1859: }
        !          1860: 
        !          1861: crash(arg)                                     /* handle crashes */
        !          1862: 
        !          1863: int arg;                               /* sometimes is reason for crash */
        !          1864: {
        !          1865: /* Keywords: internal-errors saving unix-interface:30 files:20 */
        !          1866: #ifndef PC     
        !          1867:        register int i;
        !          1868:        register char *home;
        !          1869:        register int x = 0;
        !          1870: 
        !          1871:        signal(SIGHUP,SIG_IGN);
        !          1872:        signal(SIGINT,SIG_IGN);         /* go into our shell */
        !          1873: 
        !          1874:        if (arg == SIGHUP) {
        !          1875:                no_io = 1;      /* Make sure we do no I/O */
        !          1876:                close(0);
        !          1877:                close(1);
        !          1878:                close(2);
        !          1879:                open("/dev/null",2);
        !          1880:                dup(0);
        !          1881:                dup(0);
        !          1882:        }
        !          1883:        if (crashes++) eabort(0);       /* one crash per customer */
        !          1884:        home = getenv("HOME");
        !          1885: 
        !          1886:        bbfmod[curbf] = bufmod;
        !          1887: 
        !          1888:        for (i = 0; i < NBUF; i++) {
        !          1889:                if ((bbfmod[i]) && (bbfname[i] [0])){
        !          1890:                        seprintf(bfilname[i],"%s/emacs%d",home,i);
        !          1891:                        chbuf(i);
        !          1892:                        mtime[curbf] = 0; /* Don't complain about previous file! */
        !          1893:                        IGNORE(fsave(0));
        !          1894:                        x++;            /* flag that we saved one */
        !          1895:                }
        !          1896:        }
        !          1897:        if (x) {
        !          1898:                USILENT++;
        !          1899:                infrn = -1;             /* Make sure that unx doesn't ask questions */
        !          1900:                unx("echo $LOGTTY your emacs buffers are in $HOME/emacs[0-9]* | mail $LOGNAME &",0);
        !          1901:        }
        !          1902: #endif
        !          1903:        quit();
        !          1904: }
        !          1905: 
        !          1906: /* collect -- garbage collection of buffer file */
        !          1907: 
        !          1908: collect()
        !          1909: 
        !          1910: /* Keywords: buffer-allocation buffer-representation killstack:20 */
        !          1911: {
        !          1912:        int oldcol;
        !          1913:        int oldln;
        !          1914:        int onlns;
        !          1915:        
        !          1916:        prompt1("Garbage collecting buffer");
        !          1917:        mflush(stdout);
        !          1918:        
        !          1919:        oldln = curln;
        !          1920:        oldcol = column;
        !          1921:        
        !          1922:        top();
        !          1923:        onlns = kline = nlines;
        !          1924:        kcol = leng(kline);
        !          1925:        tkill();                        /* kill all text into kill buffer */
        !          1926:        
        !          1927:        bufinit();                      /* reinit buffer storage */
        !          1928:        top();
        !          1929:        retrv();
        !          1930:        if (onlns != curln) {
        !          1931:                error(WARN,75);         /* buffer too large for emacs */
        !          1932:        }
        !          1933:        kpop();
        !          1934:        unpop(2);                       /* Ignore for undo */
        !          1935:        move(oldln,oldcol);
        !          1936:        unprompt();
        !          1937: }
        !          1938: 
        !          1939: /* pshchr -- push a character into the macro buffer */
        !          1940: 
        !          1941: pshchr(ch)
        !          1942: 
        !          1943: register int ch;
        !          1944: /* Keywords: memory-allocation:10 macro-programming:10 paging:20 */
        !          1945: /* Keywords: buffer-allocation:20 buffer-representation:20 */
        !          1946: {
        !          1947:        if (macptr >= fbkno*BLEN) {
        !          1948:                if ((fbkno+2<NBLOCK) && bgrab(fbkno++,0)){
        !          1949:                        /* grab another buffer */
        !          1950:                        if (nxtflsh < fbkno) nxtflsh = fbkno;
        !          1951:                        clptr=mkline(curln); /* Restore line pointer */
        !          1952:                } else error(FATAL,41); /* too many macros */
        !          1953:        }
        !          1954:        bbuf[0][macptr++] = ch;
        !          1955: }
        !          1956: 
        !          1957: pbfname()                              /* put buffer name in kill stack*/
        !          1958: {
        !          1959: /* Keywords: commands macro-programming naming buffers */
        !          1960:        stkstr(bname());
        !          1961: }
        !          1962: pfnname()                              /* put file name in kill stack */
        !          1963: /* Keywords: commands macro-programming naming files */
        !          1964: {
        !          1965:        stkstr(fname());
        !          1966: }
        !          1967: 
        !          1968: pvname(count)                          /* put version in kill stack */
        !          1969: int count;
        !          1970: {
        !          1971: /* Keywords: commands macro-programming naming versions */
        !          1972:        if (count) stkstr(version);
        !          1973:        else stkstr(serial);
        !          1974: }
        !          1975: 
        !          1976: recurse(arg)                           /* call emacs recursively */
        !          1977: int arg;
        !          1978: /* Keywords: user-interface:10 macro-programming:90 key-bindings:10 mode-line:5 recursive-editing commands:50 */
        !          1979: {
        !          1980:        long svkst[NKILLP+1];           /* kill buffer save area */
        !          1981:        int svnkp;
        !          1982:        register int i,c;
        !          1983:        char *omyname;
        !          1984:        char nmbuf[64];
        !          1985:        int eresult;
        !          1986:        
        !          1987: 
        !          1988:        if (arg == 0) {
        !          1989:                register char *map;
        !          1990:                map = getname(""); /* Termination map */
        !          1991:                pushin(NULL);           /* back to the tty */
        !          1992:                while (1) {
        !          1993:                        disup();
        !          1994:                        c = (getchar()&0177);
        !          1995: 
        !          1996: /* Map is a bit map of 4 bit bytes, each represented as a hex digit */
        !          1997:                        
        !          1998:                        i = map[c>>2];
        !          1999:                        if (i>'9') i = 9+(i&017);
        !          2000:                        else i = i - '0';
        !          2001:                        if (8 & (i<<(c&3))) put(c);
        !          2002:                        else {
        !          2003:                                inpop();
        !          2004:                                return(c);
        !          2005:                        }
        !          2006:                }
        !          2007:        }
        !          2008:        for (i = 0; i <= NKILLP; i++) svkst[i] = kstk[i];
        !          2009:        svnkp = nkp;
        !          2010:        omyname = myname;
        !          2011:        pushin(NULL);           /* back to the tty */
        !          2012:        seprintf(nmbuf,"%s*",myname);
        !          2013:        myname = nmbuf;
        !          2014:        dispmod();
        !          2015:        eresult = edit(1);
        !          2016:        myname = omyname; /* pop name */
        !          2017:        dispmod();
        !          2018:        inpop();                        /* pop input */
        !          2019:        for (i = 0; i <= NKILLP; i++) kstk[i] = svkst[i];
        !          2020:        nkp = svnkp;
        !          2021:        return(eresult);
        !          2022: }
        !          2023: 
        !          2024: kdup(arg)                              /* duplicate argument */
        !          2025: 
        !          2026: int arg;                               /* level to duplicate */
        !          2027: /* Keywords: commands macro-programming killstack string-variables:20 stacking */
        !          2028: {
        !          2029:        register long dupkp;
        !          2030:        
        !          2031:        if (arg > nkp) return(0);
        !          2032:        dupkp = kstk[nkp-arg];
        !          2033:        if (nkp == NKILLP) mvdown(); /* make room */
        !          2034:        kstk[++nkp] = dupkp;
        !          2035:        return(1);
        !          2036: }
        !          2037: 
        !          2038: kflush(count)                          /* flush kill stack */
        !          2039: 
        !          2040: register int count;
        !          2041: /* Keywords: commands macro-programming killstack string-variables:20 popping */
        !          2042: {
        !          2043:        while (count--) {
        !          2044:                if (kpop() == 0) return(0);
        !          2045:        }
        !          2046:        return(1);
        !          2047: }
        !          2048: 
        !          2049: kexch(count)                           /* exchange kill stack */
        !          2050: /* Keywords: commands macro-programming killstack string-variables:20 */
        !          2051: {
        !          2052:        register long dupkp;
        !          2053:        
        !          2054:        if (count<(nkp+1)) {
        !          2055:                dupkp = kstk[nkp];
        !          2056:                kstk[nkp] = kstk[nkp-count];
        !          2057:                kstk[nkp-count] = dupkp;
        !          2058:                return(1);
        !          2059:        } else return(0);
        !          2060: }
        !          2061: 
        !          2062: /* unmod -- mark or change buffer modified flag */
        !          2063: 
        !          2064: unmod(arg)
        !          2065: /* Keywords: mode-line:20 buffers:80 file-modes:10 files:20 macro-programming:50 */
        !          2066: {
        !          2067:        if (arg == 1) bufmod = 0;
        !          2068:        else if (arg > 1) bufmod = 1;
        !          2069:        dispmod();
        !          2070:        return(bufmod);
        !          2071: }
        !          2072: 
        !          2073: #ifdef PC
        !          2074: #define KBDFILE "c:emk"
        !          2075: #define KBDMODE 1
        !          2076: #else
        !          2077: #define KBDFILE "$HOME/.emacs_kbd"
        !          2078: #define KBDMODE 0666
        !          2079: #endif
        !          2080: strtkbd()
        !          2081: {
        !          2082: /* Keywords: commands macro-programming:20 filenames:10 unix-interface:40 keyboard-macros */
        !          2083:        if (kbdfile) endkbd();
        !          2084:        kbdfile = creat(expenv(KBDFILE),KBDMODE);
        !          2085:        return(kbdfile);
        !          2086: }
        !          2087: endkbd()
        !          2088: {
        !          2089: /* Keywords: commands macro-programming:20 filenames:10 unix-interface:40 keyboard-macros */
        !          2090:        if (kbdfile) close(kbdfile);
        !          2091:        kbdfile=0;
        !          2092: }
        !          2093: exkbd(arg)
        !          2094: register int arg;
        !          2095: /* Keywords: commands macro-programming:20 filenames:10 unix-interface:40 keyboard-macros */
        !          2096: {
        !          2097:        while (arg-- > 0) infile(KBDFILE);
        !          2098: }
        !          2099: setkey()
        !          2100: /* Keywords: commands files file-modes:50 encryption */
        !          2101: {
        !          2102: #ifdef CRYPTO
        !          2103:        char *kp;
        !          2104:        kp = getname("Encryption Key? ");
        !          2105:        if (kp && *kp) {
        !          2106:                strcpy(cryptkey,kp);
        !          2107:                crypt = 1;
        !          2108:        } else crypt = 0;
        !          2109: #else
        !          2110:        beep();
        !          2111: #endif
        !          2112: }
        !          2113: #ifndef PC
        !          2114: access(path, amode)
        !          2115: char *path;
        !          2116: int amode;
        !          2117: /* Keywords: file-modes files reading:20 writing:20 unix-interface */
        !          2118: {
        !          2119:        struct stat stb;
        !          2120:        register int uid;
        !          2121: 
        !          2122:        /*** This nonsense would not be necessary if ***/
        !          2123:        /*** the saccess in sys2.c would do the check based on ***/
        !          2124:        /*** the effective uid and gid instead of the real ones ***/
        !          2125: 
        !          2126:        if( stat(path, &stb) < 0 ) {
        !          2127:                return(-1);
        !          2128:        }
        !          2129: 
        !          2130:        if( (uid=geteuid())==0 || amode==0 ) {
        !          2131:                /*** super user or existence check only ***/
        !          2132: 
        !          2133:                return(0);
        !          2134:        }
        !          2135: 
        !          2136:        if( uid == stb.st_uid ) {
        !          2137:                /*** uid's match ***/
        !          2138: 
        !          2139:                amode <<= 6;
        !          2140:        } else {
        !          2141:                if( getegid() == stb.st_gid ) {
        !          2142:                        /*** gid's match ***/
        !          2143: 
        !          2144:                        amode <<= 3;
        !          2145:                }
        !          2146:        }
        !          2147: 
        !          2148:        if( (stb.st_mode&amode) == amode ) {
        !          2149:                return(0);
        !          2150:        }
        !          2151:        return(-1);
        !          2152: }
        !          2153: 
        !          2154: #endif PC
        !          2155: 
        !          2156: 
        !          2157: undoit(n,doit)
        !          2158: 
        !          2159: /* Keywords: undo insertion:50 deletion:50 killstack:20 */
        !          2160: 
        !          2161: int n;
        !          2162: int doit;
        !          2163: {
        !          2164:        int unline;
        !          2165:        int uncol;
        !          2166:        long unparm;
        !          2167:        int untype;
        !          2168:        
        !          2169: 
        !          2170:        uncol = undostack[--n] & (MAXEL-1);
        !          2171:        unline = undostack[n]>>MAXELSH;
        !          2172:        move(unline,uncol);
        !          2173:        unparm = undostack[--n]>>UNDSHIFT;
        !          2174:        untype = undostack[n] & UNDMASK;
        !          2175: 
        !          2176:        switch(untype) {
        !          2177:                
        !          2178:        case UNINS:
        !          2179:                if (doit) {
        !          2180:                        kline = unparm >>MAXELSH;
        !          2181:                        kcol = unparm & (MAXEL-1);
        !          2182:                        tkill();
        !          2183:                        kpop();
        !          2184:                }
        !          2185:                break;
        !          2186:        case UNBAD:                     /* Multiple undo that exceeds limits */
        !          2187:        
        !          2188:                if (error(WARN,85)) return(n);
        !          2189: 
        !          2190:        case UNMUL:                     /* Multi-segment undo */
        !          2191:                while (unparm>0) {
        !          2192:                        untype = undoit(n,doit);
        !          2193:                        uncol = n-untype;
        !          2194:                        if (uncol<0) uncol += NUNDO;
        !          2195:                        unparm -= uncol/2;
        !          2196:                        n = untype;
        !          2197:                }
        !          2198:                break;
        !          2199:        case UNDEL:
        !          2200:                if (doit) {
        !          2201:                        if (nkp == NKILLP)  {   /* no more kill pointers available */
        !          2202:                        mvdown();
        !          2203:                        }
        !          2204:                        nkp++;
        !          2205:                        kstk[nkp] = unparm;
        !          2206:                        retrv();
        !          2207:                }
        !          2208:                break;
        !          2209:        }
        !          2210:        if (n<= 0) n = NUNDO;
        !          2211:        return(n);
        !          2212: }
        !          2213: 
        !          2214: unadd()
        !          2215: {
        !          2216: /* Keywords: undo stacking */
        !          2217:        
        !          2218:        undostack[undop++] = ((long) curln) * MAXEL + column;
        !          2219: }
        !          2220: 
        !          2221: unins(stline,stcol)
        !          2222: 
        !          2223: /* Keywords: undo insertion stacking */
        !          2224: 
        !          2225: {
        !          2226:        long n;
        !          2227:        if (undop >= NUNDO) {
        !          2228:                undop = 0;
        !          2229:                unseg++;
        !          2230:        }
        !          2231:        n = ((long) stline) * MAXEL + stcol;
        !          2232:        undostack[undop++] = UNINS+ (n<<UNDSHIFT);
        !          2233:        unadd();
        !          2234: }
        !          2235: 
        !          2236: undel()
        !          2237: 
        !          2238: /* Keywords: undo deletion stacking */
        !          2239: 
        !          2240: {
        !          2241:        if (undop >= NUNDO) {
        !          2242:                undop = 0;
        !          2243:                unseg++;
        !          2244:        }
        !          2245:        undostack[undop++] = UNDEL+ (kend<<UNDSHIFT);
        !          2246:        unadd();
        !          2247: }
        !          2248: 
        !          2249: unstart()
        !          2250: {
        !          2251:        return (undop+unseg*NUNDO);
        !          2252: }
        !          2253: unend(unp)
        !          2254: register int unp;
        !          2255: {
        !          2256:        int untype;
        !          2257:        
        !          2258:        unp = (undop+unseg*NUNDO)-unp;
        !          2259:        if (unp >= NUNDO/2) {
        !          2260:                untype= UNBAD;
        !          2261:                unp = NUNDO/2-2;
        !          2262:        } else untype = UNMUL;
        !          2263:        unp = unp / 2;
        !          2264:        if (unp == 1) return;           /* No point in storing extra indirection */
        !          2265:        if (undop >= NUNDO) undop = 0;
        !          2266:        undostack[undop++] = untype + (unp<<UNDSHIFT);
        !          2267:        unadd();
        !          2268: }
        !          2269: 
        !          2270: undo(arg)
        !          2271: 
        !          2272: /* Keywords: commands undo */
        !          2273: 
        !          2274: {
        !          2275:        int undp;
        !          2276:        int unp;
        !          2277:        
        !          2278:        unp = unstart();                        /* Set up for undoing undo */
        !          2279:        undp = undop;
        !          2280:        while (arg--) {
        !          2281: /* Only the last undo really undoes anything */
        !          2282:                
        !          2283:                undp = undoit(undp,(arg == 0));
        !          2284:        }
        !          2285:        unend(unp);
        !          2286: }
        !          2287: unpop(n)
        !          2288: {
        !          2289:        undop -= 2*n;
        !          2290:        if (undop < 0) undop += NUNDO;
        !          2291: }

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