usr.bin/make/buf.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1988, 1989 by Adam de Boor
   5  * Copyright (c) 1989 by Berkeley Softworks
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Adam de Boor.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by the University of
  22  *      California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  * @(#)buf.c    8.1 (Berkeley) 6/6/93
  40  * $FreeBSD: src/usr.bin/make/buf.c,v 1.11 1999/09/11 13:08:01 hoek Exp $
  41  * $DragonFly: src/usr.bin/make/buf.c,v 1.15 2005/01/09 23:03:28 okumoto Exp $
  42  */
  43
  44 /*-
  45  * buf.c --
  46  *      Functions for automatically-expanded buffers.
  47  */
  48
  49 #include <string.h>
  50 #include <stdlib.h>
  51
  52 #include "buf.h"
  53 #include "sprite.h"
  54 #include "util.h"
  55
  56 #ifndef max
  57 #define max(a,b)  ((a) > (b) ? (a) : (b))
  58 #endif
  59
  60 /*
  61  * BufExpand --
  62  *      Expand the given buffer to hold the given number of additional
  63  *      bytes.
  64  *      Makes sure there's room for an extra NULL byte at the end of the
  65  *      buffer in case it holds a string.
  66  */
  67 #define BufExpand(bp, nb) do {                                          \
  68         if ((bp)->left < (nb) + 1) {                                    \
  69                 int newSize = (bp)->size + max((nb) + 1, BUF_ADD_INC);  \
  70                 Byte *newBuf = erealloc((bp)->buffer, newSize);         \
  71                                                                         \
  72                 (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer);    \
  73                 (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer);  \
  74                 (bp)->buffer = newBuf;                                  \
  75                 (bp)->size = newSize;                                   \
  76                 (bp)->left = newSize - ((bp)->inPtr - (bp)->buffer);    \
  77         }                                                               \
  78     } while (0)
  79
  80 #define BUF_DEF_SIZE    256     /* Default buffer size */
  81 #define BUF_ADD_INC     256     /* Expansion increment when Adding */
  82 #define BUF_UNGET_INC   16      /* Expansion increment when Ungetting */
  83
  84 /*-
  85  *-----------------------------------------------------------------------
  86  * Buf_OvAddByte --
  87  *      Add a single byte to the buffer.  left is zero or negative.
  88  *
  89  * Results:
  90  *      None.
  91  *
  92  * Side Effects:
  93  *      The buffer may be expanded.
  94  *
  95  *-----------------------------------------------------------------------
  96  */
  97 void
  98 Buf_OvAddByte(Buffer *bp, Byte byte)
  99 {
 100         bp->left = 0;
 101         BufExpand(bp, 1);
 102
 103         *bp->inPtr++ = byte;
 104         bp->left--;
 105
 106         /*
 107          * Null-terminate
 108          */
 109         *bp->inPtr = 0;
 110 }
 111
 112 /*-
 113  *-----------------------------------------------------------------------
 114  * Buf_AddBytes --
 115  *      Add a number of bytes to the buffer.
 116  *
 117  * Results:
 118  *      None.
 119  *
 120  * Side Effects:
 121  *      Guess what?
 122  *
 123  *-----------------------------------------------------------------------
 124  */
 125 void
 126 Buf_AddBytes(Buffer *bp, size_t numBytes, const Byte *bytesPtr)
 127 {
 128         BufExpand(bp, numBytes);
 129
 130         memcpy(bp->inPtr, bytesPtr, numBytes);
 131         bp->inPtr += numBytes;
 132         bp->left -= numBytes;
 133
 134         /*
 135          * Null-terminate
 136          */
 137         *bp->inPtr = 0;
 138 }
 139
 140 /*-
 141  *-----------------------------------------------------------------------
 142  * Buf_GetAll --
 143  *      Get all the available data at once.
 144  *
 145  * Results:
 146  *      A pointer to the data and the number of bytes available.
 147  *
 148  * Side Effects:
 149  *      None.
 150  *
 151  *-----------------------------------------------------------------------
 152  */
 153 Byte *
 154 Buf_GetAll(Buffer *bp, size_t *numBytesPtr)
 155 {
 156         if (numBytesPtr != NULL)
 157                 *numBytesPtr = bp->inPtr - bp->outPtr;
 158
 159         return (bp->outPtr);
 160 }
 161
 162 /*-
 163  *-----------------------------------------------------------------------
 164  * Buf_Discard --
 165  *      Throw away bytes in a buffer.
 166  *
 167  * Results:
 168  *      None.
 169  *
 170  * Side Effects:
 171  *      The bytes are discarded.
 172  *
 173  *-----------------------------------------------------------------------
 174  */
 175 void
 176 Buf_Discard(Buffer *bp, size_t numBytes)
 177 {
 178         if ((size_t)(bp->inPtr - bp->outPtr) <= numBytes) {
 179                 bp->inPtr = bp->outPtr = bp->buffer;
 180                 bp->left = bp->size;
 181                 *bp->inPtr = 0;
 182         } else
 183                 bp->outPtr += numBytes;
 184 }
 185
 186 /*-
 187  *-----------------------------------------------------------------------
 188  * Buf_Size --
 189  *      Returns the number of bytes in the given buffer. Doesn't include
 190  *      the null-terminating byte.
 191  *
 192  * Results:
 193  *      The number of bytes.
 194  *
 195  * Side Effects:
 196  *      None.
 197  *
 198  *-----------------------------------------------------------------------
 199  */
 200 size_t
 201 Buf_Size(Buffer *buf)
 202 {
 203         return (buf->inPtr - buf->outPtr);
 204 }
 205
 206 /*-
 207  *-----------------------------------------------------------------------
 208  * Buf_Init --
 209  *      Initialize a buffer. If no initial size is given, a reasonable
 210  *      default is used.
 211  *
 212  * Results:
 213  *      A buffer to be given to other functions in this library.
 214  *
 215  * Side Effects:
 216  *      The buffer is created, the space allocated and pointers
 217  *      initialized.
 218  *
 219  *-----------------------------------------------------------------------
 220  */
 221 Buffer *
 222 Buf_Init(size_t size)
 223 {
 224         Buffer *bp;     /* New Buffer */
 225
 226         bp = emalloc(sizeof(*bp));
 227
 228         if (size <= 0)
 229                 size = BUF_DEF_SIZE;
 230
 231         bp->left = bp->size = size;
 232         bp->buffer = emalloc(size);
 233         bp->inPtr = bp->outPtr = bp->buffer;
 234         *bp->inPtr = 0;
 235
 236         return (bp);
 237 }
 238
 239 /*-
 240  *-----------------------------------------------------------------------
 241  * Buf_Destroy --
 242  *      Destroy a buffer, and optionally free its data, too.
 243  *
 244  * Results:
 245  *      None.
 246  *
 247  * Side Effects:
 248  *      The buffer is freed.
 249  *
 250  *-----------------------------------------------------------------------
 251  */
 252 void
 253 Buf_Destroy(Buffer *buf, Boolean freeData)
 254 {
 255         if (freeData)
 256                 free(buf->buffer);
 257         free(buf);
 258 }
 259
 260 /*-
 261  *-----------------------------------------------------------------------
 262  * Buf_ReplaceLastByte --
 263  *      Replace the last byte in a buffer.
 264  *
 265  * Results:
 266  *      None.
 267  *
 268  * Side Effects:
 269  *      If the buffer was empty intially, then a new byte will be added.
 270  *      Otherwise, the last byte is overwritten.
 271  *
 272  *-----------------------------------------------------------------------
 273  */
 274 void
 275 Buf_ReplaceLastByte(Buffer *buf, Byte byte)
 276 {
 277         if (buf->inPtr == buf->outPtr)
 278                 Buf_AddByte(buf, byte);
 279         else
 280                 *(buf->inPtr - 1) = byte;
 281 }