Return to bfiles.c CVS log

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

Annotation of researchv10no/cmd/basic/bite/src/bfiles.c, revision 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: }

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