Return to cflsbuf.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / cpm / src

Annotation of 43BSD/contrib/cpm/src/cflsbuf.c, revision 1.1

1.1     ! root        1: /*     cflsbuf.c       1.10    83/05/13        */
        !             2: 
        !             3: #include <stdio.h>
        !             4: #include "cpmio.h"
        !             5: #include "cpmfio.h"
        !             6: 
        !             7: /*
        !             8:  * Flush a full block to floppy disk file
        !             9:  * (these routines are never called unless a full block is
        !            10:  * to be written)
        !            11:  * Create a new extent if required
        !            12:  */
        !            13: 
        !            14: c_flush(fptr)
        !            15:        register C_FILE *fptr;
        !            16: {
        !            17: 
        !            18:        int     it; 
        !            19:        char    alloc();
        !            20: 
        !            21:        if (!(fptr->c_flag & WRITE)) {
        !            22:                fprintf(stderr, "no write access");
        !            23:                return (EOF);
        !            24:        }
        !            25:        fptr->c_seccnt += blksiz/seclth;
        !            26:        if (putblock(0xff & (int)fptr->c_dirp->pointers[fptr->c_blk++],
        !            27:                                 fptr->c_base, -1) == EOF)
        !            28:                return (EOF);
        !            29:        if (fptr->c_blk == 16) {
        !            30:                fptr->c_dirp->blkcnt =  (char) 0x80;
        !            31:                savedir();
        !            32:                /* create new extent */
        !            33:                if ((it = creext(fptr->c_ext)) == NULL) {
        !            34:                        fprintf(stderr,"can't create new extent, current: %d\n",
        !            35:                                fptr->c_ext);
        !            36:                        return (EOF);
        !            37:                }
        !            38:                fptr->c_dirp = dirbuf+it;
        !            39:                fptr->c_ext  = it;
        !            40:                fptr->c_blk  = 0;
        !            41:                fptr->c_seccnt = 0;
        !            42:                fptr->c_extno++;
        !            43:                fptr->c_dirp->extno= fptr->c_extno;
        !            44:        }
        !            45:        fptr->c_buf = fptr->c_base;
        !            46:        fptr->c_cnt = blksiz;
        !            47:        if ((fptr->c_dirp->pointers[fptr->c_blk] = alloc()) == '\0') {
        !            48:                fprintf(stderr, "disk full\n");
        !            49:                return (EOF);
        !            50:        }
        !            51:        return (0);
        !            52: }
        !            53: 
        !            54: c_flsbuf(c, fptr)
        !            55:        register C_FILE *fptr;
        !            56: {
        !            57:        if (c_flush(fptr) == EOF)
        !            58:                return (EOF);
        !            59:        *(fptr->c_buf++) = c;
        !            60:        fptr->c_cnt--;
        !            61:        return (c);
        !            62: }
        !            63: 
        !            64: /*
        !            65:  * move the contents of 'buf' into the cpm block buffer,
        !            66:  * flush the buffer if full (for binary file transfers)
        !            67:  */
        !            68: 
        !            69: c_write(fptr, buf, cnt)
        !            70:        register C_FILE *fptr;
        !            71:        char *buf;
        !            72: {
        !            73:        int i = cnt;
        !            74: 
        !            75:        while (i-- > 0) {
        !            76:                *(fptr->c_buf++) = *(buf++);
        !            77:                if (--fptr->c_cnt == 0)
        !            78:                        if (c_flush(fptr) == EOF)
        !            79:                                return (EOF);
        !            80:        }
        !            81:        return (cnt);
        !            82: }

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