- New function Buf_Append(), which is given a pointer to a string to
[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.22 2005/01/24 05:12:58 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  * Returns the number of bytes in the given buffer.  Doesn't include
62  * the null-terminating byte.
63  *
64  * @return The number of bytes in Buffer object.
65  */
66 inline size_t
67 Buf_Size(const Buffer *buf)
68 {
69         return (buf->inPtr - buf->buffer);
70 }
71
72 /**
73  * Expand the given buffer to hold the given number of additional
74  * bytes, plus space to store a terminating NULL byte.
75  */
76 static inline void
77 BufExpand(Buffer *bp, size_t nb)
78 {
79         size_t  len = Buf_Size(bp);
80         if (bp->size < len + nb + 1) {
81                 int size = bp->size + MAX(nb + 1, BUF_ADD_INC);
82
83                 bp->size        = size;
84                 bp->buffer      = erealloc(bp->buffer, size);
85                 bp->inPtr       = bp->buffer + len;
86         }
87 }
88
89 /* Buf_AddByte adds a single byte to a buffer. */
90 void
91 Buf_AddByte(Buffer *bp, Byte byte)
92 {
93         BufExpand(bp, 1);
94
95         *bp->inPtr = byte;
96         bp->inPtr++;
97         *bp->inPtr = '\0';
98 }
99
100 /*-
101  *-----------------------------------------------------------------------
102  * Buf_AddBytes
103  *      Add a number of bytes to the buffer.
104  *-----------------------------------------------------------------------
105  */
106 void
107 Buf_AddBytes(Buffer *bp, size_t numBytes, const Byte *bytesPtr)
108 {
109         BufExpand(bp, numBytes);
110
111         memcpy(bp->inPtr, bytesPtr, numBytes);
112         bp->inPtr += numBytes;
113         *bp->inPtr = '\0';
114 }
115
116 /**
117  * Get a reference to the internal buffer.
118  *
119  * @return A pointer to the data and the number of bytes available.
120  */
121 Byte *
122 Buf_GetAll(Buffer *bp, size_t *numBytesPtr)
123 {
124         if (numBytesPtr != NULL)
125                 *numBytesPtr = Buf_Size(bp);
126
127         return (bp->buffer);
128 }
129
130 /**
131  * Initialize a buffer. If no initial size is given, a reasonable
132  * default is used.
133  *
134  * @return A buffer object to be given to other functions in this library.
135  *
136  * Side Effects:
137  *      Space is allocated for the Buffer object and a internal buffer.
138  */
139 Buffer *
140 Buf_Init(size_t size)
141 {
142         Buffer *bp;     /* New Buffer */
143
144         if (size <= 0)
145                 size = BUF_DEF_SIZE;
146
147         bp = emalloc(sizeof(*bp));
148         bp->size        = size;
149         bp->buffer      = emalloc(size);
150         bp->inPtr       = bp->buffer;
151         *bp->inPtr      = '\0';
152
153         return (bp);
154 }
155
156 /**
157  * Buf_Destroy
158  *      Destroy a buffer, and optionally free its data, too.
159  *
160  * Side Effects:
161  *      Space for the Buffer object and possibly the internal buffer
162  *      is de-allocated.
163  */
164 void
165 Buf_Destroy(Buffer *buf, Boolean freeData)
166 {
167         if (freeData)
168                 free(buf->buffer);
169         free(buf);
170 }
171
172 /**
173  * Buf_ReplaceLastByte
174  *      Replace the last byte in a buffer.  If the buffer was empty
175  *      intially, then a new byte will be added.
176  */
177 void
178 Buf_ReplaceLastByte(Buffer *bp, Byte byte)
179 {
180         if (bp->inPtr == bp->buffer) {
181                 *bp->inPtr      = byte;
182                 bp->inPtr++;
183                 *bp->inPtr      = '\0';
184         } else {
185                 *(bp->inPtr - 1) = byte;
186         }
187 }
188
189 void
190 Buf_Clear(Buffer *bp)
191 {
192         bp->inPtr       = bp->buffer;
193         *bp->inPtr      = '\0';
194 }
195
196 /**
197  * Append characters in str to Buffer object
198  */
199 void
200 Buf_Append(Buffer *bp, const char str[])
201 {
202         Buf_AddBytes(bp, strlen(str), str);
203 }
204