Return to main.c CVS log

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

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

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