Return to library.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx

Annotation of 42BSD/ucb/pascal/pdx/library.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1982 Regents of the University of California */
        !             2: 
        !             3: /* static char sccsid[] = "@(#)library.c 1.1 9/2/82"; */
        !             4: 
        !             5: /*
        !             6:  * General purpose routines.
        !             7:  */
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include <errno.h>
        !            11: 
        !            12: #define public
        !            13: #define private static
        !            14: #define and &&
        !            15: #define or ||
        !            16: #define not !
        !            17: #define ord(enumcon)   ((int) enumcon)
        !            18: #define nil(type)      ((type) 0)
        !            19: 
        !            20: typedef enum { FALSE, TRUE } Boolean;
        !            21: typedef char *String;
        !            22: typedef FILE *File;
        !            23: typedef String Filename;
        !            24: 
        !            25: #undef FILE
        !            26: 
        !            27: /*
        !            28:  * Definitions of standard C library routines that aren't in the
        !            29:  * standard I/O library, but which are generally useful.
        !            30:  */
        !            31: 
        !            32: extern long atol();            /* ascii to long */
        !            33: extern double atof();          /* ascii to floating point */
        !            34: extern char *mktemp();         /* make a temporary file name */
        !            35: 
        !            36: String cmdname;                        /* name of command for error messages */
        !            37: Filename errfilename;          /* current file associated with error */
        !            38: short errlineno;               /* line number associated with error */
        !            39: 
        !            40: /*
        !            41:  * Definitions for doing memory allocation.
        !            42:  */
        !            43: 
        !            44: extern char *malloc();
        !            45: 
        !            46: #define alloc(n, type) ((type *) malloc((unsigned) (n) * sizeof(type)))
        !            47: #define dispose(p)     { free((char *) p); p = 0; }
        !            48: 
        !            49: /*
        !            50:  * Macros for doing freads + fwrites.
        !            51:  */
        !            52: 
        !            53: #define get(fp, var)   fread((char *) &(var), sizeof(var), 1, fp)
        !            54: #define put(fp, var)   fwrite((char *) &(var), sizeof(var), 1, fp)
        !            55: 
        !            56: /*
        !            57:  * String definitions.
        !            58:  */
        !            59: 
        !            60: extern String strcpy(), index(), rindex();
        !            61: extern int strlen();
        !            62: 
        !            63: #define strdup(s)              strcpy(malloc((unsigned) strlen(s) + 1), s)
        !            64: #define streq(s1, s2)  (strcmp(s1, s2) == 0)
        !            65: 
        !            66: typedef int INTFUNC();
        !            67: 
        !            68: typedef struct {
        !            69:     INTFUNC *func;
        !            70: } ERRINFO;
        !            71: 
        !            72: #define ERR_IGNORE ((INTFUNC *) 0)
        !            73: #define ERR_CATCH  ((INTFUNC *) 1)
        !            74: 
        !            75: /*
        !            76:  * Call a program.
        !            77:  *
        !            78:  * Four entries:
        !            79:  *
        !            80:  *     call, callv - call a program and wait for it, returning status
        !            81:  *     back, backv - call a program and don't wait, returning process id
        !            82:  *
        !            83:  * The command's standard input and output are passed as FILE's.
        !            84:  */
        !            85: 
        !            86: 
        !            87: #define MAXNARGS 100    /* unchecked upper limit on max num of arguments */
        !            88: #define BADEXEC 127    /* exec fails */
        !            89: 
        !            90: #define ischild(pid)    ((pid) == 0)
        !            91: 
        !            92: /* VARARGS3 */
        !            93: public int call(name, in, out, args)
        !            94: String name;
        !            95: File in;
        !            96: File out;
        !            97: String args;
        !            98: {
        !            99:     String *ap, *argp;
        !           100:     String argv[MAXNARGS];
        !           101: 
        !           102:     argp = &argv[0];
        !           103:     *argp++ = name;
        !           104:     ap = &args;
        !           105:     while (*ap != nil(String)) {
        !           106:        *argp++ = *ap++;
        !           107:     }
        !           108:     *argp = nil(String);
        !           109:     return callv(name, in, out, argv);
        !           110: }
        !           111: 
        !           112: /* VARARGS3 */
        !           113: public int back(name, in, out, args)
        !           114: String name;
        !           115: File in;
        !           116: File out;
        !           117: String args;
        !           118: {
        !           119:     String *ap, *argp;
        !           120:     String argv[MAXNARGS];
        !           121: 
        !           122:     argp = &argv[0];
        !           123:     *argp++ = name;
        !           124:     ap = &args;
        !           125:     while (*ap != nil(String)) {
        !           126:        *argp++ = *ap++;
        !           127:     }
        !           128:     *argp = nil(String);
        !           129:     return backv(name, in, out, argv);
        !           130: }
        !           131: 
        !           132: public int callv(name, in, out, argv)
        !           133: String name;
        !           134: File in;
        !           135: File out;
        !           136: String *argv;
        !           137: {
        !           138:     int pid, status;
        !           139: 
        !           140:     pid = backv(name, in, out, argv);
        !           141:     pwait(pid, &status);
        !           142:     return status;
        !           143: }
        !           144: 
        !           145: public int backv(name, in, out, argv)
        !           146: String name;
        !           147: File in;
        !           148: File out;
        !           149: String *argv;
        !           150: {
        !           151:     int pid;
        !           152: 
        !           153:     fflush(stdout);
        !           154:     if (ischild(pid = fork())) {
        !           155:        fswap(0, fileno(in));
        !           156:        fswap(1, fileno(out));
        !           157:        onsyserr(EACCES, ERR_IGNORE);
        !           158:        execvp(name, argv);
        !           159:        _exit(BADEXEC);
        !           160:     }
        !           161:     return pid;
        !           162: }
        !           163: 
        !           164: /*
        !           165:  * Swap file numbers so as to redirect standard input and output.
        !           166:  */
        !           167: 
        !           168: private fswap(oldfd, newfd)
        !           169: int oldfd;
        !           170: int newfd;
        !           171: {
        !           172:     if (oldfd != newfd) {
        !           173:        close(oldfd);
        !           174:        dup(newfd);
        !           175:        close(newfd);
        !           176:     }
        !           177: }
        !           178: 
        !           179: /*
        !           180:  * Invoke a shell on a command line.
        !           181:  */
        !           182: 
        !           183: #define DEF_SHELL      "csh"
        !           184: 
        !           185: public shell(s)
        !           186: String s;
        !           187: {
        !           188:     extern String getenv();
        !           189:     String sh;
        !           190: 
        !           191:     if ((sh = getenv("SHELL")) == nil(String)) {
        !           192:        sh = DEF_SHELL;
        !           193:     }
        !           194:     call(sh, stdin, stdout, "-c", s, 0);
        !           195: }
        !           196: 
        !           197: /*
        !           198:  * Wait for a process the right way.  We wait for a particular
        !           199:  * process and if any others come along in between, we remember them
        !           200:  * in case they are eventually waited for.
        !           201:  *
        !           202:  * This routine is not very efficient when the number of processes
        !           203:  * to be remembered is large.
        !           204:  */
        !           205: 
        !           206: typedef struct pidlist {
        !           207:     int pid;
        !           208:     int status;
        !           209:     struct pidlist *next;
        !           210: } Pidlist;
        !           211: 
        !           212: private Pidlist *pidlist, *pfind();
        !           213: 
        !           214: public pwait(pid, statusp)
        !           215: int pid, *statusp;
        !           216: {
        !           217:        Pidlist *p;
        !           218:        int pnum, status;
        !           219: 
        !           220:        p = pfind(pid);
        !           221:        if (p != nil(Pidlist *)) {
        !           222:            *statusp = p->status;
        !           223:            dispose(p);
        !           224:            return;
        !           225:        }
        !           226:        while ((pnum = wait(&status)) != pid && pnum >= 0) {
        !           227:            p = alloc(1, Pidlist);
        !           228:            p->pid = pnum;
        !           229:            p->status = status;
        !           230:            p->next = pidlist;
        !           231:            pidlist = p;
        !           232:        }
        !           233:        if (pnum < 0) {
        !           234:            p = pfind(pid);
        !           235:            if (p == nil(Pidlist *)) {
        !           236:                panic("pwait: pid %d not found", pid);
        !           237:            }
        !           238:            *statusp = p->status;
        !           239:            dispose(p);
        !           240:        } else {
        !           241:                *statusp = status;
        !           242:        }
        !           243: }
        !           244: 
        !           245: /*
        !           246:  * Look for the given process id on the pidlist.
        !           247:  *
        !           248:  * Unlink it from list if found.
        !           249:  */
        !           250: 
        !           251: private Pidlist *pfind(pid)
        !           252: int pid;
        !           253: {
        !           254:     register Pidlist *p, *prev;
        !           255: 
        !           256:     prev = nil(Pidlist *);
        !           257:     for (p = pidlist; p != nil(Pidlist *); p = p->next) {
        !           258:        if (p->pid == pid) {
        !           259:            break;
        !           260:        }
        !           261:        prev = p;
        !           262:     }
        !           263:     if (p != nil(Pidlist *)) {
        !           264:        if (prev == nil(Pidlist *)) {
        !           265:                pidlist = p->next;
        !           266:        } else {
        !           267:                prev->next = p->next;
        !           268:        }
        !           269:     }
        !           270:     return p;
        !           271: }
        !           272: 
        !           273: /*
        !           274:  * System call error handler.
        !           275:  *
        !           276:  * The syserr routine is called when a system call is about to
        !           277:  * set the c-bit to report an error.  Certain errors are caught
        !           278:  * and cause the process to print a message and immediately exit.
        !           279:  */
        !           280: 
        !           281: extern int sys_nerr;
        !           282: extern char *sys_errlist[];
        !           283:  
        !           284: /*
        !           285:  * Before calling syserr, the integer errno is set to contain the
        !           286:  * number of the error.  The routine "_mycerror" is a dummy which
        !           287:  * is used to force the loader to get my version of cerror rather
        !           288:  * than the usual one.
        !           289:  */
        !           290: 
        !           291: extern int errno;
        !           292: extern _mycerror();
        !           293: 
        !           294: /*
        !           295:  * default error handling
        !           296:  */
        !           297: 
        !           298: private ERRINFO errinfo[] ={
        !           299: /* no error */ ERR_IGNORE,
        !           300: /* EPERM */    ERR_IGNORE,
        !           301: /* ENOENT */   ERR_IGNORE,
        !           302: /* ESRCH */    ERR_IGNORE,
        !           303: /* EINTR */    ERR_CATCH,
        !           304: /* EIO */      ERR_CATCH,
        !           305: /* ENXIO */    ERR_CATCH,
        !           306: /* E2BIG */    ERR_CATCH,
        !           307: /* ENOEXEC */  ERR_CATCH,
        !           308: /* EBADF */    ERR_IGNORE,
        !           309: /* ECHILD */   ERR_CATCH,
        !           310: /* EAGAIN */   ERR_CATCH,
        !           311: /* ENOMEM */   ERR_CATCH,
        !           312: /* EACCES */   ERR_CATCH,
        !           313: /* EFAULT */   ERR_CATCH,
        !           314: /* ENOTBLK */  ERR_CATCH,
        !           315: /* EBUSY */    ERR_CATCH,
        !           316: /* EEXIST */   ERR_CATCH,
        !           317: /* EXDEV */    ERR_CATCH,
        !           318: /* ENODEV */   ERR_CATCH,
        !           319: /* ENOTDIR */  ERR_CATCH,
        !           320: /* EISDIR */   ERR_CATCH,
        !           321: /* EINVAL */   ERR_CATCH,
        !           322: /* ENFILE */   ERR_CATCH,
        !           323: /* EMFILE */   ERR_CATCH,
        !           324: /* ENOTTY */   ERR_IGNORE,
        !           325: /* ETXTBSY */  ERR_CATCH,
        !           326: /* EFBIG */    ERR_CATCH,
        !           327: /* ENOSPC */   ERR_CATCH,
        !           328: /* ESPIPE */   ERR_CATCH,
        !           329: /* EROFS */    ERR_CATCH,
        !           330: /* EMLINK */   ERR_CATCH,
        !           331: /* EPIPE */    ERR_CATCH,
        !           332: /* EDOM */     ERR_CATCH,
        !           333: /* ERANGE */   ERR_CATCH,
        !           334: /* EQUOT */    ERR_CATCH,
        !           335: };
        !           336: 
        !           337: public syserr()
        !           338: {
        !           339:     ERRINFO *e;
        !           340: 
        !           341:     e = &errinfo[errno];
        !           342:     if (e->func == ERR_CATCH) {
        !           343:        if (errno < sys_nerr) {
        !           344:            panic(sys_errlist[errno]);
        !           345:        } else {
        !           346:            panic("errno %d", errno);
        !           347:        }
        !           348:     } else if (e->func != ERR_IGNORE) {
        !           349:        (*e->func)();
        !           350:     }
        !           351: }
        !           352: 
        !           353: /*
        !           354:  * Catcherrs only purpose is to get this module loaded and make
        !           355:  * sure my cerror is loaded (only applicable when this is in a library).
        !           356:  */
        !           357: 
        !           358: public catcherrs()
        !           359: {
        !           360:     _mycerror();
        !           361: }
        !           362: 
        !           363: /*
        !           364:  * Change the action on receipt of an error.
        !           365:  */
        !           366: 
        !           367: public onsyserr(n, f)
        !           368: int n;
        !           369: INTFUNC *f;
        !           370: {
        !           371:     errinfo[n].func = f;
        !           372: }
        !           373: 
        !           374: /*
        !           375:  * Standard error handling routines.
        !           376:  */
        !           377: 
        !           378: private short nerrs;
        !           379: private short nwarnings;
        !           380: 
        !           381: /*
        !           382:  * Main driver of error message reporting.
        !           383:  */
        !           384: 
        !           385: /* VARARGS2 */
        !           386: private errmsg(errname, shouldquit, s, a, b, c, d, e, f, g, h, i, j, k, l, m)
        !           387: String errname;
        !           388: Boolean shouldquit;
        !           389: String s;
        !           390: {
        !           391:     fflush(stdout);
        !           392:     if (shouldquit and cmdname != nil(String)) {
        !           393:        fprintf(stderr, "%s: ", cmdname);
        !           394:     }
        !           395:     if (errfilename != nil(Filename)) {
        !           396:        fprintf(stderr, "%s: ", errfilename);
        !           397:     }
        !           398:     if (errlineno > 0) {
        !           399:        fprintf(stderr, "%d: ", errlineno);
        !           400:     }
        !           401:     if (errname != nil(String)) {
        !           402:        fprintf(stderr, "%s: ", errname);
        !           403:     }
        !           404:     fprintf(stderr, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
        !           405:     putc('\n', stderr);
        !           406:     if (shouldquit) {
        !           407:        quit(1);
        !           408:     }
        !           409: }
        !           410: 
        !           411: /*
        !           412:  * The messages are listed in increasing order of seriousness.
        !           413:  *
        !           414:  * First are warnings.
        !           415:  */
        !           416: 
        !           417: /* VARARGS1 */
        !           418: public warning(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
        !           419: String s;
        !           420: {
        !           421:     nwarnings++;
        !           422:     errmsg("warning", FALSE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
        !           423: }
        !           424: 
        !           425: /*
        !           426:  * Errors are a little worse, they mean something is wrong,
        !           427:  * but not so bad that processing can't continue.
        !           428:  *
        !           429:  * The routine "erecover" is called to recover from the error,
        !           430:  * a default routine is provided that does nothing.
        !           431:  */
        !           432: 
        !           433: /* VARARGS1 */
        !           434: public error(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
        !           435: String s;
        !           436: {
        !           437:     extern erecover();
        !           438: 
        !           439:     nerrs++;
        !           440:     errmsg(nil(String), FALSE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
        !           441:     erecover();
        !           442: }
        !           443: 
        !           444: /*
        !           445:  * Non-recoverable user error.
        !           446:  */
        !           447: 
        !           448: /* VARARGS1 */
        !           449: public fatal(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
        !           450: String s;
        !           451: {
        !           452:     errmsg("fatal error", TRUE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
        !           453: }
        !           454: 
        !           455: /*
        !           456:  * Panics indicate an internal program error.
        !           457:  */
        !           458: 
        !           459: /* VARARGS1 */
        !           460: public panic(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
        !           461: String s;
        !           462: {
        !           463:     errmsg("panic", TRUE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
        !           464: }
        !           465: 
        !           466: short numerrors()
        !           467: {
        !           468:     short r;
        !           469: 
        !           470:     r = nerrs;
        !           471:     nerrs = 0;
        !           472:     return r;
        !           473: }
        !           474: 
        !           475: short numwarnings()
        !           476: {
        !           477:     short r;
        !           478: 
        !           479:     r = nwarnings;
        !           480:     nwarnings = 0;
        !           481:     return r;
        !           482: }
        !           483: 
        !           484: /*
        !           485:  * Recover from an error.
        !           486:  *
        !           487:  * This is the default routine which we aren't using since we have our own.
        !           488:  *
        !           489: public erecover()
        !           490: {
        !           491: }
        !           492:  *
        !           493:  */
        !           494: 
        !           495: /*
        !           496:  * Default way to quit from a program is just to exit.
        !           497:  *
        !           498: public quit(r)
        !           499: int r;
        !           500: {
        !           501:     exit(r);
        !           502: }
        !           503:  *
        !           504:  */
        !           505: 
        !           506: /*
        !           507:  * Compare n-byte areas pointed to by s1 and s2
        !           508:  * if n is 0 then compare up until one has a null byte.
        !           509:  */
        !           510: 
        !           511: public int cmp(s1, s2, n)
        !           512: register char *s1, *s2;
        !           513: register unsigned int n;
        !           514: {
        !           515:     if (s1 == nil(char *) || s2 == nil(char *)) {
        !           516:        panic("cmp: nil pointer");
        !           517:     }
        !           518:     if (n == 0) {
        !           519:        while (*s1 == *s2++) {
        !           520:            if (*s1++ == '\0') {
        !           521:                return(0);
        !           522:            }
        !           523:        }
        !           524:        return(*s1 - *(s2-1));
        !           525:     } else {
        !           526:        for (; n != 0; n--) {
        !           527:            if (*s1++ != *s2++) {
        !           528:                return(*(s1-1) - *(s2-1));
        !           529:            }
        !           530:        }
        !           531:        return(0);
        !           532:     }
        !           533: }
        !           534: 
        !           535: /*
        !           536:  * Move n bytes from src to dest.
        !           537:  * If n is 0 move until a null is found.
        !           538:  */
        !           539: 
        !           540: public mov(src, dest, n)
        !           541: register char *src, *dest;
        !           542: register unsigned int n;
        !           543: {
        !           544:     if (src == nil(char *))
        !           545:        panic("mov: nil source");
        !           546:     if (dest == nil(char *))
        !           547:        panic("mov: nil destination");
        !           548:     if (n > 0) {
        !           549:        for (; n != 0; n--) {
        !           550:            *dest++ = *src++;
        !           551:        }
        !           552:     } else {
        !           553:        while ((*dest++ = *src++) != '\0');
        !           554:     }
        !           555: }

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