Return to sh.err.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / bin / csh

Annotation of 43BSDTahoe/bin/csh/sh.err.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley Software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  */
                      6: 
                      7: #ifndef lint
                      8: static char *sccsid = "@(#)sh.err.c    5.3 (Berkeley) 5/13/86";
                      9: #endif
                     10: 
                     11: #include "sh.h"
                     12: #include <sys/ioctl.h>
                     13: 
                     14: /*
                     15:  * C Shell
                     16:  */
                     17: 
                     18: bool   errspl;                 /* Argument to error was spliced by seterr2 */
                     19: char   one[2] = { '1', 0 };
                     20: char   *onev[2] = { one, NOSTR };
                     21: /*
                     22:  * Print error string s with optional argument arg.
                     23:  * This routine always resets or exits.  The flag haderr
                     24:  * is set so the routine who catches the unwind can propogate
                     25:  * it if they want.
                     26:  *
                     27:  * Note that any open files at the point of error will eventually
                     28:  * be closed in the routine process in sh.c which is the only
                     29:  * place error unwinds are ever caught.
                     30:  */
                     31: /*VARARGS1*/
                     32: error(s, arg)
                     33:        char *s;
                     34: {
                     35:        register char **v;
                     36:        register char *ep;
                     37: 
                     38:        /*
                     39:         * Must flush before we print as we wish output before the error
                     40:         * to go on (some form of) standard output, while output after
                     41:         * goes on (some form of) diagnostic output.
                     42:         * If didfds then output will go to 1/2 else to FSHOUT/FSHDIAG.
                     43:         * See flush in sh.print.c.
                     44:         */
                     45:        flush();
                     46:        haderr = 1;             /* Now to diagnostic output */
                     47:        timflg = 0;             /* This isn't otherwise reset */
                     48:        if (v = pargv)
                     49:                pargv = 0, blkfree(v);
                     50:        if (v = gargv)
                     51:                gargv = 0, blkfree(v);
                     52: 
                     53:        /*
                     54:         * A zero arguments causes no printing, else print
                     55:         * an error diagnostic here.
                     56:         */
                     57:        if (s)
                     58:                printf(s, arg), printf(".\n");
                     59: 
                     60:        didfds = 0;             /* Forget about 0,1,2 */
                     61:        if ((ep = err) && errspl) {
                     62:                errspl = 0;
                     63:                xfree(ep);
                     64:        }
                     65:        errspl = 0;
                     66: 
                     67:        /*
                     68:         * Go away if -e or we are a child shell
                     69:         */
                     70:        if (exiterr || child)
                     71:                exit(1);
                     72: 
                     73:        /*
                     74:         * Reset the state of the input.
                     75:         * This buffered seek to end of file will also
                     76:         * clear the while/foreach stack.
                     77:         */
                     78:        btoeof();
                     79: 
                     80:        setq("status", onev, &shvhed);
                     81:        if (tpgrp > 0)
                     82:                (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);
                     83:        reset();                /* Unwind */
                     84: }
                     85: 
                     86: /*
                     87:  * Perror is the shells version of perror which should otherwise
                     88:  * never be called.
                     89:  */
                     90: Perror(s)
                     91:        char *s;
                     92: {
                     93: 
                     94:        /*
                     95:         * Perror uses unit 2, thus if we didn't set up the fd's
                     96:         * we must set up unit 2 now else the diagnostic will disappear
                     97:         */
                     98:        if (!didfds) {
                     99:                register int oerrno = errno;
                    100: 
                    101:                (void) dcopy(SHDIAG, 2);
                    102:                errno = oerrno;
                    103:        }
                    104:        perror(s);
                    105:        error(NOSTR);           /* To exit or unwind */
                    106: }
                    107: 
                    108: bferr(cp)
                    109:        char *cp;
                    110: {
                    111: 
                    112:        flush();
                    113:        haderr = 1;
                    114:        printf("%s: ", bname);
                    115:        error(cp);
                    116: }
                    117: 
                    118: /*
                    119:  * The parser and scanner set up errors for later by calling seterr,
                    120:  * which sets the variable err as a side effect; later to be tested,
                    121:  * e.g. in process.
                    122:  */
                    123: seterr(s)
                    124:        char *s;
                    125: {
                    126: 
                    127:        if (err == 0)
                    128:                err = s, errspl = 0;
                    129: }
                    130: 
                    131: /* Set err to a splice of cp and dp, to be freed later in error() */
                    132: seterr2(cp, dp)
                    133:        char *cp, *dp;
                    134: {
                    135: 
                    136:        if (err)
                    137:                return;
                    138:        err = strspl(cp, dp);
                    139:        errspl++;
                    140: }
                    141: 
                    142: /* Set err to a splice of cp with a string form of character d */
                    143: seterrc(cp, d)
                    144:        char *cp, d;
                    145: {
                    146:        char chbuf[2];
                    147: 
                    148:        chbuf[0] = d;
                    149:        chbuf[1] = 0;
                    150:        seterr2(cp, chbuf);
                    151: }

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