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

1.1       root        1: /* Copyright Bell Telephone Laboratories Whippany, N.J.
                      2: 
                      3:  *     /////////////////////////////////////
                      4:  *     /////////////////////////////////////
                      5:  *     ///////////// bfiles.c //////////////
                      6:  *     /// J. P. Hawkins WH X4610 8C-001 ///
                      7:  *     ///// Fri Aug 24 17:18:03 1979 //////
                      8:  *     /////////////////////////////////////
                      9:  *     /////////////////////////////////////
                     10: 
                     11:  *
                     12:  *     File Access Preparation Routines
                     13:  */
                     14: /*   "@(#) bfiles.c:  V 1.4  9/9/81" */
                     15: #include       "bas.h"
                     16: extern moreflag[];
                     17: 
                     18: struct FILTBL filtbl[] = {
                     19:        {'\0', 2},      /* File Designator # 1 */
                     20:        {'\0', 4},      /* File Designator # 2 */
                     21:        {'\0', 6},      /* File Designator # 3 */
                     22:        {'\0', 8},      /* File Designator # 4 */
                     23:        {'\0', 10},     /* File Designator # 5 */
                     24:        {'\0', 12},     /* File Designator # 6 */
                     25:        {'\0', 14},     /* File Designator # 7 */
                     26:        {'\0', 16},     /* File Designator # 8 */
                     27:        {'e', -1}       /* END MARKER */
                     28:        };
                     29: 
                     30: /*
                     31:  * ////// OPENO //////
                     32:  *
                     33:  * Open file for output.
                     34:  */
                     35: openo()
                     36: {
                     37:        setfile(1,'w');
                     38: }
                     39: 
                     40: /*
                     41:  * ////// OPENI //////
                     42:  *
                     43:  * Open file for input.
                     44:  */
                     45: openi()
                     46: {
                     47:        setfile(0,'r');
                     48: }
                     49: 
                     50: /*
                     51:  * ////// APPEND //////
                     52:  *
                     53:  * Open file for append or create if non-existant.
                     54:  */
                     55: append()
                     56: {
                     57:        setfile(2,'w');
                     58: }
                     59: /*
                     60:  *
                     61:  * //// OPEN FILES for READ, WRITE or APPEND ////
                     62:  *
                     63:  * write is mode 1
                     64:  *
                     65:  *
                     66:  */
                     67: setfile(modnum,modchar)
                     68: int    modnum;
                     69: char   modchar;
                     70: {
                     71:        int     size;   /* field size */
                     72:        char    field[20];
                     73:        int     save;
                     74:        char    *ptr;
                     75: #ifdef STRINGS
                     76:        char    *savptr;
                     77: #endif
                     78:        int     i;
                     79:        int     madeit;
                     80:        ptr = expr;
                     81: 
                     82:        i = 0;
                     83:        while(filtbl[i].mode != 'e')
                     84:        {
                     85:                madeit = 0;     /* flag fact that no file was open */
                     86:                save = (int)ptr;
                     87:                if(scanfld(&ptr,field,',') == 0)
                     88:                        break;
                     89: #ifdef STRINGS
                     90:                savptr = field;
                     91:                if(class(&savptr,scratch) >= STCLASS)
                     92:                {
                     93:                        evals(field,field); /* expand expr */
                     94:                }
                     95: #endif
                     96:                size = strlen(field);
                     97:                if(filtbl[i].mode == '\0') /* if this slot not used */
                     98:                {
                     99:                        if(size > 14)
                    100:                        {
                    101:                                error(inst.thing.linno, 34); /* filename too long */
                    102:                                return(-1);
                    103:                        }
                    104:                        if((filtbl[i].fildes = copen(field, modnum)) < 0)
                    105:                        {
                    106:                                error(inst.thing.linno, 2); /* open error */
                    107:                                return(-1);
                    108:                        }
                    109:                        filtbl[i].mode = modchar; /* set mode for write */
                    110:                        madeit = 1;     /* flag the fact an entry was made */
                    111:                        moreflag[i] = 0;
                    112:                }
                    113:                else
                    114:                {
                    115:                        ptr = (char *)save;  /* back up input string pointer */
                    116:                }
                    117:                i++;
                    118:        }
                    119:        if(!madeit && (filtbl[i].mode == 'e'))
                    120:        {
                    121:                error(inst.thing.linno, 35);    /* FILE DES. USED UP */
                    122:                return(-1);
                    123:        }
                    124:        return(0);
                    125: }
                    126: /*
                    127:  *
                    128:  * ////// FILE CLOSE //////
                    129:  *
                    130:  * format:     closef _des
                    131:  */
                    132: _closef()
                    133: {
                    134:        int     fd;
                    135:        if((expr[0] == '_') && (expr[1] >= '0' && expr[1] <= '4'))
                    136:        {
                    137:                fd = expr[1] - '1';
                    138:                close(filtbl[fd].fildes);
                    139:                moreflag[fd] = 0;       /* init more flag for this desc. */
                    140:                filtbl[fd].mode = '\0'; /* mark it available */
                    141:        }
                    142:        else
                    143:        {
                    144:                error(inst.thing.linno, 32);
                    145:                return(-1);
                    146:        }
                    147:        return(0);
                    148: }
                    149: 
                    150: /*
                    151:  * ////// CLOSEALL //////
                    152:  *
                    153:  * Close ALL open files.
                    154:  */
                    155: clall()
                    156: {
                    157:        int     i;
                    158: 
                    159:        for(i=0; filtbl[i].mode != 'e'; i++)    /* scan file table */
                    160:        {
                    161:                if(filtbl[i].mode != '\0')      /* if this entry has
                    162:                                                    an open file */
                    163:                {
                    164:                        filtbl[i].mode = '\0';  /* mark this slot unused */
                    165:                        close(filtbl[i].fildes); /* close this file */
                    166:                        moreflag[i] = 0;        /* init moreflag */
                    167:                }
                    168:        }
                    169:        return(0);
                    170: }
                    171: /*
                    172:  *
                    173:  * ////// SCANFLD //////
                    174:  *
                    175:  * scan for fields delimited by dlm
                    176:  */
                    177: scanfld(ptr,field,dlm)
                    178: char   **ptr;
                    179: char   field[];
                    180: char   dlm;
                    181: {
                    182:        int     i;
                    183: 
                    184:        for(i=0; (**ptr != dlm) && (**ptr != '\0'); )
                    185:        {
                    186:                field[i++] = *(*ptr)++;
                    187:        }
                    188:        field[i] = '\0';        /* null term */
                    189:        if(**ptr == dlm) *(*ptr)++;     /* bump past comma */
                    190:        return(i);
                    191: }

unix.superglobalmegacorp.com

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