Return to main.c CVS log

Up to [Research Unix] / researchv8dc / cmd / adb

Annotation of researchv8dc/cmd/adb/main.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * adb - main command loop and error/interrupt handling
        !             3:  */
        !             4: #include "defs.h"
        !             5: #include <signal.h>
        !             6: #include <setjmp.h>
        !             7: 
        !             8: MSG    NOEOR;
        !             9: 
        !            10: char *errflg;
        !            11: BOOL wtflag;
        !            12: 
        !            13: BOOL mkfault;
        !            14: ADDR maxoff;
        !            15: 
        !            16: int xargc;             /* bullshit */
        !            17: 
        !            18: BOOL   executing;
        !            19: int    infile;
        !            20: char   *lp;
        !            21: static int     exitflg;
        !            22: int    (*sigint)();
        !            23: int    (*sigqit)();
        !            24: 
        !            25: char   lastc;
        !            26: int    eof;
        !            27: 
        !            28: char   *Ipath = "/usr/lib/adb";
        !            29: static jmp_buf env;
        !            30: 
        !            31: main(argc, argv)
        !            32: register char **argv;
        !            33: int argc;
        !            34: {
        !            35:        extern fault();
        !            36: 
        !            37:        mkioptab();
        !            38:        maxoff = MAXOFF;
        !            39: another:
        !            40:        if (argc>1) {
        !            41:                if (strcmp("-w", argv[1]) == 0) {
        !            42:                        wtflag = 2;             /* suitable for open() */
        !            43:                        argc--, argv++;
        !            44:                        goto another;
        !            45:                }
        !            46:                if (argv[1][0] == '-' && argv[1][1] == 'I') {
        !            47:                        Ipath = argv[1]+2;
        !            48:                        argc--, argv++;
        !            49:                }
        !            50:        }
        !            51:        if (argc > 1)
        !            52:                symfil = argv[1];
        !            53:        if (argc > 2)
        !            54:                corfil = argv[2];
        !            55:        xargc = argc;
        !            56:        setsym();
        !            57:        setcor();
        !            58:        setvar();
        !            59: 
        !            60:        if ((sigint=signal(SIGINT,SIG_IGN)) != SIG_IGN) {
        !            61:                sigint = fault;
        !            62:                signal(SIGINT, fault);
        !            63:        }
        !            64:        sigqit = signal(SIGQUIT, SIG_IGN);
        !            65:        setjmp(env);
        !            66:        if (executing)
        !            67:                delbp();
        !            68:        executing = 0;
        !            69:        for (;;) {
        !            70:                flushbuf();
        !            71:                if (errflg) {
        !            72:                        printf("%s\n", errflg);
        !            73:                        exitflg = 1;
        !            74:                        errflg = 0;
        !            75:                }
        !            76:                if (mkfault) {
        !            77:                        mkfault=0;
        !            78:                        printc('\n');
        !            79:                        prints(DBNAME);
        !            80:                }
        !            81:                clrinp();
        !            82:                rdc();
        !            83:                reread();
        !            84:                if (eof) {
        !            85:                        if (infile == STDIN)
        !            86:                                done();
        !            87:                        iclose(-1, 0);
        !            88:                        eof = 0;
        !            89:                        longjmp(env, 1);
        !            90:                }
        !            91:                exitflg = 0;
        !            92:                command((char *)NULL, 0);
        !            93:                reread();
        !            94:                if (rdc() != '\n')
        !            95:                        error(NOEOR);
        !            96:        }
        !            97: }
        !            98: 
        !            99: done()
        !           100: {
        !           101:        if (pid)
        !           102:                endpcs();
        !           103:        exit(exitflg);
        !           104: }
        !           105: 
        !           106: WORD
        !           107: round(a,b)
        !           108: register WORD a, b;
        !           109: {
        !           110:        register WORD w;
        !           111: 
        !           112:        w = (a/b)*b;
        !           113:        if (a!=w)
        !           114:                w += b;
        !           115:        return(w);
        !           116: }
        !           117: 
        !           118: /*
        !           119:  * If there has been an error or a fault, take the error.
        !           120:  */
        !           121: chkerr()
        !           122: {
        !           123:        if (errflg || mkfault)
        !           124:                error(errflg);
        !           125: }
        !           126: 
        !           127: /*
        !           128:  * An error occurred; save the message for later printing,
        !           129:  * close open files, and reset to main command loop.
        !           130:  */
        !           131: error(n)
        !           132: char *n;
        !           133: {
        !           134:        errflg = n;
        !           135:        iclose(0, 1);
        !           136:        oclose();
        !           137:        longjmp(env, 1);
        !           138: }
        !           139: 
        !           140: /*
        !           141:  * An interrupt occurred; reset the interrupt
        !           142:  * catch, seek to the end of the current file
        !           143:  * and remember that there was a fault.
        !           144:  */
        !           145: fault(a)
        !           146: {
        !           147:        signal(a, fault);
        !           148:        lseek(infile, 0L, 2);
        !           149:        mkfault++;
        !           150: }

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