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