![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitio.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / bcp|
Return to bitio.h CVS log | Up to [Research Unix] / researchv10no / cmd / bcp |
1.1 ! root 1: /* Copyright (c) 1989, 1990 AT&T --- All Rights Reserved. */ ! 2: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T. */ ! 3: /* The copyright notice does not imply actual or intended publication. */ ! 4: /* AUTHORS: */ ! 5: /* H. S. Baird - ATT-BL MH - first versions */ ! 6: ! 7: /* bitio.h - view a stream file as a sequence of binary values, hiding the ! 8: bit- and byte-packing format of the file. The format of input and output ! 9: files may differ. Reading and writing are performed by macroes for speed; ! 10: the price for this is that the file formats must be fixed at compile time. ! 11: ! 12: SYNOPSIS ! 13: #include <stdio.h> ! 14: #include "bitio.h" ! 15: ! 16: BITFILE *bopen(stream,type); ! 17: FILE *stream; ! 18: char *type; ! 19: ! 20: int getb(bitfile); ! 21: BITFILE *bitfile; ! 22: ! 23: putb(bit,bitfile); ! 24: int bit; ! 25: ! 26: padb(bitfile,bit,bdy,len); ! 27: int bit,bdy,len; ! 28: ! 29: char *bbuffer(bitfile); ! 30: ! 31: unsigned long bsize(bitfile); ! 32: ! 33: unsigned long bflush(bitfile); ! 34: ! 35: unsigned long bclose(bitfile); ! 36: ! 37: COMPILER DEPENDENCIES ! 38: The compiler's data types must include: ! 39: unsigned char: 8 bits each ! 40: unsigned short: 2 unsigned chars each ! 41: unsigned int: 2 unsigned shorts each ! 42: DESCRIPTION ! 43: Bopen views the named stream file as a bit file to be read (if type is "r") ! 44: or written (if type is "w" or "wb"). The stream file must already have been ! 45: fopen(3)ed, and the first bit to be read/written will be the first bit in its ! 46: next byte in getc(3)/putc(3) order. Bopen returns a pointer which identifies ! 47: the bitfile to the other functions. System or stream I/O to/from the ! 48: associated stream should not be used until after bclose is called. ! 49: If bopen's type is "wb", then the entire output stream will be buffered ! 50: in main memory until bflush or bclose are called. At any time, bbuffer ! 51: returns this buffer's address and bsize its length in bytes. ! 52: Getb returns the next bit from the named bitfile. It returns EOF on ! 53: end of file or read error. EOF may occur on a byte, short, or int boundary, ! 54: depending on file format. ! 55: Putb appends the given bit to the named bitfile. ! 56: Padb writes 'bit' enough times (possibly 0) so that if a bitstring ! 57: of length 'len' were written next it would end on a 'bdy'-bit boundary ! 58: (may do the wrong thing if 'bdy' doesn't divide UINT_MAX). ! 59: Bflush ensures that all written bits have been written to the stream ! 60: via putc(3). The output is padded with 0 bits to a byte, short, or int ! 61: boundary, depending on file format. It returns the number of bytes (not bits) ! 62: written since bopen or the last bflush. The bitfile remains open. It does not ! 63: fflush(3) the associated stream. ! 64: Bclose causes a bflush and frees all buffers. It returns the total ! 65: number of bytes (not bits) read/written since bopen. It fflush(3)'es, ! 66: but does not fclose(3) the associated stream. ! 67: ! 68: Bitfile formats are selected at compile time: see `FORMAT:' at the ! 69: end of this file. The formats for input and output may differ. Formats ! 70: include: ! 71: a each bit is an ASCII character: '0' or '1', in putc(3) order; not padded. ! 72: 0 the low-order (0001) bit in each byte is first ("little-endian"), and ! 73: bytes are in putc(3) order; EOF and padding at a byte boundary. ! 74: 1 the high-order (0200) bit in each byte is first ("big-endian"), and ! 75: bytes are in putc(3) order; EOF and padding at a byte boundary. ! 76: 10 the low-order (0001) bit in each byte is first ("little-endian"), but ! 77: bytes are reversed (in each pair) from putc(3) order; EOF and padding ! 78: at a short boundary. ! 79: 11 the high-order (0200) bit in each byte is first ("big-endian"), but ! 80: bytes are reversed (in each pair) from putc(3) order; EOF and padding ! 81: at a short boundary. ! 82: Planned (data structures are in place; code will be implemented if needed): ! 83: 100 the low-order (0001) bit in each byte is first ("little-endian"), and ! 84: bytes (in each pair) are in putc(3) order; but shorts (in each pair) ! 85: are reversed from putc(3) order; EOF and padding at an int boundary. ! 86: 101, 110, 111 - by obvious analogy ! 87: BUGS ! 88: Putting to an input bitfile or getting from an output bitfile is ! 89: erroneous, but is not checked for. ! 90: */ ! 91: ! 92: #define BUFFERED (T) /* enable buffering of output */ ! 93: ! 94: typedef struct BITFILE { ! 95: FILE *fp; /* associated stream */ ! 96: char type; /* one of 'r','w' */ ! 97: int ic; /* byte just read */ ! 98: unsigned long nb; /* no. bytes read/written since bopen */ ! 99: unsigned long alloc; /* no. bytes allocated in buffer */ ! 100: char *buf; /* buffer (in malloc space) */ ! 101: char *cp; /* next char in buffer */ ! 102: unsigned int n; /* no. bits written so far (mod UINT_MAX) */ ! 103: unsigned char cm; /* single-bit mask */ ! 104: unsigned short sm; /* single-bit mask */ ! 105: unsigned int im; /* single-bit mask */ ! 106: union { struct { /* used to reorder char & short order */ ! 107: union { struct { ! 108: unsigned char c0; ! 109: unsigned char c1; ! 110: } cc; ! 111: unsigned short s; ! 112: } s0; ! 113: union { struct { ! 114: unsigned char c0; ! 115: unsigned char c1; ! 116: } cc; ! 117: unsigned short s; ! 118: } s1; ! 119: } ss; ! 120: unsigned int i; ! 121: } i; ! 122: } BITFILE; ! 123: #define Init_BITFILE {NULL,'\0',0,0L,0L,NULL,NULL,0,0,0} ! 124: #if MAIN ! 125: BITFILE empty_BITFILE = Init_BITFILE; ! 126: #else ! 127: extern BITFILE empty_BITFILE; ! 128: #endif ! 129: ! 130: /* Code common to all formats: */ ! 131: #if MAIN ! 132: BITFILE *bopen_rw(s,t) ! 133: FILE *s; ! 134: char *t; ! 135: { BITFILE *f; ! 136: if((f=(BITFILE *)malloc(sizeof(BITFILE)))==NULL) { ! 137: err("bopen: can't alloc"); ! 138: return(NULL); ! 139: }; ! 140: *f = empty_BITFILE; ! 141: f->fp = s; ! 142: f->type = *t; ! 143: return(f); ! 144: } ! 145: #else ! 146: BITFILE *bopen_rw(); ! 147: #endif ! 148: ! 149: #define bbuffer(f) ((f)->buf) ! 150: #define bsize(f) ((bbuffer(f)!=NULL)? ((f)->cp - (f)->buf): 0L) ! 151: ! 152: #if !BUFFERED ! 153: #define bputc(c,f) putc((c),(f)->fp) ! 154: #define bbflush(f) (0L) ! 155: #else ! 156: #define BITFILE_incr (512) /* buffer allocations are in these increments */ ! 157: ! 158: #if MAIN ! 159: brealloc(f) ! 160: BITFILE *f; ! 161: { int nbuf; /* no. bytes in buffer */ ! 162: nbuf = bsize(f); ! 163: f->alloc += BITFILE_incr; ! 164: if((f->buf=(char *)realloc(f->buf,f->alloc))==NULL) ! 165: abort(""); ! 166: f->cp = f->buf + nbuf; ! 167: } ! 168: #endif ! 169: ! 170: #define bputc(c,f) { \ ! 171: if((f)->buf==NULL) putc((c),(f)->fp); \ ! 172: else { if(bsize(f)==(f)->alloc) brealloc(f); \ ! 173: *(++((f)->cp))=(c); \ ! 174: } \ ! 175: } ! 176: ! 177: #if MAIN ! 178: unsigned long bbflush(f) ! 179: BITFILE *f; /* f->buf!=NULL && bsize(f)>0 */ ! 180: { register char *cp,*cq; ! 181: unsigned long nbuf; ! 182: nbuf = bsize(f); ! 183: for(cq=(cp=f->buf)+nbuf; cp<cq; cp++) putc(*cp,f->fp); ! 184: f->cp=f->buf; ! 185: return(nbuf); ! 186: } ! 187: #else ! 188: unsigned long bbflush(); ! 189: #endif ! 190: #endif ! 191: ! 192: /* Code particular to each format: */ ! 193: ! 194: /* Format a: ASCII file, one printable char ('0' or '1') per bit: */ ! 195: #define bopen_r_a(s) bopen_rw((s),"r") ! 196: #define bopen_w_a(s) bopen_rw((s),"w") ! 197: #define getb_a(f) ( (((f)->ic=getc((f)->fp))!=EOF)? \ ! 198: ((f)->nb++, \ ! 199: ((f)->ic=='0')? \ ! 200: 0: \ ! 201: (((f)->ic=='1')? 1: EOF)): \ ! 202: EOF ) ! 203: #define putb_a(b,f) { if((b)) bputc('1',f); else bputc('0',f); (f)->nb++; } ! 204: #define bflush_a(f) ( (bsize(f)>0)? bbflush(f): (0L) ) ! 205: ! 206: /* Format 0: the low-order bit (0001) in each byte is first ("little-endian"), ! 207: and bytes are in putc(3) order; */ ! 208: #if MAIN ! 209: BITFILE *bopen_r_0(s) ! 210: FILE *s; ! 211: { BITFILE *f; ! 212: if((f=bopen_rw(s,"r"))!=NULL) { ! 213: f->cm=0000; ! 214: }; ! 215: return(f); ! 216: } ! 217: #else ! 218: BITFILE *bopen_r_0(); ! 219: #endif ! 220: #if MAIN ! 221: BITFILE *bopen_w_0(s) ! 222: FILE *s; ! 223: { BITFILE *f; ! 224: if((f=bopen_rw(s,"w"))!=NULL) { ! 225: f->i.ss.s0.cc.c0=0000; ! 226: f->cm=0001; ! 227: }; ! 228: return(f); ! 229: } ! 230: #else ! 231: BITFILE *bopen_w_0(); ! 232: #endif ! 233: #define getb_0(f) ( ((f)->cm)? \ ! 234: ( ((f)->cm&(f)->ic)? \ ! 235: ((f)->cm<<=1,1): \ ! 236: ((f)->cm<<=1,0) ): \ ! 237: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 238: EOF: \ ! 239: ( (f)->nb++, \ ! 240: (f)->cm=0001, \ ! 241: ((f)->cm&(f)->ic)? \ ! 242: ((f)->cm<<=1,1): \ ! 243: ((f)->cm<<=1,0) ) ) ) ! 244: #define putb_0(b,f) { \ ! 245: if((b)) (f)->i.ss.s0.cc.c0 |= (f)->cm; \ ! 246: if( !((f)->cm<<=1) ) { \ ! 247: bputc((f)->i.ss.s0.cc.c0,f); \ ! 248: (f)->nb++; \ ! 249: (f)->i.ss.s0.cc.c0=0000; (f)->cm=0001; \ ! 250: }; \ ! 251: (f)->n++; \ ! 252: } ! 253: #define bflush_0(f) (padb((f),0,8,0), (bsize(f)>0)? bbflush(f): 0L) ! 254: ! 255: /* Format 1: the high-order bit (0200) in each byte is first ("big-endian"), and ! 256: bytes are in putc(3) order; */ ! 257: #if MAIN ! 258: BITFILE *bopen_r_1(s) ! 259: FILE *s; ! 260: { BITFILE *f; ! 261: if((f=bopen_rw(s,"r"))!=NULL) { ! 262: f->cm=0000; ! 263: }; ! 264: return(f); ! 265: } ! 266: #else ! 267: BITFILE *bopen_r_1(); ! 268: #endif ! 269: #if MAIN ! 270: BITFILE *bopen_w_1(s) ! 271: FILE *s; ! 272: { BITFILE *f; ! 273: if((f=bopen_rw(s,"w"))!=NULL) { ! 274: f->i.ss.s0.cc.c0=0000; ! 275: f->cm=0200; ! 276: }; ! 277: return(f); ! 278: } ! 279: #else ! 280: BITFILE *bopen_w_1(); ! 281: #endif ! 282: #define getb_1(f) ( ((f)->cm)? \ ! 283: ( ((f)->cm&(f)->ic)? \ ! 284: ((f)->cm>>=1,1): \ ! 285: ((f)->cm>>=1,0) ): \ ! 286: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 287: EOF: \ ! 288: ( (f)->nb++, \ ! 289: (f)->cm=0200, \ ! 290: ((f)->cm&(f)->ic)? \ ! 291: ((f)->cm>>=1,1): \ ! 292: ((f)->cm>>=1,0) ) ) ) ! 293: #define putb_1(b,f) { \ ! 294: if((b)) (f)->i.ss.s0.cc.c0 |= (f)->cm; \ ! 295: if( !((f)->cm>>=1) ) { \ ! 296: bputc((f)->i.ss.s0.cc.c0,f); \ ! 297: (f)->nb++; \ ! 298: (f)->i.ss.s0.cc.c0=0000; (f)->cm=0200; \ ! 299: }; \ ! 300: (f)->n++; \ ! 301: } ! 302: #define bflush_1(f) (padb((f),0,8,0), (bsize(f)>0)? bbflush(f): 0L) ! 303: ! 304: /* Format 10: the low-order (0001) bit in each byte is first ("little-endian"), and ! 305: bytes are reversed (in each pair) from putc(3) order; ! 306: */ ! 307: #if MAIN ! 308: BITFILE *bopen_r_10(s) ! 309: FILE *s; ! 310: { BITFILE *f; ! 311: if((f=bopen_rw(s,"r"))!=NULL) { ! 312: f->sm=0000000; ! 313: }; ! 314: return(f); ! 315: } ! 316: #else ! 317: BITFILE *bopen_r_10(); ! 318: #endif ! 319: #if MAIN ! 320: BITFILE *bopen_w_10(s) ! 321: FILE *s; ! 322: { BITFILE *f; ! 323: if((f=bopen_rw(s,"w"))!=NULL) { ! 324: f->i.ss.s0.s=0000000; ! 325: f->sm=0000001; ! 326: }; ! 327: return(f); ! 328: } ! 329: #else ! 330: BITFILE *bopen_w_10(); ! 331: #endif ! 332: #define getb_10(f) ( ((f)->sm)? \ ! 333: ( ((f)->sm&(f)->i.ss.s0.s)? \ ! 334: ((f)->sm<<=1,1): \ ! 335: ((f)->sm<<=1,0) ): \ ! 336: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 337: EOF: \ ! 338: ( (f)->nb++, \ ! 339: (f)->i.ss.s0.cc.c1=(f)->ic&0377, \ ! 340: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 341: EOF: \ ! 342: ( (f)->nb++, \ ! 343: (f)->i.ss.s0.cc.c0=(f)->ic&0377, \ ! 344: (f)->sm=0000001, \ ! 345: ((f)->sm&(f)->i.ss.s0.s)? \ ! 346: ((f)->sm<<=1,1): \ ! 347: ((f)->sm<<=1,0) ) ) ) ) ) ! 348: #define putb_10(b,f) { \ ! 349: if((b)) (f)->i.ss.s0.s |= (f)->sm; \ ! 350: if( !((f)->sm<<=1) ) { \ ! 351: bputc((f)->i.ss.s0.cc.c1,f); \ ! 352: (f)->nb++; \ ! 353: bputc((f)->i.ss.s0.cc.c0,f); \ ! 354: (f)->nb++; \ ! 355: (f)->i.ss.s0.s=0000000; (f)->sm=0000001; \ ! 356: }; \ ! 357: (f)->n++; \ ! 358: } ! 359: #define bflush_10(f) (padb((f),0,16,0), (bsize(f)>0)? bbflush(f): 0L) ! 360: ! 361: /* Format 11: the high-order (0200) bit in each byte is first ("little-endian"), ! 362: and bytes are reversed (in each pair) from putc(3) order. ! 363: */ ! 364: #if MAIN ! 365: BITFILE *bopen_r_11(s) ! 366: FILE *s; ! 367: { BITFILE *f; ! 368: if((f=bopen_rw(s,"r"))!=NULL) { ! 369: f->sm=0000000; ! 370: }; ! 371: return(f); ! 372: } ! 373: #else ! 374: BITFILE *bopen_r_11(); ! 375: #endif ! 376: #if MAIN ! 377: BITFILE *bopen_w_11(s) ! 378: FILE *s; ! 379: { BITFILE *f; ! 380: if((f=bopen_rw(s,"w"))!=NULL) { ! 381: f->i.ss.s0.s=0000000; ! 382: f->sm=0100000; ! 383: }; ! 384: return(f); ! 385: } ! 386: #else ! 387: BITFILE *bopen_w_11(); ! 388: #endif ! 389: #define getb_11(f) ( ((f)->sm)? \ ! 390: ( ((f)->sm&(f)->i.ss.s0.s)? \ ! 391: ((f)->sm>>=1,1): \ ! 392: ((f)->sm>>=1,0) ): \ ! 393: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 394: EOF: \ ! 395: ( (f)->nb++, \ ! 396: (f)->i.ss.s0.cc.c0=(f)->ic&0377, \ ! 397: ( (((f)->ic=getc((f)->fp))==EOF)? \ ! 398: EOF: \ ! 399: ( (f)->nb++, \ ! 400: (f)->i.ss.s0.cc.c1=(f)->ic&0377, \ ! 401: (f)->sm=0100000, \ ! 402: ((f)->sm&(f)->i.ss.s0.s)? \ ! 403: ((f)->sm>>=1,1): \ ! 404: ((f)->sm>>=1,0) ) ) ) ) ) ! 405: #define putb_11(b,f) { \ ! 406: if((b)) (f)->i.ss.s0.s |= (f)->sm; \ ! 407: if( !((f)->sm>>=1) ) { \ ! 408: bputc((f)->i.ss.s0.cc.c0,f); \ ! 409: (f)->nb++; \ ! 410: bputc((f)->i.ss.s0.cc.c1,f); \ ! 411: (f)->nb++; \ ! 412: (f)->i.ss.s0.s=0000000; (f)->sm=0100000; \ ! 413: }; \ ! 414: (f)->n++; \ ! 415: } ! 416: #define bflush_11(f) (padb((f),0,16,0), (bsize(f)>0)? bbflush(f): 0L) ! 417: ! 418: /**************************************************************/ ! 419: /* FORMAT: may be selected here (input and output may differ) */ ! 420: ! 421: /* Input: */ ! 422: #define bopen_r(s) bopen_r_0((s)) ! 423: #define getb(f) getb_0(f) ! 424: /* Output: */ ! 425: #define bopen_w(s) bopen_w_0((s)) ! 426: #define putb(b,f) putb_0((b),(f)) ! 427: #define bflush(f) bflush_0(f) ! 428: ! 429: /**************************************************************/ ! 430: ! 431: /* Code common to all formats: */ ! 432: #if MAIN ! 433: BITFILE *bopen(s,t) ! 434: FILE *s; ! 435: char *t; ! 436: { BITFILE *res; ! 437: if(*(t)=='r') res=bopen_r(s); ! 438: else if(*(t)=='w') { ! 439: res=bopen_w(s); ! 440: #if BUFFERED ! 441: if(*(t+1)=='b') { ! 442: res->alloc = BITFILE_incr; ! 443: if((res->buf=(char *)malloc(res->alloc))==NULL) ! 444: abort("bopen: can't alloc buffer"); ! 445: res->cp = res->buf; ! 446: }; ! 447: #endif ! 448: } ! 449: else abort("bopen: bad type: \"%s\"",t); ! 450: return(res); ! 451: } ! 452: #else ! 453: BITFILE *bopen(); ! 454: #endif ! 455: ! 456: #if MAIN ! 457: padb(f,b,B,l) ! 458: BITFILE *f; ! 459: char b; ! 460: int l,B; ! 461: { while(((f)->n+(l))%(B)) putb((b),(f)); ! 462: } ! 463: #endif ! 464: ! 465: #if MAIN ! 466: unsigned long bclose(f) ! 467: BITFILE *f; ! 468: { unsigned long nb,nbuf; ! 469: if(f->type=='w') { ! 470: nbuf=bflush(f); ! 471: fflush(f->fp); ! 472: #if BUFFERED ! 473: if(f->buf!=NULL) { free(f->buf); f->buf=NULL; } ! 474: #endif ! 475: }; ! 476: nb=f->nb; ! 477: free(f); ! 478: return(nb); ! 479: } ! 480: #else ! 481: unsigned long bclose(); ! 482: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.