/*- * Copyright (c) 1988, 1989, 1990, 1993 * The Regents of the University of California. All rights reserved. * Copyright (c) 1988, 1989 by Adam de Boor * Copyright (c) 1989 by Berkeley Softworks * All rights reserved. * * This code is derived from software contributed to Berkeley by * Adam de Boor. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)buf.c 8.1 (Berkeley) 6/6/93 */ #include __FBSDID("$FreeBSD: head/usr.bin/make/buf.c 141133 2005-02-02 07:36:18Z harti $"); /*- * buf.c -- * Functions for automatically-expanded buffers. */ #include #include #include "buf.h" #include "sprite.h" #include "util.h" #ifndef max #define max(a,b) ((a) > (b) ? (a) : (b)) #endif /* * BufExpand -- * Expand the given buffer to hold the given number of additional * bytes. * Makes sure there's room for an extra NULL byte at the end of the * buffer in case it holds a string. */ #define BufExpand(bp, nb) do { \ if ((bp)->left < (nb) + 1) { \ int newSize = (bp)->size + max((nb) + 1, BUF_ADD_INC); \ Byte *newBuf = erealloc((bp)->buffer, newSize); \ \ (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer); \ (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer); \ (bp)->buffer = newBuf; \ (bp)->size = newSize; \ (bp)->left = newSize - ((bp)->inPtr - (bp)->buffer); \ } \ } while (0) #define BUF_DEF_SIZE 256 /* Default buffer size */ #define BUF_ADD_INC 256 /* Expansion increment when Adding */ #define BUF_UNGET_INC 16 /* Expansion increment when Ungetting */ /*- *----------------------------------------------------------------------- * Buf_OvAddByte -- * Add a single byte to the buffer. left is zero or negative. * * Results: * None. * * Side Effects: * The buffer may be expanded. * *----------------------------------------------------------------------- */ void Buf_OvAddByte(Buffer *bp, Byte byte) { bp->left = 0; BufExpand(bp, 1); *bp->inPtr++ = byte; bp->left--; /* * Null-terminate */ *bp->inPtr = 0; } /*- *----------------------------------------------------------------------- * Buf_AddBytes -- * Add a number of bytes to the buffer. * * Results: * None. * * Side Effects: * Guess what? * *----------------------------------------------------------------------- */ void Buf_AddBytes(Buffer *bp, size_t numBytes, const Byte *bytesPtr) { BufExpand(bp, numBytes); memcpy(bp->inPtr, bytesPtr, numBytes); bp->inPtr += numBytes; bp->left -= numBytes; /* * Null-terminate */ *bp->inPtr = 0; } /*- *----------------------------------------------------------------------- * Buf_UngetByte -- * Place the byte back at the beginning of the buffer. * * Results: * SUCCESS if the byte was added ok. FAILURE if not. * * Side Effects: * The byte is stuffed in the buffer and outPtr is decremented. * *----------------------------------------------------------------------- */ void Buf_UngetByte(Buffer *bp, Byte byte) { if (bp->outPtr != bp->buffer) { bp->outPtr--; *bp->outPtr = byte; } else if (bp->outPtr == bp->inPtr) { *bp->inPtr = byte; bp->inPtr++; bp->left--; *bp->inPtr = 0; } else { /* * Yech. have to expand the buffer to stuff this thing in. * We use a different expansion constant because people don't * usually push back many bytes when they're doing it a byte at * a time... */ size_t numBytes = bp->inPtr - bp->outPtr; Byte *newBuf; newBuf = emalloc(bp->size + BUF_UNGET_INC); memcpy(newBuf + BUF_UNGET_INC, bp->outPtr, numBytes + 1); bp->outPtr = newBuf + BUF_UNGET_INC; bp->inPtr = bp->outPtr + numBytes; free(bp->buffer); bp->buffer = newBuf; bp->size += BUF_UNGET_INC; bp->left = bp->size - (bp->inPtr - bp->buffer); bp->outPtr -= 1; *bp->outPtr = byte; } } /*- *----------------------------------------------------------------------- * Buf_UngetBytes -- * Push back a series of bytes at the beginning of the buffer. * * Results: * None. * * Side Effects: * outPtr is decremented and the bytes copied into the buffer. * *----------------------------------------------------------------------- */ void Buf_UngetBytes(Buffer *bp, size_t numBytes, Byte *bytesPtr) { if ((size_t)(bp->outPtr - bp->buffer) >= numBytes) { bp->outPtr -= numBytes; memcpy(bp->outPtr, bytesPtr, numBytes); } else if (bp->outPtr == bp->inPtr) { Buf_AddBytes(bp, numBytes, bytesPtr); } else { size_t curNumBytes = bp->inPtr - bp->outPtr; Byte *newBuf; size_t newBytes = max(numBytes, BUF_UNGET_INC); newBuf = emalloc(bp->size + newBytes); memcpy(newBuf + newBytes, bp->outPtr, curNumBytes + 1); bp->outPtr = newBuf + newBytes; bp->inPtr = bp->outPtr + curNumBytes; free(bp->buffer); bp->buffer = newBuf; bp->size += newBytes; bp->left = bp->size - (bp->inPtr - bp->buffer); bp->outPtr -= numBytes; memcpy(bp->outPtr, bytesPtr, numBytes); } } /*- *----------------------------------------------------------------------- * Buf_GetByte -- * Return the next byte from the buffer. Actually returns an integer. * * Results: * Returns BUF_ERROR if there's no byte in the buffer, or the byte * itself if there is one. * * Side Effects: * outPtr is incremented and both outPtr and inPtr will be reset if * the buffer is emptied. * *----------------------------------------------------------------------- */ int Buf_GetByte(Buffer *bp) { int res; if (bp->inPtr == bp->outPtr) return (BUF_ERROR); res = (int)*bp->outPtr; bp->outPtr += 1; if (bp->outPtr == bp->inPtr) { bp->outPtr = bp->inPtr = bp->buffer; bp->left = bp->size; *bp->inPtr = 0; } return (res); } /*- *----------------------------------------------------------------------- * Buf_GetBytes -- * Extract a number of bytes from the buffer. * * Results: * The number of bytes gotten. * * Side Effects: * The passed array is overwritten. * *----------------------------------------------------------------------- */ int Buf_GetBytes(Buffer *bp, size_t numBytes, Byte *bytesPtr) { if ((size_t)(bp->inPtr - bp->outPtr) < numBytes) numBytes = bp->inPtr - bp->outPtr; memcpy(bytesPtr, bp->outPtr, numBytes); bp->outPtr += numBytes; if (bp->outPtr == bp->inPtr) { bp->outPtr = bp->inPtr = bp->buffer; bp->left = bp->size; *bp->inPtr = 0; } return (numBytes); } /*- *----------------------------------------------------------------------- * Buf_GetAll -- * Get all the available data at once. * * Results: * A pointer to the data and the number of bytes available. * * Side Effects: * None. * *----------------------------------------------------------------------- */ Byte * Buf_GetAll(Buffer *bp, size_t *numBytesPtr) { if (numBytesPtr != NULL) *numBytesPtr = bp->inPtr - bp->outPtr; return (bp->outPtr); } /*- *----------------------------------------------------------------------- * Buf_Discard -- * Throw away bytes in a buffer. * * Results: * None. * * Side Effects: * The bytes are discarded. * *----------------------------------------------------------------------- */ void Buf_Discard(Buffer *bp, size_t numBytes) { if ((size_t)(bp->inPtr - bp->outPtr) <= numBytes) { bp->inPtr = bp->outPtr = bp->buffer; bp->left = bp->size; *bp->inPtr = 0; } else bp->outPtr += numBytes; } /*- *----------------------------------------------------------------------- * Buf_Size -- * Returns the number of bytes in the given buffer. Doesn't include * the null-terminating byte. * * Results: * The number of bytes. * * Side Effects: * None. * *----------------------------------------------------------------------- */ size_t Buf_Size(Buffer *buf) { return (buf->inPtr - buf->outPtr); } /*- *----------------------------------------------------------------------- * Buf_Init -- * Initialize a buffer. If no initial size is given, a reasonable * default is used. * * Results: * A buffer to be given to other functions in this library. * * Side Effects: * The buffer is created, the space allocated and pointers * initialized. * *----------------------------------------------------------------------- */ Buffer * Buf_Init(size_t size) { Buffer *bp; /* New Buffer */ bp = emalloc(sizeof(*bp)); if (size <= 0) size = BUF_DEF_SIZE; bp->left = bp->size = size; bp->buffer = emalloc(size); bp->inPtr = bp->outPtr = bp->buffer; *bp->inPtr = 0; return (bp); } /*- *----------------------------------------------------------------------- * Buf_Destroy -- * Destroy a buffer, and optionally free its data, too. * * Results: * None. * * Side Effects: * The buffer is freed. * *----------------------------------------------------------------------- */ void Buf_Destroy(Buffer *buf, Boolean freeData) { if (freeData) free(buf->buffer); free(buf); } /*- *----------------------------------------------------------------------- * Buf_ReplaceLastByte -- * Replace the last byte in a buffer. * * Results: * None. * * Side Effects: * If the buffer was empty intially, then a new byte will be added. * Otherwise, the last byte is overwritten. * *----------------------------------------------------------------------- */ void Buf_ReplaceLastByte(Buffer *buf, Byte byte) { if (buf->inPtr == buf->outPtr) Buf_AddByte(buf, byte); else *(buf->inPtr - 1) = byte; }