Return to main.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / main

Annotation of 43BSD/ucb/pascal/pdx/main/main.c, revision 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: char copyright[] =
        !             9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
        !            10:  All rights reserved.\n";
        !            11: #endif not lint
        !            12: 
        !            13: #ifndef lint
        !            14: static char sccsid[] = "@(#)main.c     5.1 (Berkeley) 6/7/85";
        !            15: #endif not lint
        !            16: 
        !            17: /*
        !            18:  * Debugger main routine.
        !            19:  */
        !            20: 
        !            21: #include "defs.h"
        !            22: #include <setjmp.h>
        !            23: #include <signal.h>
        !            24: #include "main.h"
        !            25: #include "command.h"
        !            26: #include "process.h"
        !            27: #include "object.h"
        !            28: 
        !            29: #define FIRST_TIME 0        /* initial value setjmp returns */
        !            30: 
        !            31: LOCAL int firstarg;
        !            32: LOCAL jmp_buf env;
        !            33: LOCAL catchintr();
        !            34: 
        !            35: main(argc, argv)
        !            36: int argc;
        !            37: char **argv;
        !            38: {
        !            39:     FILE *fp;
        !            40:     int i;
        !            41: 
        !            42:     catcherrs();
        !            43:     catchsigs();
        !            44:     scanargs(argc, argv);
        !            45:     cmdname = argv[0];
        !            46:     if ((fp = fopen(objname, "r")) == NIL) {
        !            47:        panic("can't read %s", objname);
        !            48:     } else {
        !            49:        fclose(fp);
        !            50:     }
        !            51:     if (option('r')) {
        !            52:        if (setjmp(env) == FIRST_TIME) {
        !            53:            arginit();
        !            54:            for (i = firstarg; i < argc; i++) {
        !            55:                newarg(argv[i]);
        !            56:            }
        !            57:            run();
        !            58:            /* NOTREACHED */
        !            59:        } else {
        !            60:            option('r') = FALSE;
        !            61:        }
        !            62:     } else {
        !            63:        initstart();
        !            64:        prompt();
        !            65:        init();
        !            66:     }
        !            67:     setjmp(env);
        !            68:     signal(SIGINT, catchintr);
        !            69:     yyparse();
        !            70:     putchar('\n');
        !            71:     quit(0);
        !            72: }
        !            73: 
        !            74: /*
        !            75:  * Initialize the world, including setting initial input file
        !            76:  * if the file exists.
        !            77:  */
        !            78: 
        !            79: init()
        !            80: {
        !            81:     initinput();
        !            82:     readobj(objname);
        !            83:     lexinit();
        !            84: }
        !            85: 
        !            86: /*
        !            87:  * After a non-fatal error we jump back to command parsing.
        !            88:  */
        !            89: 
        !            90: erecover()
        !            91: {
        !            92:     gobble();
        !            93:     prompt();
        !            94:     longjmp(env, 1);
        !            95: }
        !            96: 
        !            97: /*
        !            98:  * This routine is called when an interrupt occurs.
        !            99:  */
        !           100: 
        !           101: LOCAL catchintr()
        !           102: {
        !           103:     putchar('\n');
        !           104:     prompt();
        !           105:     longjmp(env, 1);
        !           106: }
        !           107: 
        !           108: /*
        !           109:  * scan the argument list
        !           110:  */
        !           111: 
        !           112: LOCAL scanargs(argc, argv)
        !           113: int argc;
        !           114: char **argv;
        !           115: {
        !           116:     register int i, j;
        !           117:     BOOLEAN done;
        !           118: 
        !           119:     if (streq(argv[0], "pxhdr") || streq(argv[0], "pix")) {
        !           120:        objname = argv[1];
        !           121:        option('r') = TRUE;
        !           122:        option('t') = TRUE;
        !           123:        if (streq(argv[0], "pxhdr")) {
        !           124:            setargs("pdx", argv[2]);
        !           125:            firstarg = 3;
        !           126:        } else {
        !           127:            setargs("pix", NIL);
        !           128:            firstarg = 2;
        !           129:        }
        !           130:        argv[0] = "pdx";
        !           131:     } else {
        !           132:        done = FALSE;
        !           133:        i = 1;
        !           134:        while (i < argc && !done) {
        !           135:            if (argv[i][0] == '-') {
        !           136:                for (j = 1; argv[i][j] != '\0'; j++) {
        !           137:                    switch (argv[i][j]) {
        !           138:                        case 'r':   /* run program before accepting commands */
        !           139:                        case 'i':   /* assume input is a terminal */
        !           140:                        case 'b':   /* (internal) trace breakpoints */
        !           141:                        case 'e':   /* (internal) trace execution */
        !           142:                        case 'h':   /* (internal) display header information */
        !           143:                            option(argv[i][j]) = TRUE;
        !           144:                            break;
        !           145: 
        !           146:                    default:
        !           147:                        panic("bad option \"%c\"", argv[i]);
        !           148:                    }
        !           149:                }
        !           150:            } else {
        !           151:                objname = argv[i];
        !           152:                done = TRUE;
        !           153:            }
        !           154:            i++;
        !           155:        }
        !           156:        firstarg = i;
        !           157:        setargs("pdx", objname);
        !           158:     }
        !           159: }
        !           160: 
        !           161: /*
        !           162:  * Terminate program.  In the case of the -t option, we must remove
        !           163:  * the object file because it's a tmp file.
        !           164:  */
        !           165: 
        !           166: quit(r)
        !           167: int r;
        !           168: {
        !           169:     if (option('t')) {
        !           170:        unlink(objname);
        !           171:     }
        !           172:     exit(r);
        !           173: }
        !           174: 
        !           175: LOCAL catchsigs()
        !           176: {
        !           177:     signal(SIGHUP, quit);
        !           178:     signal(SIGQUIT, quit);
        !           179: }

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