Return to ex_subr.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / ex

Annotation of 42BSD/ucb/ex/ex_subr.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1981 Regents of the University of California */
        !             2: static char *sccsid = "@(#)ex_subr.c   7.5     7/9/83";
        !             3: #include "ex.h"
        !             4: #include "ex_re.h"
        !             5: #include "ex_tty.h"
        !             6: #include "ex_vis.h"
        !             7: 
        !             8: /*
        !             9:  * Random routines, in alphabetical order.
        !            10:  */
        !            11: 
        !            12: any(c, s)
        !            13:        int c;
        !            14:        register char *s;
        !            15: {
        !            16:        register int x;
        !            17: 
        !            18:        while (x = *s++)
        !            19:                if (x == c)
        !            20:                        return (1);
        !            21:        return (0);
        !            22: }
        !            23: 
        !            24: backtab(i)
        !            25:        register int i;
        !            26: {
        !            27:        register int j;
        !            28: 
        !            29:        j = i % value(SHIFTWIDTH);
        !            30:        if (j == 0)
        !            31:                j = value(SHIFTWIDTH);
        !            32:        i -= j;
        !            33:        if (i < 0)
        !            34:                i = 0;
        !            35:        return (i);
        !            36: }
        !            37: 
        !            38: change()
        !            39: {
        !            40: 
        !            41:        tchng++;
        !            42:        chng = tchng;
        !            43: }
        !            44: 
        !            45: /*
        !            46:  * Column returns the number of
        !            47:  * columns occupied by printing the
        !            48:  * characters through position cp of the
        !            49:  * current line.
        !            50:  */
        !            51: column(cp)
        !            52:        register char *cp;
        !            53: {
        !            54: 
        !            55:        if (cp == 0)
        !            56:                cp = &linebuf[LBSIZE - 2];
        !            57:        return (qcolumn(cp, (char *) 0));
        !            58: }
        !            59: 
        !            60: /*
        !            61:  * Ignore a comment to the end of the line.
        !            62:  * This routine eats the trailing newline so don't call newline().
        !            63:  */
        !            64: comment()
        !            65: {
        !            66:        register int c;
        !            67: 
        !            68:        do {
        !            69:                c = getchar();
        !            70:        } while (c != '\n' && c != EOF);
        !            71:        if (c == EOF)
        !            72:                ungetchar(c);
        !            73: }
        !            74: 
        !            75: Copy(to, from, size)
        !            76:        register char *from, *to;
        !            77:        register int size;
        !            78: {
        !            79: 
        !            80:        if (size > 0)
        !            81:                do
        !            82:                        *to++ = *from++;
        !            83:                while (--size > 0);
        !            84: }
        !            85: 
        !            86: copyw(to, from, size)
        !            87:        register line *from, *to;
        !            88:        register int size;
        !            89: {
        !            90: 
        !            91:        if (size > 0)
        !            92:                do
        !            93:                        *to++ = *from++;
        !            94:                while (--size > 0);
        !            95: }
        !            96: 
        !            97: copywR(to, from, size)
        !            98:        register line *from, *to;
        !            99:        register int size;
        !           100: {
        !           101: 
        !           102:        while (--size >= 0)
        !           103:                to[size] = from[size];
        !           104: }
        !           105: 
        !           106: ctlof(c)
        !           107:        int c;
        !           108: {
        !           109: 
        !           110:        return (c == TRIM ? '?' : c | ('A' - 1));
        !           111: }
        !           112: 
        !           113: dingdong()
        !           114: {
        !           115: 
        !           116:        if (VB)
        !           117:                putpad(VB);
        !           118:        else if (value(ERRORBELLS))
        !           119:                putch('\207');
        !           120: }
        !           121: 
        !           122: fixindent(indent)
        !           123:        int indent;
        !           124: {
        !           125:        register int i;
        !           126:        register char *cp;
        !           127: 
        !           128:        i = whitecnt(genbuf);
        !           129:        cp = vpastwh(genbuf);
        !           130:        if (*cp == 0 && i == indent && linebuf[0] == 0) {
        !           131:                genbuf[0] = 0;
        !           132:                return (i);
        !           133:        }
        !           134:        CP(genindent(i), cp);
        !           135:        return (i);
        !           136: }
        !           137: 
        !           138: filioerr(cp)
        !           139:        char *cp;
        !           140: {
        !           141:        register int oerrno = errno;
        !           142: 
        !           143:        lprintf("\"%s\"", cp);
        !           144:        errno = oerrno;
        !           145:        syserror();
        !           146: }
        !           147: 
        !           148: char *
        !           149: genindent(indent)
        !           150:        register int indent;
        !           151: {
        !           152:        register char *cp;
        !           153: 
        !           154:        for (cp = genbuf; indent >= value(TABSTOP); indent -= value(TABSTOP))
        !           155:                *cp++ = '\t';
        !           156:        for (; indent > 0; indent--)
        !           157:                *cp++ = ' ';
        !           158:        return (cp);
        !           159: }
        !           160: 
        !           161: getDOT()
        !           162: {
        !           163: 
        !           164:        getline(*dot);
        !           165: }
        !           166: 
        !           167: line *
        !           168: getmark(c)
        !           169:        register int c;
        !           170: {
        !           171:        register line *addr;
        !           172:        
        !           173:        for (addr = one; addr <= dol; addr++)
        !           174:                if (names[c - 'a'] == (*addr &~ 01)) {
        !           175:                        return (addr);
        !           176:                }
        !           177:        return (0);
        !           178: }
        !           179: 
        !           180: getn(cp)
        !           181:        register char *cp;
        !           182: {
        !           183:        register int i = 0;
        !           184: 
        !           185:        while (isdigit(*cp))
        !           186:                i = i * 10 + *cp++ - '0';
        !           187:        if (*cp)
        !           188:                return (0);
        !           189:        return (i);
        !           190: }
        !           191: 
        !           192: ignnEOF()
        !           193: {
        !           194:        register int c = getchar();
        !           195: 
        !           196:        if (c == EOF)
        !           197:                ungetchar(c);
        !           198:        else if (c=='"')
        !           199:                comment();
        !           200: }
        !           201: 
        !           202: iswhite(c)
        !           203:        int c;
        !           204: {
        !           205: 
        !           206:        return (c == ' ' || c == '\t');
        !           207: }
        !           208: 
        !           209: junk(c)
        !           210:        register int c;
        !           211: {
        !           212: 
        !           213:        if (c && !value(BEAUTIFY))
        !           214:                return (0);
        !           215:        if (c >= ' ' && c != TRIM)
        !           216:                return (0);
        !           217:        switch (c) {
        !           218: 
        !           219:        case '\t':
        !           220:        case '\n':
        !           221:        case '\f':
        !           222:                return (0);
        !           223: 
        !           224:        default:
        !           225:                return (1);
        !           226:        }
        !           227: }
        !           228: 
        !           229: killed()
        !           230: {
        !           231: 
        !           232:        killcnt(addr2 - addr1 + 1);
        !           233: }
        !           234: 
        !           235: killcnt(cnt)
        !           236:        register int cnt;
        !           237: {
        !           238: 
        !           239:        if (inopen) {
        !           240:                notecnt = cnt;
        !           241:                notenam = notesgn = "";
        !           242:                return;
        !           243:        }
        !           244:        if (!notable(cnt))
        !           245:                return;
        !           246:        printf("%d lines", cnt);
        !           247:        if (value(TERSE) == 0) {
        !           248:                printf(" %c%s", Command[0] | ' ', Command + 1);
        !           249:                if (Command[strlen(Command) - 1] != 'e')
        !           250:                        putchar('e');
        !           251:                putchar('d');
        !           252:        }
        !           253:        putNFL();
        !           254: }
        !           255: 
        !           256: lineno(a)
        !           257:        line *a;
        !           258: {
        !           259: 
        !           260:        return (a - zero);
        !           261: }
        !           262: 
        !           263: lineDOL()
        !           264: {
        !           265: 
        !           266:        return (lineno(dol));
        !           267: }
        !           268: 
        !           269: lineDOT()
        !           270: {
        !           271: 
        !           272:        return (lineno(dot));
        !           273: }
        !           274: 
        !           275: markDOT()
        !           276: {
        !           277: 
        !           278:        markpr(dot);
        !           279: }
        !           280: 
        !           281: markpr(which)
        !           282:        line *which;
        !           283: {
        !           284: 
        !           285:        if ((inglobal == 0 || inopen) && which <= endcore) {
        !           286:                names['z'-'a'+1] = *which & ~01;
        !           287:                if (inopen)
        !           288:                        ncols['z'-'a'+1] = cursor;
        !           289:        }
        !           290: }
        !           291: 
        !           292: markreg(c)
        !           293:        register int c;
        !           294: {
        !           295: 
        !           296:        if (c == '\'' || c == '`')
        !           297:                return ('z' + 1);
        !           298:        if (c >= 'a' && c <= 'z')
        !           299:                return (c);
        !           300:        return (0);
        !           301: }
        !           302: 
        !           303: /*
        !           304:  * Mesg decodes the terse/verbose strings. Thus
        !           305:  *     'xxx@yyy' -> 'xxx' if terse, else 'xxx yyy'
        !           306:  *     'xxx|yyy' -> 'xxx' if terse, else 'yyy'
        !           307:  * All others map to themselves.
        !           308:  */
        !           309: char *
        !           310: mesg(str)
        !           311:        register char *str;
        !           312: {
        !           313:        register char *cp;
        !           314: 
        !           315:        str = strcpy(genbuf, str);
        !           316:        for (cp = str; *cp; cp++)
        !           317:                switch (*cp) {
        !           318: 
        !           319:                case '@':
        !           320:                        if (value(TERSE))
        !           321:                                *cp = 0;
        !           322:                        else
        !           323:                                *cp = ' ';
        !           324:                        break;
        !           325: 
        !           326:                case '|':
        !           327:                        if (value(TERSE) == 0)
        !           328:                                return (cp + 1);
        !           329:                        *cp = 0;
        !           330:                        break;
        !           331:                }
        !           332:        return (str);
        !           333: }
        !           334: 
        !           335: /*VARARGS2*/
        !           336: merror(seekpt, i)
        !           337: #ifdef VMUNIX
        !           338:        char *seekpt;
        !           339: #else
        !           340: # ifdef lint
        !           341:        char *seekpt;
        !           342: # else
        !           343:        int seekpt;
        !           344: # endif
        !           345: #endif
        !           346:        int i;
        !           347: {
        !           348:        register char *cp = linebuf;
        !           349: 
        !           350:        if (seekpt == 0)
        !           351:                return;
        !           352:        merror1(seekpt);
        !           353:        if (*cp == '\n')
        !           354:                putnl(), cp++;
        !           355:        if (inopen > 0 && CE)
        !           356:                vclreol();
        !           357:        if (SO && SE)
        !           358:                putpad(SO);
        !           359:        printf(mesg(cp), i);
        !           360:        if (SO && SE)
        !           361:                putpad(SE);
        !           362: }
        !           363: 
        !           364: merror1(seekpt)
        !           365: #ifdef VMUNIX
        !           366:        char *seekpt;
        !           367: #else
        !           368: # ifdef lint
        !           369:        char *seekpt;
        !           370: # else
        !           371:        int seekpt;
        !           372: # endif
        !           373: #endif
        !           374: {
        !           375: 
        !           376: #ifdef VMUNIX
        !           377:        strcpy(linebuf, seekpt);
        !           378: #else
        !           379:        lseek(erfile, (long) seekpt, 0);
        !           380:        if (read(erfile, linebuf, 128) < 2)
        !           381:                CP(linebuf, "ERROR");
        !           382: #endif
        !           383: }
        !           384: 
        !           385: morelines()
        !           386: {
        !           387: 
        !           388:        if ((int) sbrk(1024 * sizeof (line)) == -1)
        !           389:                return (-1);
        !           390:        endcore += 1024;
        !           391:        return (0);
        !           392: }
        !           393: 
        !           394: nonzero()
        !           395: {
        !           396: 
        !           397:        if (addr1 == zero) {
        !           398:                notempty();
        !           399:                error("Nonzero address required@on this command");
        !           400:        }
        !           401: }
        !           402: 
        !           403: notable(i)
        !           404:        int i;
        !           405: {
        !           406: 
        !           407:        return (hush == 0 && !inglobal && i > value(REPORT));
        !           408: }
        !           409: 
        !           410: 
        !           411: notempty()
        !           412: {
        !           413: 
        !           414:        if (dol == zero)
        !           415:                error("No lines@in the buffer");
        !           416: }
        !           417: 
        !           418: 
        !           419: netchHAD(cnt)
        !           420:        int cnt;
        !           421: {
        !           422: 
        !           423:        netchange(lineDOL() - cnt);
        !           424: }
        !           425: 
        !           426: netchange(i)
        !           427:        register int i;
        !           428: {
        !           429:        register char *cp;
        !           430: 
        !           431:        if (i > 0)
        !           432:                notesgn = cp = "more ";
        !           433:        else
        !           434:                notesgn = cp = "fewer ", i = -i;
        !           435:        if (inopen) {
        !           436:                notecnt = i;
        !           437:                notenam = "";
        !           438:                return;
        !           439:        }
        !           440:        if (!notable(i))
        !           441:                return;
        !           442:        printf(mesg("%d %slines@in file after %s"), i, cp, Command);
        !           443:        putNFL();
        !           444: }
        !           445: 
        !           446: putmark(addr)
        !           447:        line *addr;
        !           448: {
        !           449: 
        !           450:        putmk1(addr, putline());
        !           451: }
        !           452: 
        !           453: putmk1(addr, n)
        !           454:        register line *addr;
        !           455:        int n;
        !           456: {
        !           457:        register line *markp;
        !           458:        register oldglobmk;
        !           459: 
        !           460:        oldglobmk = *addr & 1;
        !           461:        *addr &= ~1;
        !           462:        for (markp = (anymarks ? names : &names['z'-'a'+1]);
        !           463:          markp <= &names['z'-'a'+1]; markp++)
        !           464:                if (*markp == *addr)
        !           465:                        *markp = n;
        !           466:        *addr = n | oldglobmk;
        !           467: }
        !           468: 
        !           469: char *
        !           470: plural(i)
        !           471:        long i;
        !           472: {
        !           473: 
        !           474:        return (i == 1 ? "" : "s");
        !           475: }
        !           476: 
        !           477: int    qcount();
        !           478: short  vcntcol;
        !           479: 
        !           480: qcolumn(lim, gp)
        !           481:        register char *lim, *gp;
        !           482: {
        !           483:        register int x;
        !           484:        int (*OO)();
        !           485: 
        !           486:        OO = Outchar;
        !           487:        Outchar = qcount;
        !           488:        vcntcol = 0;
        !           489:        if (lim != NULL)
        !           490:                x = lim[1], lim[1] = 0;
        !           491:        pline(0);
        !           492:        if (lim != NULL)
        !           493:                lim[1] = x;
        !           494:        if (gp)
        !           495:                while (*gp)
        !           496:                        putchar(*gp++);
        !           497:        Outchar = OO;
        !           498:        return (vcntcol);
        !           499: }
        !           500: 
        !           501: int
        !           502: qcount(c)
        !           503:        int c;
        !           504: {
        !           505: 
        !           506:        if (c == '\t') {
        !           507:                vcntcol += value(TABSTOP) - vcntcol % value(TABSTOP);
        !           508:                return;
        !           509:        }
        !           510:        vcntcol++;
        !           511: }
        !           512: 
        !           513: reverse(a1, a2)
        !           514:        register line *a1, *a2;
        !           515: {
        !           516:        register line t;
        !           517: 
        !           518:        for (;;) {
        !           519:                t = *--a2;
        !           520:                if (a2 <= a1)
        !           521:                        return;
        !           522:                *a2 = *a1;
        !           523:                *a1++ = t;
        !           524:        }
        !           525: }
        !           526: 
        !           527: save(a1, a2)
        !           528:        line *a1;
        !           529:        register line *a2;
        !           530: {
        !           531:        register int more;
        !           532: 
        !           533:        if (!FIXUNDO)
        !           534:                return;
        !           535: #ifdef TRACE
        !           536:        if (trace)
        !           537:                vudump("before save");
        !           538: #endif
        !           539:        undkind = UNDNONE;
        !           540:        undadot = dot;
        !           541:        more = (a2 - a1 + 1) - (unddol - dol);
        !           542:        while (more > (endcore - truedol))
        !           543:                if (morelines() < 0)
        !           544:                        error("Out of memory@saving lines for undo - try using ed");
        !           545:        if (more)
        !           546:                (*(more > 0 ? copywR : copyw))(unddol + more + 1, unddol + 1,
        !           547:                    (truedol - unddol));
        !           548:        unddol += more;
        !           549:        truedol += more;
        !           550:        copyw(dol + 1, a1, a2 - a1 + 1);
        !           551:        undkind = UNDALL;
        !           552:        unddel = a1 - 1;
        !           553:        undap1 = a1;
        !           554:        undap2 = a2 + 1;
        !           555: #ifdef TRACE
        !           556:        if (trace)
        !           557:                vudump("after save");
        !           558: #endif
        !           559: }
        !           560: 
        !           561: save12()
        !           562: {
        !           563: 
        !           564:        save(addr1, addr2);
        !           565: }
        !           566: 
        !           567: saveall()
        !           568: {
        !           569: 
        !           570:        save(one, dol);
        !           571: }
        !           572: 
        !           573: span()
        !           574: {
        !           575: 
        !           576:        return (addr2 - addr1 + 1);
        !           577: }
        !           578: 
        !           579: sync()
        !           580: {
        !           581: 
        !           582:        chng = 0;
        !           583:        tchng = 0;
        !           584:        xchng = 0;
        !           585: }
        !           586: 
        !           587: 
        !           588: skipwh()
        !           589: {
        !           590:        register int wh;
        !           591: 
        !           592:        wh = 0;
        !           593:        while (iswhite(peekchar())) {
        !           594:                wh++;
        !           595:                ignchar();
        !           596:        }
        !           597:        return (wh);
        !           598: }
        !           599: 
        !           600: /*VARARGS2*/
        !           601: smerror(seekpt, cp)
        !           602: #ifdef lint
        !           603:        char *seekpt;
        !           604: #else
        !           605:        int seekpt;
        !           606: #endif
        !           607:        char *cp;
        !           608: {
        !           609: 
        !           610:        if (seekpt == 0)
        !           611:                return;
        !           612:        merror1(seekpt);
        !           613:        if (inopen && CE)
        !           614:                vclreol();
        !           615:        if (SO && SE)
        !           616:                putpad(SO);
        !           617:        lprintf(mesg(linebuf), cp);
        !           618:        if (SO && SE)
        !           619:                putpad(SE);
        !           620: }
        !           621: 
        !           622: #define        std_nerrs (sizeof std_errlist / sizeof std_errlist[0])
        !           623: 
        !           624: #define        error(i)        i
        !           625: 
        !           626: #ifdef lint
        !           627: char   *std_errlist[] = {
        !           628: #else
        !           629: # ifdef VMUNIX
        !           630: char   *std_errlist[] = {
        !           631: # else
        !           632: short  std_errlist[] = {
        !           633: # endif
        !           634: #endif
        !           635:        error("Error 0"),
        !           636:        error("Not super-user"),
        !           637:        error("No such file or directory"),
        !           638:        error("No such process"),
        !           639:        error("Interrupted system call"),
        !           640:        error("Physical I/O error"),
        !           641:        error("No such device or address"),
        !           642:        error("Argument list too long"),
        !           643:        error("Exec format error"),
        !           644:        error("Bad file number"),
        !           645:        error("No children"),
        !           646:        error("No more processes"),
        !           647:        error("Not enough core"),
        !           648:        error("Permission denied"),
        !           649:        error("Bad address"),
        !           650:        error("Block device required"),
        !           651:        error("Mount device busy"),
        !           652:        error("File exists"),
        !           653:        error("Cross-device link"),
        !           654:        error("No such device"),
        !           655:        error("Not a directory"),
        !           656:        error("Is a directory"),
        !           657:        error("Invalid argument"),
        !           658:        error("File table overflow"),
        !           659:        error("Too many open files"),
        !           660:        error("Not a typewriter"),
        !           661:        error("Text file busy"),
        !           662:        error("File too large"),
        !           663:        error("No space left on device"),
        !           664:        error("Illegal seek"),
        !           665:        error("Read-only file system"),
        !           666:        error("Too many links"),
        !           667:        error("Broken pipe"),
        !           668: #ifndef V6
        !           669:        error("Math argument"),
        !           670:        error("Result too large"),
        !           671: #endif
        !           672:        error("Quota exceeded")         /* Berkeley quota systems only */
        !           673: };
        !           674: 
        !           675: #undef error
        !           676: 
        !           677: char *
        !           678: strend(cp)
        !           679:        register char *cp;
        !           680: {
        !           681: 
        !           682:        while (*cp)
        !           683:                cp++;
        !           684:        return (cp);
        !           685: }
        !           686: 
        !           687: strcLIN(dp)
        !           688:        char *dp;
        !           689: {
        !           690: 
        !           691:        CP(linebuf, dp);
        !           692: }
        !           693: 
        !           694: syserror()
        !           695: {
        !           696:        register int e = errno;
        !           697: 
        !           698:        dirtcnt = 0;
        !           699:        putchar(' ');
        !           700:        if (e >= 0 && errno <= std_nerrs)
        !           701:                error(std_errlist[e]);
        !           702:        else
        !           703:                error("System error %d", e);
        !           704: }
        !           705: 
        !           706: /*
        !           707:  * Return the column number that results from being in column col and
        !           708:  * hitting a tab, where tabs are set every ts columns.  Work right for
        !           709:  * the case where col > COLUMNS, even if ts does not divide COLUMNS.
        !           710:  */
        !           711: tabcol(col, ts)
        !           712: int col, ts;
        !           713: {
        !           714:        int offset, result;
        !           715: 
        !           716:        if (col >= COLUMNS) {
        !           717:                offset = COLUMNS * (col/COLUMNS);
        !           718:                col -= offset;
        !           719:        } else
        !           720:                offset = 0;
        !           721:        result = col + ts - (col % ts) + offset;
        !           722:        return (result);
        !           723: }
        !           724: 
        !           725: char *
        !           726: vfindcol(i)
        !           727:        int i;
        !           728: {
        !           729:        register char *cp;
        !           730:        register int (*OO)() = Outchar;
        !           731: 
        !           732:        Outchar = qcount;
        !           733:        ignore(qcolumn(linebuf - 1, NOSTR));
        !           734:        for (cp = linebuf; *cp && vcntcol < i; cp++)
        !           735:                putchar(*cp);
        !           736:        if (cp != linebuf)
        !           737:                cp--;
        !           738:        Outchar = OO;
        !           739:        return (cp);
        !           740: }
        !           741: 
        !           742: char *
        !           743: vskipwh(cp)
        !           744:        register char *cp;
        !           745: {
        !           746: 
        !           747:        while (iswhite(*cp) && cp[1])
        !           748:                cp++;
        !           749:        return (cp);
        !           750: }
        !           751: 
        !           752: 
        !           753: char *
        !           754: vpastwh(cp)
        !           755:        register char *cp;
        !           756: {
        !           757: 
        !           758:        while (iswhite(*cp))
        !           759:                cp++;
        !           760:        return (cp);
        !           761: }
        !           762: 
        !           763: whitecnt(cp)
        !           764:        register char *cp;
        !           765: {
        !           766:        register int i;
        !           767: 
        !           768:        i = 0;
        !           769:        for (;;)
        !           770:                switch (*cp++) {
        !           771: 
        !           772:                case '\t':
        !           773:                        i += value(TABSTOP) - i % value(TABSTOP);
        !           774:                        break;
        !           775: 
        !           776:                case ' ':
        !           777:                        i++;
        !           778:                        break;
        !           779: 
        !           780:                default:
        !           781:                        return (i);
        !           782:                }
        !           783: }
        !           784: 
        !           785: #ifdef lint
        !           786: Ignore(a)
        !           787:        char *a;
        !           788: {
        !           789: 
        !           790:        a = a;
        !           791: }
        !           792: 
        !           793: Ignorf(a)
        !           794:        int (*a)();
        !           795: {
        !           796: 
        !           797:        a = a;
        !           798: }
        !           799: #endif
        !           800: 
        !           801: markit(addr)
        !           802:        line *addr;
        !           803: {
        !           804: 
        !           805:        if (addr != dot && addr >= one && addr <= dol)
        !           806:                markDOT();
        !           807: }
        !           808: 
        !           809: /*
        !           810:  * The following code is defensive programming against a bug in the
        !           811:  * pdp-11 overlay implementation.  Sometimes it goes nuts and asks
        !           812:  * for an overlay with some garbage number, which generates an emt
        !           813:  * trap.  This is a less than elegant solution, but it is somewhat
        !           814:  * better than core dumping and losing your work, leaving your tty
        !           815:  * in a weird state, etc.
        !           816:  */
        !           817: int _ovno;
        !           818: onemt()
        !           819: {
        !           820:        int oovno;
        !           821: 
        !           822:        signal(SIGEMT, onemt);
        !           823:        oovno = _ovno;
        !           824:        /* 2 and 3 are valid on 11/40 type vi, so */
        !           825:        if (_ovno < 0 || _ovno > 3)
        !           826:                _ovno = 0;
        !           827:        error("emt trap, _ovno is %d @ - try again");
        !           828: }
        !           829: 
        !           830: /*
        !           831:  * When a hangup occurs our actions are similar to a preserve
        !           832:  * command.  If the buffer has not been [Modified], then we do
        !           833:  * nothing but remove the temporary files and exit.
        !           834:  * Otherwise, we sync the temp file and then attempt a preserve.
        !           835:  * If the preserve succeeds, we unlink our temp files.
        !           836:  * If the preserve fails, we leave the temp files as they are
        !           837:  * as they are a backup even without preservation if they
        !           838:  * are not removed.
        !           839:  */
        !           840: onhup()
        !           841: {
        !           842: 
        !           843:        /*
        !           844:         * USG tty driver can send multiple HUP's!!
        !           845:         */
        !           846:        signal(SIGINT, SIG_IGN);
        !           847:        signal(SIGHUP, SIG_IGN);
        !           848:        if (chng == 0) {
        !           849:                cleanup(1);
        !           850:                exit(0);
        !           851:        }
        !           852:        if (setexit() == 0) {
        !           853:                if (preserve()) {
        !           854:                        cleanup(1);
        !           855:                        exit(0);
        !           856:                }
        !           857:        }
        !           858:        exit(1);
        !           859: }
        !           860: 
        !           861: /*
        !           862:  * An interrupt occurred.  Drain any output which
        !           863:  * is still in the output buffering pipeline.
        !           864:  * Catch interrupts again.  Unless we are in visual
        !           865:  * reset the output state (out of -nl mode, e.g).
        !           866:  * Then like a normal error (with the \n before Interrupt
        !           867:  * suppressed in visual mode).
        !           868:  */
        !           869: onintr()
        !           870: {
        !           871: 
        !           872: #ifndef CBREAK
        !           873:        signal(SIGINT, onintr);
        !           874: #else
        !           875:        signal(SIGINT, inopen ? vintr : onintr);
        !           876: #endif
        !           877:        alarm(0);       /* in case we were called from map */
        !           878:        draino();
        !           879:        if (!inopen) {
        !           880:                pstop();
        !           881:                setlastchar('\n');
        !           882: #ifdef CBREAK
        !           883:        }
        !           884: #else
        !           885:        } else
        !           886:                vraw();
        !           887: #endif
        !           888:        error("\nInterrupt" + inopen);
        !           889: }
        !           890: 
        !           891: /*
        !           892:  * If we are interruptible, enable interrupts again.
        !           893:  * In some critical sections we turn interrupts off,
        !           894:  * but not very often.
        !           895:  */
        !           896: setrupt()
        !           897: {
        !           898: 
        !           899:        if (ruptible) {
        !           900: #ifndef CBREAK
        !           901:                signal(SIGINT, onintr);
        !           902: #else
        !           903:                signal(SIGINT, inopen ? vintr : onintr);
        !           904: #endif
        !           905: #ifdef SIGTSTP
        !           906:                if (dosusp)
        !           907:                        signal(SIGTSTP, onsusp);
        !           908: #endif
        !           909:        }
        !           910: }
        !           911: 
        !           912: preserve()
        !           913: {
        !           914: 
        !           915: #ifdef VMUNIX
        !           916:        tflush();
        !           917: #endif
        !           918:        synctmp();
        !           919:        pid = fork();
        !           920:        if (pid < 0)
        !           921:                return (0);
        !           922:        if (pid == 0) {
        !           923:                close(0);
        !           924:                dup(tfile);
        !           925:                execl(EXPRESERVE, "expreserve", (char *) 0);
        !           926:                exit(1);
        !           927:        }
        !           928:        waitfor();
        !           929:        if (rpid == pid && status == 0)
        !           930:                return (1);
        !           931:        return (0);
        !           932: }
        !           933: 
        !           934: #ifndef V6
        !           935: exit(i)
        !           936:        int i;
        !           937: {
        !           938: 
        !           939: # ifdef TRACE
        !           940:        if (trace)
        !           941:                fclose(trace);
        !           942: # endif
        !           943:        _exit(i);
        !           944: }
        !           945: #endif
        !           946: 
        !           947: #ifdef SIGTSTP
        !           948: /*
        !           949:  * We have just gotten a susp.  Suspend and prepare to resume.
        !           950:  */
        !           951: onsusp()
        !           952: {
        !           953:        ttymode f;
        !           954:        int omask;
        !           955: 
        !           956:        f = setty(normf);
        !           957:        vnfl();
        !           958:        putpad(TE);
        !           959:        flush();
        !           960: 
        !           961:        (void) sigsetmask(0);
        !           962:        signal(SIGTSTP, SIG_DFL);
        !           963:        kill(0, SIGTSTP);
        !           964: 
        !           965:        /* the pc stops here */
        !           966: 
        !           967:        signal(SIGTSTP, onsusp);
        !           968:        vcontin(0);
        !           969:        setty(f);
        !           970:        if (!inopen)
        !           971:                error(0);
        !           972:        else {
        !           973:                if (vcnt < 0) {
        !           974:                        vcnt = -vcnt;
        !           975:                        if (state == VISUAL)
        !           976:                                vclear();
        !           977:                        else if (state == CRTOPEN)
        !           978:                                vcnt = 0;
        !           979:                }
        !           980:                vdirty(0, LINES);
        !           981:                vrepaint(cursor);
        !           982:        }
        !           983: }
        !           984: #endif

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