- Cleanup white space. style(9)
[dragonfly.git] / 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 }