1 | /*****************************************************************************/ |
2 | /* */ |
3 | /* strbuf.c */ |
4 | /* */ |
5 | /* Variable sized string buffers */ |
6 | /* */ |
7 | /* */ |
8 | /* */ |
9 | /* (C) 2001-2012, Ullrich von Bassewitz */ |
10 | /* Roemerstrasse 52 */ |
11 | /* D-70794 Filderstadt */ |
12 | /* EMail: uz@cc65.org */ |
13 | /* */ |
14 | /* */ |
15 | /* This software is provided 'as-is', without any expressed or implied */ |
16 | /* warranty. In no event will the authors be held liable for any damages */ |
17 | /* arising from the use of this software. */ |
18 | /* */ |
19 | /* Permission is granted to anyone to use this software for any purpose, */ |
20 | /* including commercial applications, and to alter it and redistribute it */ |
21 | /* freely, subject to the following restrictions: */ |
22 | /* */ |
23 | /* 1. The origin of this software must not be misrepresented; you must not */ |
24 | /* claim that you wrote the original software. If you use this software */ |
25 | /* in a product, an acknowledgment in the product documentation would be */ |
26 | /* appreciated but is not required. */ |
27 | /* 2. Altered source versions must be plainly marked as such, and must not */ |
28 | /* be misrepresented as being the original software. */ |
29 | /* 3. This notice may not be removed or altered from any source */ |
30 | /* distribution. */ |
31 | /* */ |
32 | /*****************************************************************************/ |
33 | |
34 | |
35 | |
36 | #include <string.h> |
37 | #include <ctype.h> |
38 | |
39 | /* common */ |
40 | #include "chartype.h" |
41 | #include "strbuf.h" |
42 | #include "va_copy.h" |
43 | #include "xmalloc.h" |
44 | #include "xsprintf.h" |
45 | |
46 | |
47 | |
48 | /*****************************************************************************/ |
49 | /* Data */ |
50 | /*****************************************************************************/ |
51 | |
52 | |
53 | |
54 | /* An empty string buf */ |
55 | const StrBuf EmptyStrBuf = STATIC_STRBUF_INITIALIZER; |
56 | |
57 | |
58 | |
59 | /*****************************************************************************/ |
60 | /* Code */ |
61 | /*****************************************************************************/ |
62 | |
63 | |
64 | |
65 | #if !defined(HAVE_INLINE) |
66 | StrBuf* SB_Init (StrBuf* B) |
67 | /* Initialize a string buffer */ |
68 | { |
69 | *B = EmptyStrBuf; |
70 | return B; |
71 | } |
72 | #endif |
73 | |
74 | |
75 | |
76 | StrBuf* SB_InitFromString (StrBuf* B, const char* S) |
77 | /* Initialize a string buffer from a literal string. Beware: The buffer won't |
78 | ** store a copy but a pointer to the actual string. |
79 | */ |
80 | { |
81 | B->Allocated = 0; |
82 | B->Len = strlen (S); |
83 | B->Index = 0; |
84 | B->Buf = (char*) S; |
85 | return B; |
86 | } |
87 | |
88 | |
89 | |
90 | void SB_Done (StrBuf* B) |
91 | /* Free the data of a string buffer (but not the struct itself) */ |
92 | { |
93 | if (B->Allocated) { |
94 | xfree (B->Buf); |
95 | } |
96 | } |
97 | |
98 | |
99 | |
100 | StrBuf* NewStrBuf (void) |
101 | /* Allocate, initialize and return a new StrBuf */ |
102 | { |
103 | /* Allocate a new string buffer */ |
104 | StrBuf* B = xmalloc (sizeof (StrBuf)); |
105 | |
106 | /* Initialize the struct... */ |
107 | SB_Init (B); |
108 | |
109 | /* ...and return it */ |
110 | return B; |
111 | } |
112 | |
113 | |
114 | |
115 | void FreeStrBuf (StrBuf* B) |
116 | /* Free a string buffer */ |
117 | { |
118 | /* Allow NULL pointers */ |
119 | if (B) { |
120 | SB_Done (B); |
121 | xfree (B); |
122 | } |
123 | } |
124 | |
125 | |
126 | |
127 | void SB_Realloc (StrBuf* B, unsigned NewSize) |
128 | /* Reallocate the string buffer space, make sure at least NewSize bytes are |
129 | ** available. |
130 | */ |
131 | { |
132 | /* Get the current size, use a minimum of 8 bytes */ |
133 | unsigned NewAllocated = B->Allocated; |
134 | if (NewAllocated == 0) { |
135 | NewAllocated = 8; |
136 | } |
137 | |
138 | /* Round up to the next power of two */ |
139 | while (NewAllocated < NewSize) { |
140 | NewAllocated *= 2; |
141 | } |
142 | |
143 | /* Reallocate the buffer. Beware: The allocated size may be zero while the |
144 | ** length is not. This means that we have a buffer that wasn't allocated |
145 | ** on the heap. |
146 | */ |
147 | if (B->Allocated) { |
148 | /* Just reallocate the block */ |
149 | B->Buf = xrealloc (B->Buf, NewAllocated); |
150 | } else { |
151 | /* Allocate a new block and copy */ |
152 | B->Buf = memcpy (xmalloc (NewAllocated), B->Buf, B->Len); |
153 | } |
154 | |
155 | /* Remember the new block size */ |
156 | B->Allocated = NewAllocated; |
157 | } |
158 | |
159 | |
160 | |
161 | static void SB_CheapRealloc (StrBuf* B, unsigned NewSize) |
162 | /* Reallocate the string buffer space, make sure at least NewSize bytes are |
163 | ** available. This function won't copy the old buffer contents over to the new |
164 | ** buffer and may be used if the old contents are overwritten later. |
165 | */ |
166 | { |
167 | /* Get the current size, use a minimum of 8 bytes */ |
168 | unsigned NewAllocated = B->Allocated; |
169 | if (NewAllocated == 0) { |
170 | NewAllocated = 8; |
171 | } |
172 | |
173 | /* Round up to the next power of two */ |
174 | while (NewAllocated < NewSize) { |
175 | NewAllocated *= 2; |
176 | } |
177 | |
178 | /* Free the old buffer if there is one */ |
179 | if (B->Allocated) { |
180 | xfree (B->Buf); |
181 | } |
182 | |
183 | /* Allocate a fresh block */ |
184 | B->Buf = xmalloc (NewAllocated); |
185 | |
186 | /* Remember the new block size */ |
187 | B->Allocated = NewAllocated; |
188 | } |
189 | |
190 | |
191 | |
192 | #if !defined(HAVE_INLINE) |
193 | char SB_At (const StrBuf* B, unsigned Index) |
194 | /* Get a character from the buffer */ |
195 | { |
196 | PRECONDITION (Index < B->Len); |
197 | return B->Buf[Index]; |
198 | } |
199 | #endif |
200 | |
201 | |
202 | |
203 | void SB_Drop (StrBuf* B, unsigned Count) |
204 | /* Drop characters from the end of the string. */ |
205 | { |
206 | PRECONDITION (Count <= B->Len); |
207 | B->Len -= Count; |
208 | if (B->Index > B->Len) { |
209 | B->Index = B->Len; |
210 | } |
211 | } |
212 | |
213 | |
214 | |
215 | void SB_Terminate (StrBuf* B) |
216 | /* Zero terminate the given string buffer. NOTE: The terminating zero is not |
217 | ** accounted for in B->Len, if you want that, you have to use AppendChar! |
218 | */ |
219 | { |
220 | unsigned NewLen = B->Len + 1; |
221 | if (NewLen > B->Allocated) { |
222 | SB_Realloc (B, NewLen); |
223 | } |
224 | B->Buf[B->Len] = '\0'; |
225 | } |
226 | |
227 | |
228 | |
229 | void SB_CopyBuf (StrBuf* Target, const char* Buf, unsigned Size) |
230 | /* Copy Buf to Target, discarding the old contents of Target */ |
231 | { |
232 | if (Size) { |
233 | if (Target->Allocated < Size) { |
234 | SB_CheapRealloc (Target, Size); |
235 | } |
236 | memcpy (Target->Buf, Buf, Size); |
237 | } |
238 | Target->Len = Size; |
239 | } |
240 | |
241 | |
242 | |
243 | #if !defined(HAVE_INLINE) |
244 | void SB_CopyStr (StrBuf* Target, const char* S) |
245 | /* Copy S to Target, discarding the old contents of Target */ |
246 | { |
247 | SB_CopyBuf (Target, S, strlen (S)); |
248 | } |
249 | #endif |
250 | |
251 | |
252 | |
253 | #if !defined(HAVE_INLINE) |
254 | void SB_Copy (StrBuf* Target, const StrBuf* Source) |
255 | /* Copy Source to Target, discarding the old contents of Target */ |
256 | { |
257 | SB_CopyBuf (Target, Source->Buf, Source->Len); |
258 | Target->Index = Source->Index; |
259 | } |
260 | #endif |
261 | |
262 | |
263 | |
264 | void SB_AppendChar (StrBuf* B, int C) |
265 | /* Append a character to a string buffer */ |
266 | { |
267 | unsigned NewLen = B->Len + 1; |
268 | if (NewLen > B->Allocated) { |
269 | SB_Realloc (B, NewLen); |
270 | } |
271 | B->Buf[B->Len] = (char) C; |
272 | B->Len = NewLen; |
273 | } |
274 | |
275 | |
276 | |
277 | void SB_AppendBuf (StrBuf* B, const char* S, unsigned Size) |
278 | /* Append a character buffer to the end of the string buffer */ |
279 | { |
280 | unsigned NewLen = B->Len + Size; |
281 | if (NewLen > B->Allocated) { |
282 | SB_Realloc (B, NewLen); |
283 | } |
284 | memcpy (B->Buf + B->Len, S, Size); |
285 | B->Len = NewLen; |
286 | } |
287 | |
288 | |
289 | |
290 | #if !defined(HAVE_INLINE) |
291 | void SB_AppendStr (StrBuf* B, const char* S) |
292 | /* Append a string to the end of the string buffer */ |
293 | { |
294 | SB_AppendBuf (B, S, strlen (S)); |
295 | } |
296 | #endif |
297 | |
298 | |
299 | |
300 | #if !defined(HAVE_INLINE) |
301 | void SB_Append (StrBuf* Target, const StrBuf* Source) |
302 | /* Append the contents of Source to Target */ |
303 | { |
304 | SB_AppendBuf (Target, Source->Buf, Source->Len); |
305 | } |
306 | #endif |
307 | |
308 | |
309 | |
310 | #if !defined(HAVE_INLINE) |
311 | void SB_Cut (StrBuf* B, unsigned Len) |
312 | /* Cut the contents of B at the given length. If the current length of the |
313 | ** buffer is smaller than Len, nothing will happen. |
314 | */ |
315 | { |
316 | if (Len < B->Len) { |
317 | B->Len = Len; |
318 | } |
319 | } |
320 | #endif |
321 | |
322 | |
323 | |
324 | void SB_Slice (StrBuf* Target, const StrBuf* Source, unsigned Start, unsigned Len) |
325 | /* Copy a slice from Source into Target. The current contents of Target are |
326 | ** destroyed. If Start is greater than the length of Source, or if Len |
327 | ** characters aren't available, the result will be a buffer with less than Len |
328 | ** bytes. |
329 | */ |
330 | { |
331 | /* Calculate the length of the resulting buffer */ |
332 | if (Start >= Source->Len) { |
333 | /* Target will be empty */ |
334 | SB_Clear (Target); |
335 | return; |
336 | } |
337 | if (Start + Len > Source->Len) { |
338 | Len = Source->Len - Start; |
339 | } |
340 | |
341 | /* Make sure we have enough room in the target string buffer */ |
342 | if (Len > Target->Allocated) { |
343 | SB_Realloc (Target, Len); |
344 | } |
345 | |
346 | /* Copy the slice */ |
347 | memcpy (Target->Buf, Source->Buf + Start, Len); |
348 | Target->Len = Len; |
349 | } |
350 | |
351 | |
352 | |
353 | void SB_Move (StrBuf* Target, StrBuf* Source) |
354 | /* Move the complete contents of Source to target. This will delete the old |
355 | ** contents of Target, and Source will be empty after the call. |
356 | */ |
357 | { |
358 | /* Free the target string */ |
359 | if (Target->Allocated) { |
360 | xfree (Target->Buf); |
361 | } |
362 | |
363 | /* Move all data from Source to Target */ |
364 | *Target = *Source; |
365 | |
366 | /* Clear Source */ |
367 | SB_Init (Source); |
368 | } |
369 | |
370 | |
371 | |
372 | void SB_ToLower (StrBuf* S) |
373 | /* Convert all characters in S to lower case */ |
374 | { |
375 | unsigned I; |
376 | char* B = S->Buf; |
377 | for (I = 0; I < S->Len; ++I, ++B) { |
378 | if (IsUpper (*B)) { |
379 | *B = tolower (*B); |
380 | } |
381 | } |
382 | } |
383 | |
384 | |
385 | |
386 | void SB_ToUpper (StrBuf* S) |
387 | /* Convert all characters in S to upper case */ |
388 | { |
389 | unsigned I; |
390 | char* B = S->Buf; |
391 | for (I = 0; I < S->Len; ++I, ++B) { |
392 | if (IsLower (*B)) { |
393 | *B = toupper (*B); |
394 | } |
395 | } |
396 | } |
397 | |
398 | |
399 | |
400 | int SB_Compare (const StrBuf* S1, const StrBuf* S2) |
401 | /* Do a lexical compare of S1 and S2. See strcmp for result codes. */ |
402 | { |
403 | int Result; |
404 | if (S1->Len < S2->Len) { |
405 | Result = memcmp (S1->Buf, S2->Buf, S1->Len); |
406 | if (Result == 0) { |
407 | /* S1 considered lesser because it's shorter */ |
408 | Result = -1; |
409 | } |
410 | } else if (S1->Len > S2->Len) { |
411 | Result = memcmp (S1->Buf, S2->Buf, S2->Len); |
412 | if (Result == 0) { |
413 | /* S2 considered lesser because it's shorter */ |
414 | Result = 1; |
415 | } |
416 | } else { |
417 | Result = memcmp (S1->Buf, S2->Buf, S1->Len); |
418 | } |
419 | return Result; |
420 | } |
421 | |
422 | |
423 | |
424 | int SB_CompareStr (const StrBuf* S1, const char* S2) |
425 | /* Do a lexical compare of S1 and S2. See strcmp for result codes. */ |
426 | { |
427 | int Result; |
428 | unsigned S2Len = strlen (S2); |
429 | if (S1->Len < S2Len) { |
430 | Result = memcmp (S1->Buf, S2, S1->Len); |
431 | if (Result == 0) { |
432 | /* S1 considered lesser because it's shorter */ |
433 | Result = -1; |
434 | } |
435 | } else if (S1->Len > S2Len) { |
436 | Result = memcmp (S1->Buf, S2, S2Len); |
437 | if (Result == 0) { |
438 | /* S2 considered lesser because it's shorter */ |
439 | Result = 1; |
440 | } |
441 | } else { |
442 | Result = memcmp (S1->Buf, S2, S1->Len); |
443 | } |
444 | return Result; |
445 | } |
446 | |
447 | |
448 | |
449 | void SB_VPrintf (StrBuf* S, const char* Format, va_list ap) |
450 | /* printf function with S as target. The function is safe, which means that |
451 | ** the current contents of S are discarded, and are allocated again with |
452 | ** a matching size for the output. The function will call FAIL when problems |
453 | ** are detected (anything that let xsnprintf return -1). |
454 | */ |
455 | { |
456 | va_list tmp; |
457 | int SizeNeeded; |
458 | |
459 | /* Since we must determine the space needed anyway, we will try with |
460 | ** the currently allocated memory. If the call succeeds, we've saved |
461 | ** an allocation. If not, we have to reallocate and try again. |
462 | */ |
463 | va_copy (tmp, ap); |
464 | SizeNeeded = xvsnprintf (S->Buf, S->Allocated, Format, tmp); |
465 | va_end (tmp); |
466 | |
467 | /* Check the result, the xvsnprintf function should not fail */ |
468 | CHECK (SizeNeeded >= 0); |
469 | |
470 | /* Check if we must reallocate */ |
471 | if ((unsigned) SizeNeeded >= S->Allocated) { |
472 | /* Must retry. Use CheapRealloc to avoid copying */ |
473 | SB_CheapRealloc (S, SizeNeeded + 1); /* Account for '\0' */ |
474 | (void) xvsnprintf (S->Buf, S->Allocated, Format, ap); |
475 | } |
476 | |
477 | /* Update string buffer variables */ |
478 | S->Len = SizeNeeded; |
479 | S->Index = 0; |
480 | } |
481 | |
482 | |
483 | |
484 | void SB_Printf (StrBuf* S, const char* Format, ...) |
485 | /* vprintf function with S as target. The function is safe, which means that |
486 | ** the current contents of S are discarded, and are allocated again with |
487 | ** a matching size for the output. The function will call FAIL when problems |
488 | ** are detected (anything that let xsnprintf return -1). |
489 | */ |
490 | { |
491 | va_list ap; |
492 | va_start (ap, Format); |
493 | SB_VPrintf (S, Format, ap); |
494 | va_end (ap); |
495 | } |
496 | |