1 /* An abstract string datatype.
2 Copyright (C) 1998, 1999, 2000, 2002, 2004 Free Software Foundation, Inc.
3 Contributed by Mark Mitchell (mark@markmitchell.com).
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 GNU CC is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with GNU CC; see the file COPYING. If not, write to
28 the Free Software Foundation, 59 Temple Place - Suite 330,
29 Boston, MA 02111-1307, USA. */
45 #include "libiberty.h"
46 #include "dyn-string.h"
48 /* Performs in-place initialization of a dyn_string struct. This
49 function can be used with a dyn_string struct on the stack or
50 embedded in another object. The contents of of the string itself
51 are still dynamically allocated. The string initially is capable
52 of holding at least SPACE characeters, including the terminating
53 NUL. If SPACE is 0, it will silently be increated to 1.
55 If RETURN_ON_ALLOCATION_FAILURE is defined and memory allocation
56 fails, returns 0. Otherwise returns 1. */
59 dyn_string_init (ds_struct_ptr
, space
)
60 struct dyn_string
*ds_struct_ptr
;
63 /* We need at least one byte in which to store the terminating NUL. */
67 #ifdef RETURN_ON_ALLOCATION_FAILURE
68 ds_struct_ptr
->s
= (char *) malloc (space
);
69 if (ds_struct_ptr
->s
== NULL
)
72 ds_struct_ptr
->s
= (char *) xmalloc (space
);
74 ds_struct_ptr
->allocated
= space
;
75 ds_struct_ptr
->length
= 0;
76 ds_struct_ptr
->s
[0] = '\0';
81 /* Create a new dynamic string capable of holding at least SPACE
82 characters, including the terminating NUL. If SPACE is 0, it will
83 be silently increased to 1. If RETURN_ON_ALLOCATION_FAILURE is
84 defined and memory allocation fails, returns NULL. Otherwise
85 returns the newly allocated string. */
88 dyn_string_new (space
)
92 #ifdef RETURN_ON_ALLOCATION_FAILURE
93 result
= (dyn_string_t
) malloc (sizeof (struct dyn_string
));
96 if (!dyn_string_init (result
, space
))
102 result
= (dyn_string_t
) xmalloc (sizeof (struct dyn_string
));
103 dyn_string_init (result
, space
);
108 /* Free the memory used by DS. */
111 dyn_string_delete (ds
)
118 /* Returns the contents of DS in a buffer allocated with malloc. It
119 is the caller's responsibility to deallocate the buffer using free.
120 DS is then set to the empty string. Deletes DS itself. */
123 dyn_string_release (ds
)
126 /* Store the old buffer. */
127 char* result
= ds
->s
;
128 /* The buffer is no longer owned by DS. */
132 /* Return the old buffer. */
136 /* Increase the capacity of DS so it can hold at least SPACE
137 characters, plus the terminating NUL. This function will not (at
138 present) reduce the capacity of DS. Returns DS on success.
140 If RETURN_ON_ALLOCATION_FAILURE is defined and a memory allocation
141 operation fails, deletes DS and returns NULL. */
144 dyn_string_resize (ds
, space
)
148 int new_allocated
= ds
->allocated
;
150 /* Increase SPACE to hold the NUL termination. */
153 /* Increase allocation by factors of two. */
154 while (space
> new_allocated
)
157 if (new_allocated
!= ds
->allocated
)
159 ds
->allocated
= new_allocated
;
160 /* We actually need more space. */
161 #ifdef RETURN_ON_ALLOCATION_FAILURE
162 ds
->s
= (char *) realloc (ds
->s
, ds
->allocated
);
169 ds
->s
= (char *) xrealloc (ds
->s
, ds
->allocated
);
176 /* Sets the contents of DS to the empty string. */
179 dyn_string_clear (ds
)
182 /* A dyn_string always has room for at least the NUL terminator. */
187 /* Makes the contents of DEST the same as the contents of SRC. DEST
188 and SRC must be distinct. Returns 1 on success. On failure, if
189 RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
192 dyn_string_copy (dest
, src
)
199 /* Make room in DEST. */
200 if (dyn_string_resize (dest
, src
->length
) == NULL
)
202 /* Copy DEST into SRC. */
203 strcpy (dest
->s
, src
->s
);
204 /* Update the size of DEST. */
205 dest
->length
= src
->length
;
209 /* Copies SRC, a NUL-terminated string, into DEST. Returns 1 on
210 success. On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
214 dyn_string_copy_cstr (dest
, src
)
218 int length
= strlen (src
);
219 /* Make room in DEST. */
220 if (dyn_string_resize (dest
, length
) == NULL
)
222 /* Copy DEST into SRC. */
223 strcpy (dest
->s
, src
);
224 /* Update the size of DEST. */
225 dest
->length
= length
;
229 /* Inserts SRC at the beginning of DEST. DEST is expanded as
230 necessary. SRC and DEST must be distinct. Returns 1 on success.
231 On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
235 dyn_string_prepend (dest
, src
)
239 return dyn_string_insert (dest
, 0, src
);
242 /* Inserts SRC, a NUL-terminated string, at the beginning of DEST.
243 DEST is expanded as necessary. Returns 1 on success. On failure,
244 if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
247 dyn_string_prepend_cstr (dest
, src
)
251 return dyn_string_insert_cstr (dest
, 0, src
);
254 /* Inserts SRC into DEST starting at position POS. DEST is expanded
255 as necessary. SRC and DEST must be distinct. Returns 1 on
256 success. On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
260 dyn_string_insert (dest
, pos
, src
)
270 if (dyn_string_resize (dest
, dest
->length
+ src
->length
) == NULL
)
272 /* Make room for the insertion. Be sure to copy the NUL. */
273 for (i
= dest
->length
; i
>= pos
; --i
)
274 dest
->s
[i
+ src
->length
] = dest
->s
[i
];
275 /* Splice in the new stuff. */
276 strncpy (dest
->s
+ pos
, src
->s
, src
->length
);
277 /* Compute the new length. */
278 dest
->length
+= src
->length
;
282 /* Inserts SRC, a NUL-terminated string, into DEST starting at
283 position POS. DEST is expanded as necessary. Returns 1 on
284 success. On failure, RETURN_ON_ALLOCATION_FAILURE, deletes DEST
288 dyn_string_insert_cstr (dest
, pos
, src
)
294 int length
= strlen (src
);
296 if (dyn_string_resize (dest
, dest
->length
+ length
) == NULL
)
298 /* Make room for the insertion. Be sure to copy the NUL. */
299 for (i
= dest
->length
; i
>= pos
; --i
)
300 dest
->s
[i
+ length
] = dest
->s
[i
];
301 /* Splice in the new stuff. */
302 strncpy (dest
->s
+ pos
, src
, length
);
303 /* Compute the new length. */
304 dest
->length
+= length
;
308 /* Inserts character C into DEST starting at position POS. DEST is
309 expanded as necessary. Returns 1 on success. On failure,
310 RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
313 dyn_string_insert_char (dest
, pos
, c
)
320 if (dyn_string_resize (dest
, dest
->length
+ 1) == NULL
)
322 /* Make room for the insertion. Be sure to copy the NUL. */
323 for (i
= dest
->length
; i
>= pos
; --i
)
324 dest
->s
[i
+ 1] = dest
->s
[i
];
325 /* Add the new character. */
327 /* Compute the new length. */
332 /* Append S to DS, resizing DS if necessary. Returns 1 on success.
333 On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
337 dyn_string_append (dest
, s
)
341 if (dyn_string_resize (dest
, dest
->length
+ s
->length
) == 0)
343 strcpy (dest
->s
+ dest
->length
, s
->s
);
344 dest
->length
+= s
->length
;
348 /* Append the NUL-terminated string S to DS, resizing DS if necessary.
349 Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE,
350 deletes DEST and returns 0. */
353 dyn_string_append_cstr (dest
, s
)
357 int len
= strlen (s
);
359 /* The new length is the old length plus the size of our string, plus
360 one for the null at the end. */
361 if (dyn_string_resize (dest
, dest
->length
+ len
) == NULL
)
363 strcpy (dest
->s
+ dest
->length
, s
);
368 /* Appends C to the end of DEST. Returns 1 on success. On failiure,
369 if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
372 dyn_string_append_char (dest
, c
)
376 /* Make room for the extra character. */
377 if (dyn_string_resize (dest
, dest
->length
+ 1) == NULL
)
379 /* Append the character; it will overwrite the old NUL. */
380 dest
->s
[dest
->length
] = c
;
381 /* Add a new NUL at the end. */
382 dest
->s
[dest
->length
+ 1] = '\0';
383 /* Update the length. */
388 /* Sets the contents of DEST to the substring of SRC starting at START
389 and ending before END. START must be less than or equal to END,
390 and both must be between zero and the length of SRC, inclusive.
391 Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE,
392 deletes DEST and returns 0. */
395 dyn_string_substring (dest
, src
, start
, end
)
402 int length
= end
- start
;
404 if (start
> end
|| start
> src
->length
|| end
> src
->length
)
407 /* Make room for the substring. */
408 if (dyn_string_resize (dest
, length
) == NULL
)
410 /* Copy the characters in the substring, */
411 for (i
= length
; --i
>= 0; )
412 dest
->s
[i
] = src
->s
[start
+ i
];
413 /* NUL-terimate the result. */
414 dest
->s
[length
] = '\0';
415 /* Record the length of the substring. */
416 dest
->length
= length
;
421 /* Returns non-zero if DS1 and DS2 have the same contents. */
424 dyn_string_eq (ds1
, ds2
)
428 /* If DS1 and DS2 have different lengths, they must not be the same. */
429 if (ds1
->length
!= ds2
->length
)
432 return !strcmp (ds1
->s
, ds2
->s
);
This page took 0.037753 seconds and 4 git commands to generate.