OSDN Git Service

f6fad61803155a3c4817691c82489b4eca0482fc
[pf3gnuchains/gcc-fork.git] / libiberty / dyn-string.c
1 /* An abstract string datatype.
2    Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3    Contributed by Mark Mitchell (mark@markmitchell.com).
4
5 This file is part of GNU CC.
6    
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)
10 any later version.
11
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #ifdef HAVE_STRING_H
27 #include <string.h>
28 #endif
29
30 #ifdef HAVE_STDLIB_H
31 #include <stdlib.h>
32 #endif
33
34 #include "libiberty.h"
35 #include "dyn-string.h"
36
37 /* Performs in-place initialization of a dyn_string struct.  This
38    function can be used with a dyn_string struct on the stack or
39    embedded in another object.  The contents of of the string itself
40    are still dynamically allocated.  The string initially is capable
41    of holding at least SPACE characeters, including the terminating
42    NUL.  If SPACE is 0, it will silently be increated to 1.  */
43
44 void
45 dyn_string_init (ds_struct_ptr, space)
46      struct dyn_string *ds_struct_ptr;
47      int space;
48 {
49   /* We need at least one byte in which to store the terminating NUL.  */
50   if (space == 0)
51     space = 1;
52
53   ds_struct_ptr->allocated = space;
54   ds_struct_ptr->s = (char *) xmalloc (space);
55   ds_struct_ptr->length = 0;
56   ds_struct_ptr->s[0] = '\0';
57 }    
58
59 /* Create a new dynamic string capable of holding at least SPACE characters,
60    including the terminating NUL.  If SPACE is 0, it will be silently
61    increased to 1.  */
62
63 dyn_string_t 
64 dyn_string_new (space)
65      int space;
66 {
67   dyn_string_t result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
68   dyn_string_init (result, space);
69   return result;
70 }
71
72 /* Free the memory used by DS.  */
73
74 void 
75 dyn_string_delete (ds)
76      dyn_string_t ds;
77 {
78   free (ds->s);
79   free (ds);
80 }
81
82 /* Returns the contents of DS in a buffer allocated with malloc.  It
83    is the caller's responsibility to deallocate the buffer using free.
84    DS is then set to the empty string.  */
85
86 char*
87 dyn_string_release (ds)
88      dyn_string_t ds;
89 {
90   /* Store the old buffer.  */
91   char* result = ds->s;
92   /* The buffer is no longer owned by DS.  */
93   ds->s = NULL;
94   /* Reinitialize DS to the empty string.  */
95   dyn_string_init (ds, 0);
96   /* Return the old buffer.  */
97   return result;
98 }
99
100 /* Increase the capacity of DS so it can hold at least SPACE
101    characters, plus the terminating NUL.  This function will not (at
102    present) reduce the capacity of DS.  */
103
104 dyn_string_t 
105 dyn_string_resize (ds, space)
106      dyn_string_t ds;
107      int space;
108 {
109   int new_allocated = ds->allocated;
110
111   /* Increase SPACE to hold the NUL termination.  */
112   ++space;
113
114   while (space > new_allocated)
115     new_allocated *= 2;
116     
117   if (new_allocated != ds->allocated)
118     {
119       /* We actually need more space.  */
120       ds->allocated = new_allocated;
121       ds->s = (char *) xrealloc (ds->s, ds->allocated);
122     }
123
124   return ds;
125 }
126
127 /* Sets the contents of DS to the empty string.  */
128
129 void
130 dyn_string_clear (ds)
131      dyn_string_t ds;
132 {
133   /* A dyn_string always has room for at least the NUL terminator.  */
134   ds->s[0] = '\0';
135   ds->length = 0;
136 }
137
138 /* Makes the contents of DEST the same as the contents of SRC.  DEST
139    and SRC must be distinct.  */
140
141 void
142 dyn_string_copy (dest, src)
143      dyn_string_t dest;
144      dyn_string_t src;
145 {
146   if (dest == src)
147     abort ();
148
149   /* Make room in DEST.  */
150   dyn_string_resize (dest, src->length);
151   /* Copy DEST into SRC.  */
152   strcpy (dest->s, src->s);
153   /* Update the size of DEST.  */
154   dest->length = src->length;
155 }
156
157 /* Copies SRC, a NUL-terminated string, into DEST.  */
158
159 void
160 dyn_string_copy_cstr (dest, src)
161      dyn_string_t dest;
162      const char *src;
163 {
164   int length = strlen (src);
165   /* Make room in DEST.  */
166   dyn_string_resize (dest, length);
167   /* Copy DEST into SRC.  */
168   strcpy (dest->s, src);
169   /* Update the size of DEST.  */
170   dest->length = length;
171 }
172
173 /* Inserts SRC at the beginning of DEST.  DEST is expanded as
174    necessary.  SRC and DEST must be distinct.  */
175
176 void 
177 dyn_string_prepend (dest, src)
178      dyn_string_t dest;
179      dyn_string_t src;
180 {
181   dyn_string_insert (dest, 0, src);
182 }
183
184 /* Inserts SRC, a NUL-terminated string, at the beginning of DEST.
185    DEST is expanded as necessary.  */
186
187 void 
188 dyn_string_prepend_cstr (dest, src)
189      dyn_string_t dest;
190      const char *src;
191 {
192   dyn_string_insert_cstr (dest, 0, src);
193 }
194
195 /* Inserts SRC into DEST starting at position POS.  DEST is expanded as
196    necessary.  SRC and DEST must be distinct.  */
197
198 void 
199 dyn_string_insert (dest, pos, src)
200      dyn_string_t dest;
201      int pos;
202      dyn_string_t src;
203 {
204   int i;
205
206   if (src == dest)
207     abort ();
208
209   dyn_string_resize (dest, dest->length + src->length);
210   /* Make room for the insertion.  Be sure to copy the NUL.  */
211   for (i = dest->length; i >= pos; --i)
212     dest->s[i + src->length] = dest->s[i];
213   /* Splice in the new stuff.  */
214   strncpy (dest->s + pos, src->s, src->length);
215   /* Compute the new length.  */
216   dest->length += src->length;
217 }
218
219 /* Inserts SRC, a NUL-terminated string, into DEST starting at
220    position POS.  DEST is expanded as necessary.  */
221
222 void 
223 dyn_string_insert_cstr (dest, pos, src)
224      dyn_string_t dest;
225      int pos;
226      const char *src;
227 {
228   int i;
229   int length = strlen (src);
230
231   dyn_string_resize (dest, dest->length + length);
232   /* Make room for the insertion.  Be sure to copy the NUL.  */
233   for (i = dest->length; i >= pos; --i)
234     dest->s[i + length] = dest->s[i];
235   /* Splice in the new stuff.  */
236   strncpy (dest->s + pos, src, length);
237   /* Compute the new length.  */
238   dest->length += length;
239 }
240
241 /* Append S to DS, resizing DS if necessary.  Returns DS.  */
242
243 dyn_string_t
244 dyn_string_append (ds, s)
245      dyn_string_t ds;
246      dyn_string_t s;
247 {
248   dyn_string_resize (ds, ds->length + s->length);
249   strcpy (ds->s + ds->length, s->s);
250   ds->length += s->length;
251   return ds;
252 }
253
254 /* Append the NUL-terminated string S to DS, resizing DS if necessary.
255    Returns DS.  */
256
257 dyn_string_t 
258 dyn_string_append_cstr (ds, s)
259      dyn_string_t ds;
260      const char *s;
261 {
262   int len = strlen (s);
263
264   /* The new length is the old length plus the size of our string, plus
265      one for the null at the end.  */
266   dyn_string_resize (ds, ds->length + len);
267   strcpy (ds->s + ds->length, s);
268   ds->length += len;
269
270   return ds;
271 }
272
273 /* Appends C to the end of DS.  */
274
275 dyn_string_t 
276 dyn_string_append_char (ds, c)
277      dyn_string_t ds;
278      char c;
279 {
280   /* Make room for the extra character.  */
281   dyn_string_resize (ds, ds->length + 1);
282   /* Append the character; it will overwrite the old NUL.  */
283   ds->s[ds->length] = c;
284   /* Add a new NUL at the end.  */
285   ds->s[ds->length + 1] = '\0';
286   /* Update the length.  */
287   ++(ds->length);
288   return ds;
289 }
290
291 /* Sets the contents of DEST to the substring of SRC starting at START
292    and ending before END.  START must be less than or equal to END,
293    and both must be between zero and the length of SRC, inclusive.  */
294
295 void
296 dyn_string_substring (dest, src, start, end)
297      dyn_string_t dest;
298      dyn_string_t src;
299      int start;
300      int end;
301 {
302   int i;
303   int length = end - start;
304
305   if (start > end || start > src->length || end > src->length)
306     abort ();
307
308   /* Make room for the substring.  */
309   dyn_string_resize (dest, length);
310   /* Copy the characters in the substring,  */
311   for (i = length; --i >= 0; )
312     dest->s[i] = src->s[start + i];
313   /* NUL-terimate the result.  */
314   dest->s[length] = '\0';
315   /* Record the length of the substring.  */
316   dest->length = length;
317 }
318
319 /* Returns non-zero if DS1 and DS2 have the same contents.  */
320
321 int
322 dyn_string_eq (ds1, ds2)
323      dyn_string_t ds1;
324      dyn_string_t ds2;
325 {
326   /* If DS1 and DS2 have different lengths, they must not be the same.  */
327   if (ds1->length != ds2->length)
328     return 0;
329   else
330     return !strcmp (ds1->s, ds2->s);
331 }