1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-24 11:29:10 +00:00
freebsd/usr.bin/make/buf.c
Juli Mallett 4526ed6ffb Convert make(1) to use ANSI style function declarations. Variable
documentation already adequatedly existed in the description in most
cases.  Where it did not, it was added.  If no documentation existed
beforehand, then none was added.  Some unused dummies for use in the
traversal functions were marked as __unused during the conversion.
Occasionally, local style fixes were applied to lines already being
modified or influenced.

Now make(1) should always build with WARNS=3.
2002-10-09 03:42:10 +00:00

439 lines
11 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* 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 <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/*-
* buf.c --
* Functions for automatically-expanded buffers.
*/
#include "sprite.h"
#include "make.h"
#include "buf.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) \
if (bp->left < (nb)+1) {\
int newSize = (bp)->size + max((nb)+1,BUF_ADD_INC); \
Byte *newBuf = (Byte *) 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);\
}
#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, int 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, int 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, int 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...
*/
int numBytes = bp->inPtr - bp->outPtr;
Byte *newBuf;
newBuf = (Byte *)emalloc(bp->size + BUF_UNGET_INC);
memcpy ((char *)(newBuf+BUF_UNGET_INC), (char *)bp->outPtr, numBytes+1);
bp->outPtr = newBuf + BUF_UNGET_INC;
bp->inPtr = bp->outPtr + numBytes;
free ((char *)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, int numBytes, Byte *bytesPtr)
{
if (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 {
int curNumBytes = bp->inPtr - bp->outPtr;
Byte *newBuf;
int newBytes = max(numBytes,BUF_UNGET_INC);
newBuf = (Byte *)emalloc (bp->size + newBytes);
memcpy((char *)(newBuf+newBytes), (char *)bp->outPtr, curNumBytes+1);
bp->outPtr = newBuf + newBytes;
bp->inPtr = bp->outPtr + curNumBytes;
free ((char *)bp->buffer);
bp->buffer = newBuf;
bp->size += newBytes;
bp->left = bp->size - (bp->inPtr - bp->buffer);
bp->outPtr -= numBytes;
memcpy ((char *)bp->outPtr, (char *)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);
} else {
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, int numBytes, Byte *bytesPtr)
{
if (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, int *numBytesPtr)
{
if (numBytesPtr != (int *)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, int numBytes)
{
if (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.
*
*-----------------------------------------------------------------------
*/
int
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 (int size)
{
Buffer bp; /* New Buffer */
bp = (Buffer)emalloc(sizeof(*bp));
if (size <= 0) {
size = BUF_DEF_SIZE;
}
bp->left = bp->size = size;
bp->buffer = (Byte *)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 ((char *)buf->buffer);
}
free ((char *)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, int byte)
{
if (buf->inPtr == buf->outPtr)
Buf_AddByte(buf, byte);
else
*(buf->inPtr - 1) = byte;
}