OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [libiberty/] [dyn-string.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* 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
#include <stdio.h>
27
 
28
#ifdef HAVE_STRING_H
29
#include <string.h>
30
#endif
31
 
32
#ifdef HAVE_STDLIB_H
33
#include <stdlib.h>
34
#endif
35
 
36
#include "libiberty.h"
37
#include "dyn-string.h"
38
 
39
/* If this file is being compiled for inclusion in the C++ runtime
40
   library, as part of the demangler implementation, we don't want to
41
   abort if an allocation fails.  Instead, percolate an error code up
42
   through the call chain.  */
43
 
44
#ifdef IN_LIBGCC2
45
#define RETURN_ON_ALLOCATION_FAILURE
46
#endif
47
 
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.
54
 
55
   If RETURN_ON_ALLOCATION_FAILURE is defined and memory allocation
56
   fails, returns 0.  Otherwise returns 1.  */
57
 
58
int
59
dyn_string_init (ds_struct_ptr, space)
60
     struct dyn_string *ds_struct_ptr;
61
     int space;
62
{
63
  /* We need at least one byte in which to store the terminating NUL.  */
64
  if (space == 0)
65
    space = 1;
66
 
67
#ifdef RETURN_ON_ALLOCATION_FAILURE
68
  ds_struct_ptr->s = (char *) malloc (space);
69
  if (ds_struct_ptr->s == NULL)
70
    return 0;
71
#else
72
  ds_struct_ptr->s = (char *) xmalloc (space);
73
#endif
74
  ds_struct_ptr->allocated = space;
75
  ds_struct_ptr->length = 0;
76
  ds_struct_ptr->s[0] = '\0';
77
 
78
  return 1;
79
}
80
 
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.  */
86
 
87
dyn_string_t
88
dyn_string_new (space)
89
     int space;
90
{
91
  dyn_string_t result;
92
#ifdef RETURN_ON_ALLOCATION_FAILURE
93
  result = (dyn_string_t) malloc (sizeof (struct dyn_string));
94
  if (result == NULL)
95
    return NULL;
96
  if (!dyn_string_init (result, space))
97
    {
98
      free (result);
99
      return NULL;
100
    }
101
#else
102
  result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
103
  dyn_string_init (result, space);
104
#endif
105
  return result;
106
}
107
 
108
/* Free the memory used by DS.  */
109
 
110
void
111
dyn_string_delete (ds)
112
     dyn_string_t ds;
113
{
114
  free (ds->s);
115
  free (ds);
116
}
117
 
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.  */
121
 
122
char*
123
dyn_string_release (ds)
124
     dyn_string_t ds;
125
{
126
  /* Store the old buffer.  */
127
  char* result = ds->s;
128
  /* The buffer is no longer owned by DS.  */
129
  ds->s = NULL;
130
  /* Delete DS.  */
131
  free (ds);
132
  /* Return the old buffer.  */
133
  return result;
134
}
135
 
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.
139
 
140
   If RETURN_ON_ALLOCATION_FAILURE is defined and a memory allocation
141
   operation fails, deletes DS and returns NULL.  */
142
 
143
dyn_string_t
144
dyn_string_resize (ds, space)
145
     dyn_string_t ds;
146
     int space;
147
{
148
  int new_allocated = ds->allocated;
149
 
150
  /* Increase SPACE to hold the NUL termination.  */
151
  ++space;
152
 
153
  /* Increase allocation by factors of two.  */
154
  while (space > new_allocated)
155
    new_allocated *= 2;
156
 
157
  if (new_allocated != ds->allocated)
158
    {
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);
163
      if (ds->s == NULL)
164
        {
165
          free (ds);
166
          return NULL;
167
        }
168
#else
169
      ds->s = (char *) xrealloc (ds->s, ds->allocated);
170
#endif
171
    }
172
 
173
  return ds;
174
}
175
 
176
/* Sets the contents of DS to the empty string.  */
177
 
178
void
179
dyn_string_clear (ds)
180
     dyn_string_t ds;
181
{
182
  /* A dyn_string always has room for at least the NUL terminator.  */
183
  ds->s[0] = '\0';
184
  ds->length = 0;
185
}
186
 
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.  */
190
 
191
int
192
dyn_string_copy (dest, src)
193
     dyn_string_t dest;
194
     dyn_string_t src;
195
{
196
  if (dest == src)
197
    abort ();
198
 
199
  /* Make room in DEST.  */
200
  if (dyn_string_resize (dest, src->length) == NULL)
201
    return 0;
202
  /* Copy DEST into SRC.  */
203
  strcpy (dest->s, src->s);
204
  /* Update the size of DEST.  */
205
  dest->length = src->length;
206
  return 1;
207
}
208
 
209
/* Copies SRC, a NUL-terminated string, into DEST.  Returns 1 on
210
   success.  On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
211
   and returns 0.  */
212
 
213
int
214
dyn_string_copy_cstr (dest, src)
215
     dyn_string_t dest;
216
     const char *src;
217
{
218
  int length = strlen (src);
219
  /* Make room in DEST.  */
220
  if (dyn_string_resize (dest, length) == NULL)
221
    return 0;
222
  /* Copy DEST into SRC.  */
223
  strcpy (dest->s, src);
224
  /* Update the size of DEST.  */
225
  dest->length = length;
226
  return 1;
227
}
228
 
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
232
   returns 0.  */
233
 
234
int
235
dyn_string_prepend (dest, src)
236
     dyn_string_t dest;
237
     dyn_string_t src;
238
{
239
  return dyn_string_insert (dest, 0, src);
240
}
241
 
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. */
245
 
246
int
247
dyn_string_prepend_cstr (dest, src)
248
     dyn_string_t dest;
249
     const char *src;
250
{
251
  return dyn_string_insert_cstr (dest, 0, src);
252
}
253
 
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
257
   and returns 0.  */
258
 
259
int
260
dyn_string_insert (dest, pos, src)
261
     dyn_string_t dest;
262
     int pos;
263
     dyn_string_t src;
264
{
265
  int i;
266
 
267
  if (src == dest)
268
    abort ();
269
 
270
  if (dyn_string_resize (dest, dest->length + src->length) == NULL)
271
    return 0;
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;
279
  return 1;
280
}
281
 
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
285
   and returns 0.  */
286
 
287
int
288
dyn_string_insert_cstr (dest, pos, src)
289
     dyn_string_t dest;
290
     int pos;
291
     const char *src;
292
{
293
  int i;
294
  int length = strlen (src);
295
 
296
  if (dyn_string_resize (dest, dest->length + length) == NULL)
297
    return 0;
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;
305
  return 1;
306
}
307
 
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.  */
311
 
312
int
313
dyn_string_insert_char (dest, pos, c)
314
     dyn_string_t dest;
315
     int pos;
316
     int c;
317
{
318
  int i;
319
 
320
  if (dyn_string_resize (dest, dest->length + 1) == NULL)
321
    return 0;
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.  */
326
  dest->s[pos] = c;
327
  /* Compute the new length.  */
328
  ++dest->length;
329
  return 1;
330
}
331
 
332
/* Append S to DS, resizing DS if necessary.  Returns 1 on success.
333
   On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
334
   returns 0.  */
335
 
336
int
337
dyn_string_append (dest, s)
338
     dyn_string_t dest;
339
     dyn_string_t s;
340
{
341
  if (dyn_string_resize (dest, dest->length + s->length) == 0)
342
    return 0;
343
  strcpy (dest->s + dest->length, s->s);
344
  dest->length += s->length;
345
  return 1;
346
}
347
 
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.  */
351
 
352
int
353
dyn_string_append_cstr (dest, s)
354
     dyn_string_t dest;
355
     const char *s;
356
{
357
  int len = strlen (s);
358
 
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)
362
    return 0;
363
  strcpy (dest->s + dest->length, s);
364
  dest->length += len;
365
  return 1;
366
}
367
 
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.  */
370
 
371
int
372
dyn_string_append_char (dest, c)
373
     dyn_string_t dest;
374
     int c;
375
{
376
  /* Make room for the extra character.  */
377
  if (dyn_string_resize (dest, dest->length + 1) == NULL)
378
    return 0;
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.  */
384
  ++(dest->length);
385
  return 1;
386
}
387
 
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.  */
393
 
394
int
395
dyn_string_substring (dest, src, start, end)
396
     dyn_string_t dest;
397
     dyn_string_t src;
398
     int start;
399
     int end;
400
{
401
  int i;
402
  int length = end - start;
403
 
404
  if (start > end || start > src->length || end > src->length)
405
    abort ();
406
 
407
  /* Make room for the substring.  */
408
  if (dyn_string_resize (dest, length) == NULL)
409
    return 0;
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;
417
 
418
  return 1;
419
}
420
 
421
/* Returns non-zero if DS1 and DS2 have the same contents.  */
422
 
423
int
424
dyn_string_eq (ds1, ds2)
425
     dyn_string_t ds1;
426
     dyn_string_t ds2;
427
{
428
  /* If DS1 and DS2 have different lengths, they must not be the same.  */
429
  if (ds1->length != ds2->length)
430
    return 0;
431
  else
432
    return !strcmp (ds1->s, ds2->s);
433
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.