![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to buf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make|
Return to buf.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. ! 3: * Copyright (c) 1988, 1989 by Adam de Boor ! 4: * Copyright (c) 1989 by Berkeley Softworks ! 5: * All rights reserved. ! 6: * ! 7: * This code is derived from software contributed to Berkeley by ! 8: * Adam de Boor. ! 9: * ! 10: * Redistribution and use in source and binary forms are permitted ! 11: * provided that: (1) source distributions retain this entire copyright ! 12: * notice and comment, and (2) distributions including binaries display ! 13: * the following acknowledgement: ``This product includes software ! 14: * developed by the University of California, Berkeley and its contributors'' ! 15: * in the documentation or other materials provided with the distribution ! 16: * and in all advertising materials mentioning features or use of this ! 17: * software. Neither the name of the University nor the names of its ! 18: * contributors may be used to endorse or promote products derived ! 19: * from this software without specific prior written permission. ! 20: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 21: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 22: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 23: */ ! 24: ! 25: #ifndef lint ! 26: static char sccsid[] = "@(#)buf.c 5.4 (Berkeley) 6/1/90"; ! 27: #endif /* not lint */ ! 28: ! 29: /*- ! 30: * buf.c -- ! 31: * Functions for automatically-expanded buffers. ! 32: */ ! 33: ! 34: #include "sprite.h" ! 35: #include "buf.h" ! 36: ! 37: typedef struct { ! 38: int size; /* Current size of the buffer */ ! 39: Byte *buffer; /* The buffer itself */ ! 40: Byte *inPtr; /* Place to write to */ ! 41: Byte *outPtr; /* Place to read from */ ! 42: } Buf, *BufPtr; ! 43: ! 44: #ifndef max ! 45: #define max(a,b) ((a) > (b) ? (a) : (b)) ! 46: #endif ! 47: ! 48: /* ! 49: * BufExpand -- ! 50: * Expand the given buffer to hold the given number of additional ! 51: * bytes. ! 52: * Makes sure there's room for an extra NULL byte at the end of the ! 53: * buffer in case it holds a string. ! 54: */ ! 55: #define BufExpand(bp,nb) \ ! 56: if (((bp)->size - ((bp)->inPtr - (bp)->buffer)) < (nb)+1) {\ ! 57: int newSize = (bp)->size + max((nb)+1,BUF_ADD_INC); \ ! 58: Byte *newBuf = (Byte *) realloc((bp)->buffer, newSize); \ ! 59: \ ! 60: (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer); \ ! 61: (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer);\ ! 62: (bp)->buffer = newBuf;\ ! 63: (bp)->size = newSize;\ ! 64: } ! 65: ! 66: #define BUF_DEF_SIZE 256 /* Default buffer size */ ! 67: #define BUF_ADD_INC 256 /* Expansion increment when Adding */ ! 68: #define BUF_UNGET_INC 16 /* Expansion increment when Ungetting */ ! 69: ! 70: /*- ! 71: *----------------------------------------------------------------------- ! 72: * Buf_AddByte -- ! 73: * Add a single byte to the buffer. ! 74: * ! 75: * Results: ! 76: * None. ! 77: * ! 78: * Side Effects: ! 79: * The buffer may be expanded. ! 80: * ! 81: *----------------------------------------------------------------------- ! 82: */ ! 83: void ! 84: Buf_AddByte (buf, byte) ! 85: Buffer buf; ! 86: Byte byte; ! 87: { ! 88: register BufPtr bp = (BufPtr) buf; ! 89: ! 90: BufExpand (bp, 1); ! 91: ! 92: *bp->inPtr = byte; ! 93: bp->inPtr += 1; ! 94: ! 95: /* ! 96: * Null-terminate ! 97: */ ! 98: *bp->inPtr = 0; ! 99: } ! 100: ! 101: /*- ! 102: *----------------------------------------------------------------------- ! 103: * Buf_AddBytes -- ! 104: * Add a number of bytes to the buffer. ! 105: * ! 106: * Results: ! 107: * None. ! 108: * ! 109: * Side Effects: ! 110: * Guess what? ! 111: * ! 112: *----------------------------------------------------------------------- ! 113: */ ! 114: void ! 115: Buf_AddBytes (buf, numBytes, bytesPtr) ! 116: Buffer buf; ! 117: int numBytes; ! 118: Byte *bytesPtr; ! 119: { ! 120: register BufPtr bp = (BufPtr) buf; ! 121: ! 122: BufExpand (bp, numBytes); ! 123: ! 124: bcopy (bytesPtr, bp->inPtr, numBytes); ! 125: bp->inPtr += numBytes; ! 126: ! 127: /* ! 128: * Null-terminate ! 129: */ ! 130: *bp->inPtr = 0; ! 131: } ! 132: ! 133: /*- ! 134: *----------------------------------------------------------------------- ! 135: * Buf_UngetByte -- ! 136: * Place the byte back at the beginning of the buffer. ! 137: * ! 138: * Results: ! 139: * SUCCESS if the byte was added ok. FAILURE if not. ! 140: * ! 141: * Side Effects: ! 142: * The byte is stuffed in the buffer and outPtr is decremented. ! 143: * ! 144: *----------------------------------------------------------------------- ! 145: */ ! 146: void ! 147: Buf_UngetByte (buf, byte) ! 148: Buffer buf; ! 149: Byte byte; ! 150: { ! 151: register BufPtr bp = (BufPtr) buf; ! 152: ! 153: if (bp->outPtr != bp->buffer) { ! 154: bp->outPtr -= 1; ! 155: *bp->outPtr = byte; ! 156: } else if (bp->outPtr == bp->inPtr) { ! 157: *bp->inPtr = byte; ! 158: bp->inPtr += 1; ! 159: *bp->inPtr = 0; ! 160: } else { ! 161: /* ! 162: * Yech. have to expand the buffer to stuff this thing in. ! 163: * We use a different expansion constant because people don't ! 164: * usually push back many bytes when they're doing it a byte at ! 165: * a time... ! 166: */ ! 167: int numBytes = bp->inPtr - bp->outPtr; ! 168: Byte *newBuf; ! 169: ! 170: newBuf = (Byte *)emalloc(bp->size + BUF_UNGET_INC); ! 171: bcopy ((Address)bp->outPtr, ! 172: (Address)(newBuf+BUF_UNGET_INC), numBytes+1); ! 173: bp->outPtr = newBuf + BUF_UNGET_INC; ! 174: bp->inPtr = bp->outPtr + numBytes; ! 175: free ((Address)bp->buffer); ! 176: bp->buffer = newBuf; ! 177: bp->size += BUF_UNGET_INC; ! 178: bp->outPtr -= 1; ! 179: *bp->outPtr = byte; ! 180: } ! 181: } ! 182: ! 183: /*- ! 184: *----------------------------------------------------------------------- ! 185: * Buf_UngetBytes -- ! 186: * Push back a series of bytes at the beginning of the buffer. ! 187: * ! 188: * Results: ! 189: * None. ! 190: * ! 191: * Side Effects: ! 192: * outPtr is decremented and the bytes copied into the buffer. ! 193: * ! 194: *----------------------------------------------------------------------- ! 195: */ ! 196: void ! 197: Buf_UngetBytes (buf, numBytes, bytesPtr) ! 198: Buffer buf; ! 199: int numBytes; ! 200: Byte *bytesPtr; ! 201: { ! 202: register BufPtr bp = (BufPtr) buf; ! 203: ! 204: if (bp->outPtr - bp->buffer >= numBytes) { ! 205: bp->outPtr -= numBytes; ! 206: bcopy (bytesPtr, bp->outPtr, numBytes); ! 207: } else if (bp->outPtr == bp->inPtr) { ! 208: Buf_AddBytes (buf, numBytes, bytesPtr); ! 209: } else { ! 210: int curNumBytes = bp->inPtr - bp->outPtr; ! 211: Byte *newBuf; ! 212: int newBytes = max(numBytes,BUF_UNGET_INC); ! 213: ! 214: newBuf = (Byte *)emalloc (bp->size + newBytes); ! 215: bcopy((Address)bp->outPtr, (Address)(newBuf+newBytes), curNumBytes+1); ! 216: bp->outPtr = newBuf + newBytes; ! 217: bp->inPtr = bp->outPtr + curNumBytes; ! 218: free ((Address)bp->buffer); ! 219: bp->buffer = newBuf; ! 220: bp->size += newBytes; ! 221: bp->outPtr -= numBytes; ! 222: bcopy ((Address)bytesPtr, (Address)bp->outPtr, numBytes); ! 223: } ! 224: } ! 225: ! 226: /*- ! 227: *----------------------------------------------------------------------- ! 228: * Buf_GetByte -- ! 229: * Return the next byte from the buffer. Actually returns an integer. ! 230: * ! 231: * Results: ! 232: * Returns BUF_ERROR if there's no byte in the buffer, or the byte ! 233: * itself if there is one. ! 234: * ! 235: * Side Effects: ! 236: * outPtr is incremented and both outPtr and inPtr will be reset if ! 237: * the buffer is emptied. ! 238: * ! 239: *----------------------------------------------------------------------- ! 240: */ ! 241: int ! 242: Buf_GetByte (buf) ! 243: Buffer buf; ! 244: { ! 245: BufPtr bp = (BufPtr) buf; ! 246: int res; ! 247: ! 248: if (bp->inPtr == bp->outPtr) { ! 249: return (BUF_ERROR); ! 250: } else { ! 251: res = (int) *bp->outPtr; ! 252: bp->outPtr += 1; ! 253: if (bp->outPtr == bp->inPtr) { ! 254: bp->outPtr = bp->inPtr = bp->buffer; ! 255: bp->inPtr = 0; ! 256: } ! 257: return (res); ! 258: } ! 259: } ! 260: ! 261: /*- ! 262: *----------------------------------------------------------------------- ! 263: * Buf_GetBytes -- ! 264: * Extract a number of bytes from the buffer. ! 265: * ! 266: * Results: ! 267: * The number of bytes gotten. ! 268: * ! 269: * Side Effects: ! 270: * The passed array is overwritten. ! 271: * ! 272: *----------------------------------------------------------------------- ! 273: */ ! 274: int ! 275: Buf_GetBytes (buf, numBytes, bytesPtr) ! 276: Buffer buf; ! 277: int numBytes; ! 278: Byte *bytesPtr; ! 279: { ! 280: BufPtr bp = (BufPtr) buf; ! 281: ! 282: if (bp->inPtr - bp->outPtr < numBytes) { ! 283: numBytes = bp->inPtr - bp->outPtr; ! 284: } ! 285: bcopy (bp->outPtr, bytesPtr, numBytes); ! 286: bp->outPtr += numBytes; ! 287: ! 288: if (bp->outPtr == bp->inPtr) { ! 289: bp->outPtr = bp->inPtr = bp->buffer; ! 290: *bp->inPtr = 0; ! 291: } ! 292: return (numBytes); ! 293: } ! 294: ! 295: /*- ! 296: *----------------------------------------------------------------------- ! 297: * Buf_GetAll -- ! 298: * Get all the available data at once. ! 299: * ! 300: * Results: ! 301: * A pointer to the data and the number of bytes available. ! 302: * ! 303: * Side Effects: ! 304: * None. ! 305: * ! 306: *----------------------------------------------------------------------- ! 307: */ ! 308: Byte * ! 309: Buf_GetAll (buf, numBytesPtr) ! 310: Buffer buf; ! 311: int *numBytesPtr; ! 312: { ! 313: BufPtr bp = (BufPtr)buf; ! 314: ! 315: if (numBytesPtr != (int *)NULL) { ! 316: *numBytesPtr = bp->inPtr - bp->outPtr; ! 317: } ! 318: ! 319: return (bp->outPtr); ! 320: } ! 321: ! 322: /*- ! 323: *----------------------------------------------------------------------- ! 324: * Buf_Discard -- ! 325: * Throw away bytes in a buffer. ! 326: * ! 327: * Results: ! 328: * None. ! 329: * ! 330: * Side Effects: ! 331: * The bytes are discarded. ! 332: * ! 333: *----------------------------------------------------------------------- ! 334: */ ! 335: void ! 336: Buf_Discard (buf, numBytes) ! 337: Buffer buf; ! 338: int numBytes; ! 339: { ! 340: register BufPtr bp = (BufPtr) buf; ! 341: ! 342: if (bp->inPtr - bp->outPtr <= numBytes) { ! 343: bp->inPtr = bp->outPtr = bp->buffer; ! 344: *bp->inPtr = 0; ! 345: } else { ! 346: bp->outPtr += numBytes; ! 347: } ! 348: } ! 349: ! 350: /*- ! 351: *----------------------------------------------------------------------- ! 352: * Buf_Size -- ! 353: * Returns the number of bytes in the given buffer. Doesn't include ! 354: * the null-terminating byte. ! 355: * ! 356: * Results: ! 357: * The number of bytes. ! 358: * ! 359: * Side Effects: ! 360: * None. ! 361: * ! 362: *----------------------------------------------------------------------- ! 363: */ ! 364: int ! 365: Buf_Size (buf) ! 366: Buffer buf; ! 367: { ! 368: return (((BufPtr)buf)->inPtr - ((BufPtr)buf)->outPtr); ! 369: } ! 370: ! 371: /*- ! 372: *----------------------------------------------------------------------- ! 373: * Buf_Init -- ! 374: * Initialize a buffer. If no initial size is given, a reasonable ! 375: * default is used. ! 376: * ! 377: * Results: ! 378: * A buffer to be given to other functions in this library. ! 379: * ! 380: * Side Effects: ! 381: * The buffer is created, the space allocated and pointers ! 382: * initialized. ! 383: * ! 384: *----------------------------------------------------------------------- ! 385: */ ! 386: Buffer ! 387: Buf_Init (size) ! 388: int size; /* Initial size for the buffer */ ! 389: { ! 390: BufPtr bp; /* New Buffer */ ! 391: ! 392: bp = (Buf *)emalloc(sizeof(Buf)); ! 393: ! 394: if (size <= 0) { ! 395: size = BUF_DEF_SIZE; ! 396: } ! 397: bp->size = size; ! 398: bp->buffer = (Byte *)emalloc (size); ! 399: bp->inPtr = bp->outPtr = bp->buffer; ! 400: *bp->inPtr = 0; ! 401: ! 402: return ((Buffer) bp); ! 403: } ! 404: ! 405: /*- ! 406: *----------------------------------------------------------------------- ! 407: * Buf_Destroy -- ! 408: * Nuke a buffer and all its resources. ! 409: * ! 410: * Results: ! 411: * None. ! 412: * ! 413: * Side Effects: ! 414: * The buffer is freed. ! 415: * ! 416: *----------------------------------------------------------------------- ! 417: */ ! 418: void ! 419: Buf_Destroy (buf, freeData) ! 420: Buffer buf; /* Buffer to destroy */ ! 421: Boolean freeData; /* TRUE if the data should be destroyed as well */ ! 422: { ! 423: BufPtr bp = (BufPtr) buf; ! 424: ! 425: if (freeData) { ! 426: free ((Address)bp->buffer); ! 427: } ! 428: free ((Address)bp); ! 429: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.