Return to rdwrbatch.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu

Annotation of 42BSD/ingres/source/dbu/rdwrbatch.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <symbol.h>
        !             4: # include      <access.h>
        !             5: # include      <batch.h>
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)rdwrbatch.c 7.1     2/5/81)
        !             9: 
        !            10: getbatch(loc, count)
        !            11: char   *loc;
        !            12: int    count;
        !            13: {
        !            14:        register char   *c;
        !            15:        register int    cnt, size;
        !            16:        int             i;
        !            17: 
        !            18:        cnt = count;
        !            19: #      ifdef xZTR1
        !            20:        if (tTf(42, 15))
        !            21:                printf("getbatch:%d (%d)\n", cnt, Batch_cnt);
        !            22: #      endif
        !            23:        c = loc;
        !            24: 
        !            25:        while (cnt)
        !            26:        {
        !            27:                /* see if there is anything in the buffer */
        !            28:                if (Batch_cnt == BATCHSIZE)
        !            29:                        if ((i = readbatch()) < cnt)
        !            30:                                syserr("getbatch:can't read enough %d %d", i, cnt);
        !            31:                if (cnt <= BATCHSIZE - Batch_cnt)
        !            32:                        size = cnt;
        !            33:                else
        !            34:                        size = BATCHSIZE - Batch_cnt;
        !            35:                bmove(&Batchbuf.bbuf[Batch_cnt], c, size);
        !            36:                Batch_cnt += size;
        !            37:                cnt -= size;
        !            38:                c += size;
        !            39:                /* flush the buffer if full */
        !            40:                if (Batch_cnt == BATCHSIZE)
        !            41:                        batchflush();   /* re-write buffer if necessary */
        !            42:        }
        !            43:        return (0);
        !            44: }
        !            45: /*
        !            46: **  PUTBATCH
        !            47: */
        !            48: 
        !            49: putbatch(cp, count)
        !            50: char   *cp;
        !            51: int    count;
        !            52: {
        !            53:        register char   *c;
        !            54:        register int    size, cnt;
        !            55:        int             i;
        !            56: 
        !            57:        cnt = count;
        !            58:        c = cp;
        !            59: #      ifdef xZTR1
        !            60:        if (tTf(42, 2))
        !            61:                printf("putbatch:%d\n", cnt);
        !            62: #      endif
        !            63: 
        !            64:        while (cnt)
        !            65:        {
        !            66:                Batch_dirty = TRUE;     /* mark this buffer as dirty */
        !            67:                if (cnt + Batch_cnt > BATCHSIZE)
        !            68:                        size = BATCHSIZE - Batch_cnt;
        !            69:                else
        !            70:                        size = cnt;
        !            71:                bmove(c, &Batchbuf.bbuf[Batch_cnt], size);
        !            72:                c += size;
        !            73:                Batch_cnt += size;
        !            74:                cnt -= size;
        !            75:                if (Batch_cnt == BATCHSIZE)
        !            76:                {
        !            77:                        batchflush();
        !            78:                        /* is there is more to write, must read ahead first */
        !            79:                        if (cnt)
        !            80:                                if ((i = readbatch()) < cnt)
        !            81:                                        syserr("putbatch:rd too small %d", i);
        !            82:                }
        !            83:        }
        !            84: }
        !            85: /*
        !            86: **  READBATCH
        !            87: */
        !            88: 
        !            89: readbatch()
        !            90: {
        !            91: 
        !            92:        if ((Batch_lread = read(Batch_fp, &Batchbuf, BATCHSIZE+IDSIZE)) < 0)
        !            93:                syserr("readbatch:can't read %d %d", Batch_lread, Batch_fp);
        !            94:        Batch_cnt = 0;
        !            95: #      ifdef xZTR1
        !            96:        if (tTf(42, 10))
        !            97:                printf("read %d bytes from batch\n", Batch_lread);
        !            98: #      endif
        !            99:        /* check file-id */
        !           100:        if (!sequal(Fileset, Batchbuf.file_id))
        !           101:                syserr("readbatch:bad id '%s' '%.20s' %d", Fileset, Batchbuf.file_id, Batch_lread);
        !           102:        return (Batch_lread);
        !           103: }
        !           104: /*
        !           105: **  BATCHFLUSH
        !           106: */
        !           107: 
        !           108: batchflush()
        !           109: {
        !           110:        register int    i;
        !           111:        if (Batch_cnt && Batch_dirty)
        !           112:        {
        !           113: #              ifdef xZTR1
        !           114:                if (tTf(42, 5))
        !           115:                        printf("flush:backing up %d\n", Batch_lread);
        !           116: #              endif
        !           117:                if ((i = lseek(Batch_fp, (long) -Batch_lread, 1)) < 0)
        !           118:                        syserr("batchflush:can't seek %d", Batch_lread);
        !           119: #              ifdef xZTR1
        !           120:                if (tTf(42, 4))
        !           121:                        printf("flushing %d\n", Batch_cnt + IDSIZE);
        !           122: #              endif
        !           123:                if ((i = write(Batch_fp, &Batchbuf, Batch_cnt + IDSIZE)) != Batch_cnt + IDSIZE)
        !           124:                        syserr("batchflush:can't write %d", i);
        !           125:                Batch_dirty = FALSE;
        !           126:        }
        !           127: }

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