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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [libiberty/] [dyn-string.c] - Blame information for rev 205

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* An abstract string datatype.
2
   Copyright (C) 1998, 1999, 2000, 2002, 2004 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
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
19
executable.)
20
 
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.
25
 
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, 51 Franklin Street - Fifth Floor,
29
Boston, MA 02110-1301, USA.  */
30
 
31
#ifdef HAVE_CONFIG_H
32
#include "config.h"
33
#endif
34
 
35
#include <stdio.h>
36
 
37
#ifdef HAVE_STRING_H
38
#include <string.h>
39
#endif
40
 
41
#ifdef HAVE_STDLIB_H
42
#include <stdlib.h>
43
#endif
44
 
45
#include "libiberty.h"
46
#include "dyn-string.h"
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 (struct dyn_string *ds_struct_ptr, int space)
60
{
61
  /* We need at least one byte in which to store the terminating NUL.  */
62
  if (space == 0)
63
    space = 1;
64
 
65
#ifdef RETURN_ON_ALLOCATION_FAILURE
66
  ds_struct_ptr->s = (char *) malloc (space);
67
  if (ds_struct_ptr->s == NULL)
68
    return 0;
69
#else
70
  ds_struct_ptr->s = XNEWVEC (char, space);
71
#endif
72
  ds_struct_ptr->allocated = space;
73
  ds_struct_ptr->length = 0;
74
  ds_struct_ptr->s[0] = '\0';
75
 
76
  return 1;
77
}
78
 
79
/* Create a new dynamic string capable of holding at least SPACE
80
   characters, including the terminating NUL.  If SPACE is 0, it will
81
   be silently increased to 1.  If RETURN_ON_ALLOCATION_FAILURE is
82
   defined and memory allocation fails, returns NULL.  Otherwise
83
   returns the newly allocated string.  */
84
 
85
dyn_string_t
86
dyn_string_new (int space)
87
{
88
  dyn_string_t result;
89
#ifdef RETURN_ON_ALLOCATION_FAILURE
90
  result = (dyn_string_t) malloc (sizeof (struct dyn_string));
91
  if (result == NULL)
92
    return NULL;
93
  if (!dyn_string_init (result, space))
94
    {
95
      free (result);
96
      return NULL;
97
    }
98
#else
99
  result = XNEW (struct dyn_string);
100
  dyn_string_init (result, space);
101
#endif
102
  return result;
103
}
104
 
105
/* Free the memory used by DS.  */
106
 
107
void
108
dyn_string_delete (dyn_string_t ds)
109
{
110
  free (ds->s);
111
  free (ds);
112
}
113
 
114
/* Returns the contents of DS in a buffer allocated with malloc.  It
115
   is the caller's responsibility to deallocate the buffer using free.
116
   DS is then set to the empty string.  Deletes DS itself.  */
117
 
118
char*
119
dyn_string_release (dyn_string_t ds)
120
{
121
  /* Store the old buffer.  */
122
  char* result = ds->s;
123
  /* The buffer is no longer owned by DS.  */
124
  ds->s = NULL;
125
  /* Delete DS.  */
126
  free (ds);
127
  /* Return the old buffer.  */
128
  return result;
129
}
130
 
131
/* Increase the capacity of DS so it can hold at least SPACE
132
   characters, plus the terminating NUL.  This function will not (at
133
   present) reduce the capacity of DS.  Returns DS on success.
134
 
135
   If RETURN_ON_ALLOCATION_FAILURE is defined and a memory allocation
136
   operation fails, deletes DS and returns NULL.  */
137
 
138
dyn_string_t
139
dyn_string_resize (dyn_string_t ds, int space)
140
{
141
  int new_allocated = ds->allocated;
142
 
143
  /* Increase SPACE to hold the NUL termination.  */
144
  ++space;
145
 
146
  /* Increase allocation by factors of two.  */
147
  while (space > new_allocated)
148
    new_allocated *= 2;
149
 
150
  if (new_allocated != ds->allocated)
151
    {
152
      ds->allocated = new_allocated;
153
      /* We actually need more space.  */
154
#ifdef RETURN_ON_ALLOCATION_FAILURE
155
      ds->s = (char *) realloc (ds->s, ds->allocated);
156
      if (ds->s == NULL)
157
        {
158
          free (ds);
159
          return NULL;
160
        }
161
#else
162
      ds->s = XRESIZEVEC (char, ds->s, ds->allocated);
163
#endif
164
    }
165
 
166
  return ds;
167
}
168
 
169
/* Sets the contents of DS to the empty string.  */
170
 
171
void
172
dyn_string_clear (dyn_string_t ds)
173
{
174
  /* A dyn_string always has room for at least the NUL terminator.  */
175
  ds->s[0] = '\0';
176
  ds->length = 0;
177
}
178
 
179
/* Makes the contents of DEST the same as the contents of SRC.  DEST
180
   and SRC must be distinct.  Returns 1 on success.  On failure, if
181
   RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
182
 
183
int
184
dyn_string_copy (dyn_string_t dest, dyn_string_t src)
185
{
186
  if (dest == src)
187
    abort ();
188
 
189
  /* Make room in DEST.  */
190
  if (dyn_string_resize (dest, src->length) == NULL)
191
    return 0;
192
  /* Copy DEST into SRC.  */
193
  strcpy (dest->s, src->s);
194
  /* Update the size of DEST.  */
195
  dest->length = src->length;
196
  return 1;
197
}
198
 
199
/* Copies SRC, a NUL-terminated string, into DEST.  Returns 1 on
200
   success.  On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
201
   and returns 0.  */
202
 
203
int
204
dyn_string_copy_cstr (dyn_string_t dest, const char *src)
205
{
206
  int length = strlen (src);
207
  /* Make room in DEST.  */
208
  if (dyn_string_resize (dest, length) == NULL)
209
    return 0;
210
  /* Copy DEST into SRC.  */
211
  strcpy (dest->s, src);
212
  /* Update the size of DEST.  */
213
  dest->length = length;
214
  return 1;
215
}
216
 
217
/* Inserts SRC at the beginning of DEST.  DEST is expanded as
218
   necessary.  SRC and DEST must be distinct.  Returns 1 on success.
219
   On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
220
   returns 0.  */
221
 
222
int
223
dyn_string_prepend (dyn_string_t dest, dyn_string_t src)
224
{
225
  return dyn_string_insert (dest, 0, src);
226
}
227
 
228
/* Inserts SRC, a NUL-terminated string, at the beginning of DEST.
229
   DEST is expanded as necessary.  Returns 1 on success.  On failure,
230
   if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
231
 
232
int
233
dyn_string_prepend_cstr (dyn_string_t dest, const char *src)
234
{
235
  return dyn_string_insert_cstr (dest, 0, src);
236
}
237
 
238
/* Inserts SRC into DEST starting at position POS.  DEST is expanded
239
   as necessary.  SRC and DEST must be distinct.  Returns 1 on
240
   success.  On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
241
   and returns 0.  */
242
 
243
int
244
dyn_string_insert (dyn_string_t dest, int pos, dyn_string_t src)
245
{
246
  int i;
247
 
248
  if (src == dest)
249
    abort ();
250
 
251
  if (dyn_string_resize (dest, dest->length + src->length) == NULL)
252
    return 0;
253
  /* Make room for the insertion.  Be sure to copy the NUL.  */
254
  for (i = dest->length; i >= pos; --i)
255
    dest->s[i + src->length] = dest->s[i];
256
  /* Splice in the new stuff.  */
257
  strncpy (dest->s + pos, src->s, src->length);
258
  /* Compute the new length.  */
259
  dest->length += src->length;
260
  return 1;
261
}
262
 
263
/* Inserts SRC, a NUL-terminated string, into DEST starting at
264
   position POS.  DEST is expanded as necessary.  Returns 1 on
265
   success.  On failure, RETURN_ON_ALLOCATION_FAILURE, deletes DEST
266
   and returns 0.  */
267
 
268
int
269
dyn_string_insert_cstr (dyn_string_t dest, int pos, const char *src)
270
{
271
  int i;
272
  int length = strlen (src);
273
 
274
  if (dyn_string_resize (dest, dest->length + length) == NULL)
275
    return 0;
276
  /* Make room for the insertion.  Be sure to copy the NUL.  */
277
  for (i = dest->length; i >= pos; --i)
278
    dest->s[i + length] = dest->s[i];
279
  /* Splice in the new stuff.  */
280
  strncpy (dest->s + pos, src, length);
281
  /* Compute the new length.  */
282
  dest->length += length;
283
  return 1;
284
}
285
 
286
/* Inserts character C into DEST starting at position POS.  DEST is
287
   expanded as necessary.  Returns 1 on success.  On failure,
288
   RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
289
 
290
int
291
dyn_string_insert_char (dyn_string_t dest, int pos, int c)
292
{
293
  int i;
294
 
295
  if (dyn_string_resize (dest, dest->length + 1) == NULL)
296
    return 0;
297
  /* Make room for the insertion.  Be sure to copy the NUL.  */
298
  for (i = dest->length; i >= pos; --i)
299
    dest->s[i + 1] = dest->s[i];
300
  /* Add the new character.  */
301
  dest->s[pos] = c;
302
  /* Compute the new length.  */
303
  ++dest->length;
304
  return 1;
305
}
306
 
307
/* Append S to DS, resizing DS if necessary.  Returns 1 on success.
308
   On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
309
   returns 0.  */
310
 
311
int
312
dyn_string_append (dyn_string_t dest, dyn_string_t s)
313
{
314
  if (dyn_string_resize (dest, dest->length + s->length) == 0)
315
    return 0;
316
  strcpy (dest->s + dest->length, s->s);
317
  dest->length += s->length;
318
  return 1;
319
}
320
 
321
/* Append the NUL-terminated string S to DS, resizing DS if necessary.
322
   Returns 1 on success.  On failure, if RETURN_ON_ALLOCATION_FAILURE,
323
   deletes DEST and returns 0.  */
324
 
325
int
326
dyn_string_append_cstr (dyn_string_t dest, const char *s)
327
{
328
  int len = strlen (s);
329
 
330
  /* The new length is the old length plus the size of our string, plus
331
     one for the null at the end.  */
332
  if (dyn_string_resize (dest, dest->length + len) == NULL)
333
    return 0;
334
  strcpy (dest->s + dest->length, s);
335
  dest->length += len;
336
  return 1;
337
}
338
 
339
/* Appends C to the end of DEST.  Returns 1 on success.  On failiure,
340
   if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
341
 
342
int
343
dyn_string_append_char (dyn_string_t dest, int c)
344
{
345
  /* Make room for the extra character.  */
346
  if (dyn_string_resize (dest, dest->length + 1) == NULL)
347
    return 0;
348
  /* Append the character; it will overwrite the old NUL.  */
349
  dest->s[dest->length] = c;
350
  /* Add a new NUL at the end.  */
351
  dest->s[dest->length + 1] = '\0';
352
  /* Update the length.  */
353
  ++(dest->length);
354
  return 1;
355
}
356
 
357
/* Sets the contents of DEST to the substring of SRC starting at START
358
   and ending before END.  START must be less than or equal to END,
359
   and both must be between zero and the length of SRC, inclusive.
360
   Returns 1 on success.  On failure, if RETURN_ON_ALLOCATION_FAILURE,
361
   deletes DEST and returns 0.  */
362
 
363
int
364
dyn_string_substring (dyn_string_t dest, dyn_string_t src,
365
                      int start, int end)
366
{
367
  int i;
368
  int length = end - start;
369
 
370
  if (start > end || start > src->length || end > src->length)
371
    abort ();
372
 
373
  /* Make room for the substring.  */
374
  if (dyn_string_resize (dest, length) == NULL)
375
    return 0;
376
  /* Copy the characters in the substring,  */
377
  for (i = length; --i >= 0; )
378
    dest->s[i] = src->s[start + i];
379
  /* NUL-terimate the result.  */
380
  dest->s[length] = '\0';
381
  /* Record the length of the substring.  */
382
  dest->length = length;
383
 
384
  return 1;
385
}
386
 
387
/* Returns non-zero if DS1 and DS2 have the same contents.  */
388
 
389
int
390
dyn_string_eq (dyn_string_t ds1, dyn_string_t ds2)
391
{
392
  /* If DS1 and DS2 have different lengths, they must not be the same.  */
393
  if (ds1->length != ds2->length)
394
    return 0;
395
  else
396
    return !strcmp (ds1->s, ds2->s);
397
}

powered by: WebSVN 2.1.0

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