Return to basic.c CVS log

Up to [Research Unix] / researchv10no / cmd / basic / bite / src

Annotation of researchv10no/cmd/basic/bite/src/basic.c, revision 1.1

1.1     ! root        1: /* Copyright Bell Telephone Laboratories Whippany, N.J.
        !             2: 
        !             3:  *     ***********************************
        !             4:  *     ***********************************
        !             5:  *     ****** MAIN PROGRAM FOR BITE ******
        !             6:  *     *** R. B. Drake WH 8C-005 X4163 ***
        !             7:  *     **** Fri Aug 24 14:38:50 1979 *****
        !             8:  *     ***********************************
        !             9:  *     ***********************************
        !            10:  *
        !            11:  * mod,J.P.Hawkins,17-SEP-79, encode "else" and "endif"
        !            12: 
        !            13:  * MOD,J.P.Hawkins to read environment for BITEPATH
        !            14:  */
        !            15: /*   "@(#) basic.c:  V 1.3  6/17/81" */
        !            16: 
        !            17: /*
        !            18:  * THIS IS THE CALL INTERFACE TO BASIC
        !            19:  *
        !            20:  * the cmd format is
        !            21:  * bite [-] prog1 prog2 ......
        !            22:  *
        !            23:  * where - causes the programs to load without executing
        !            24:  *
        !            25:  */
        !            26: #include "bas.h"
        !            27: extern int     endfcnt;
        !            28: extern char    bpath[];
        !            29: static int nquit;
        !            30: quit()
        !            31: {
        !            32:        signal(2,quit);
        !            33:        nquit = 1;
        !            34:        printf("\n?\n");
        !            35:        return(0);
        !            36: }
        !            37: int rem;
        !            38: int atad;
        !            39: int tv;
        !            40: int tel;
        !            41: int nxt;
        !            42: int _sub;
        !            43: int _fi;
        !            44: int _togo;
        !            45: int tospgo;
        !            46: int subog;
        !            47: int tsil;
        !            48: int no;
        !            49: int daol;
        !            50: int evas;
        !            51: int dlo;
        !            52: int bat;
        !            53: int esle;      /* else code */
        !            54: int fidne;     /* endif code */
        !            55: int rof;       /* for code */
        !            56: int mr;
        !            57: int sl;
        !            58: /*
        !            59:  *
        !            60:  *
        !            61:  */
        !            62: char txtbuf[NMPAG*PGSIZ];
        !            63: main(argc,argv,envp)
        !            64: int argc;
        !            65: char *argv[];
        !            66: char *envp[];
        !            67: {
        !            68:        int     seed = 1;
        !            69:        int     i;
        !            70:        int     loadgo, j;
        !            71:        endfcnt = 0;    /* initialize structured "if" nest count */
        !            72:        loadgo = 0;     /* init load and go flag */
        !            73:        /*
        !            74:         * Look for BITEPATH in environment and
        !            75:         * append to end of internal search path.
        !            76:         * Users can define their own searchpath for BITE
        !            77:         * by adding BITEPATH=:path1:path2: etc. in their profile
        !            78:         */
        !            79:        for(i=0; envp[i] != 0; i++)
        !            80:        {
        !            81:                if(strncmp("BITEPATH",envp[i],8) == 0)
        !            82:                {
        !            83:                        strcat(bpath,&envp[i][9]);
        !            84:                        break;
        !            85:                }
        !            86:        }
        !            87:        linptr=lbdptr=curptr=txtbuf;
        !            88:        signal(2,quit);
        !            89:        rem=encode("rem");
        !            90:        tv=encode("n");
        !            91:        tospgo=encode("go to");
        !            92:        tsil=encode("list");
        !            93:        atad=encode("data");
        !            94:        daol = encode("load");
        !            95:        evas = encode("save");
        !            96:        dlo = encode("old");
        !            97:        bat = encode("!");
        !            98:        nxt=encode("next");
        !            99:        _sub=encode("s");
        !           100:        _fi=encode("if");
        !           101:        subog=encode("gosub");
        !           102:        no = encode("on");
        !           103:        _togo=encode("goto");
        !           104:        tel=encode("\010");
        !           105:        esle=encode("else");
        !           106:        fidne=encode("endif");
        !           107:        rof=encode("for");
        !           108:        sl=encode("ls");
        !           109:        mr=encode("mr");
        !           110:        initvar();
        !           111:        srand(seed);    /* init random number gen */
        !           112: #ifdef TEST
        !           113:        ibinit(); /* IEEE bus init */
        !           114:        bdvminit(); /* digital voltmeter init */
        !           115: #endif
        !           116: #ifdef LSX
        !           117:        iinit(); /* keyboard interrupt enable */
        !           118: #endif
        !           119:        if(argc > 1)
        !           120:        {
        !           121:                j = 1;                  /* init arg index to 1 */
        !           122:                if(argc > 2 && *argv[1] == '-') /* run flag? */
        !           123:                {
        !           124:                        j = 2;          /* load starting at arg 2 */
        !           125:                        --argc;         /* decrement arg count */
        !           126:                }
        !           127:                else
        !           128:                {
        !           129:                        loadgo = 1;     /* set run flag */
        !           130:                }
        !           131:                for(i=j;--argc;i++)
        !           132:                {
        !           133:                        expr = argv[i];
        !           134:                        load();
        !           135:                }
        !           136:                if(loadgo)      /* run? */
        !           137:                {
        !           138:                        expr = linbuf;
        !           139:                        *expr = '\0';
        !           140:                        run();
        !           141:                }
        !           142:        }
        !           143:        while(1)
        !           144:        {
        !           145:                nquit = 0;
        !           146:                if(bed(stdin) < 0 && nquit != 1) break;
        !           147:        }
        !           148: }
        !           149: nocode(code)
        !           150: int    code;
        !           151: {
        !           152:        int i;
        !           153:        static int *list[] =
        !           154:                { &daol,
        !           155:                &evas,
        !           156:                &dlo,
        !           157:                &rem,
        !           158:                &bat,
        !           159:                &_sub,
        !           160:                &mr,
        !           161:                &sl,
        !           162:                0 };
        !           163:        for(i=0;list[i] !=0;i++)
        !           164:        {
        !           165:                if(code == *list[i])
        !           166:                return(1);
        !           167:        }
        !           168:                return(0);
        !           169: }

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