Return to read.c CVS log

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

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

1.1     ! root        1: /* Copyright Bell Telephone Laboratories Whippany, N.J.
        !             2: 
        !             3:  *     ***********************************************
        !             4:  *     ***********************************************
        !             5:  *     *** READ INFORMATION FROM 'data' STATEMENTS ***
        !             6:  *     ********* R. B. Drake WH 8C-005 X4163 *********
        !             7:  *     ********** Sun Aug 26 11:19:29 1979 ***********
        !             8:  *     ***********************************************
        !             9:  *     ***********************************************
        !            10:  * "read" locates the next item of information in a 'data' sttement
        !            11:  * and places it in variables defined by a list following the read
        !            12:  * command.
        !            13: 
        !            14: */
        !            15: /*   "@(#) read.c:  V 1.4  3/4/81" */
        !            16: 
        !            17: #include "bas.h"
        !            18: static char *daptr;
        !            19: static char *itmptr;
        !            20: extern int atad;
        !            21: double evalx();
        !            22: char *prncpy();
        !            23: int arflg;
        !            24: getnext()
        !            25: {
        !            26:        while(fetch(-1, &daptr) == 0)
        !            27:        {
        !            28:                if(inst.thing.opcode.lobyte == atad)
        !            29:                {
        !            30:                        itmptr = expr;
        !            31:                        return(0);
        !            32:                }
        !            33:        }
        !            34:        error(inst.thing.linno,33);
        !            35:        return(-1);
        !            36: }
        !            37: __read()
        !            38: {
        !            39:        char *ptr;
        !            40:        int flg;
        !            41: #ifdef STRINGS
        !            42:        char    *savptr;
        !            43:        char    field[40];
        !            44:        char    result[80];
        !            45: #endif
        !            46:        char ascop[80],ascno[80];
        !            47:        ptr = expr;
        !            48:        if(daptr == 0)
        !            49:        {
        !            50:                if(fetch(0, &daptr) != 0)
        !            51:                {
        !            52:                        error(inst.thing.linno,33);
        !            53:                        return(0);
        !            54:                }
        !            55:                if(inst.thing.opcode.lobyte == atad)
        !            56:                        itmptr = expr;
        !            57:                else
        !            58:                if(getnext() < 0)
        !            59:                        return(0);
        !            60:        }
        !            61:        while(1)
        !            62:        {
        !            63:                flg = 0;
        !            64:                ptr = prncpy(ascop,ptr);
        !            65:                if(arflg == 1)
        !            66:                        flg = 1;
        !            67:                switch(*itmptr)
        !            68:                {
        !            69:                        case '\0':
        !            70:                                if(getnext() < 0)
        !            71:                                        return(0);
        !            72:                                break;
        !            73:                        case ',':
        !            74:                                itmptr++;
        !            75:                                if(*itmptr == '\0')
        !            76:                                        if(getnext() < 0)
        !            77:                                                return(0);
        !            78:                }
        !            79:                itmptr = prncpy(ascno,itmptr);
        !            80: #ifdef STRINGS
        !            81:                savptr = ascno;
        !            82:                if(class(&savptr,field) < STCLASS)
        !            83:                {
        !            84: #endif
        !            85:                        if(flg==1)
        !            86:                                aputvar(ascop,evalx(ascno));
        !            87:                        else
        !            88:                                putvar(ascop,evalx(ascno));
        !            89: #ifdef STRINGS
        !            90:                }
        !            91:                else
        !            92:                {
        !            93:                        evals(ascno,result);
        !            94:                        savptr=ascop;
        !            95:                        if(class(&savptr,field) == SACLASS)
        !            96:                                saputvar(field,result);
        !            97:                        else
        !            98:                                sputvar(field,result);
        !            99:                }
        !           100: #endif
        !           101:                if(*ptr++ == '\0')
        !           102:                        return(0);
        !           103:        }
        !           104: }
        !           105: restore()
        !           106: {
        !           107:        daptr = 0;
        !           108:        return(0);
        !           109: }
        !           110: char *prncpy(to,from)
        !           111: char register *to,*from;
        !           112: {
        !           113:        int prncnt,i;
        !           114:        prncnt = 0;
        !           115:        arflg = 0;
        !           116:        for(i=0;*from != '\0';i++)
        !           117:        {
        !           118:                if(*from == ',' && prncnt == 0) break;
        !           119:                to[i] = *from++;
        !           120:                switch(to[i])
        !           121:                {
        !           122:                        case '(':
        !           123:                                prncnt += 1;
        !           124:                                arflg = 1;
        !           125:                                break;
        !           126:                        case ')':
        !           127:                                prncnt -= 1;
        !           128:                }
        !           129:        }
        !           130:        to[i] = '\0';
        !           131:        return(from);
        !           132: }

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