dyn-string.c revision 68765
1/* An abstract string datatype. 2 Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. 3 Contributed by Mark Mitchell (mark@markmitchell.com). 4 5This file is part of GNU CC. 6 7GNU CC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, 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 58int 59dyn_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 87dyn_string_t 88dyn_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 110void 111dyn_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 122char* 123dyn_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 143dyn_string_t 144dyn_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 178void 179dyn_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 191int 192dyn_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 213int 214dyn_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 234int 235dyn_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 246int 247dyn_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 259int 260dyn_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 287int 288dyn_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/* Append S to DS, resizing DS if necessary. Returns 1 on success. 309 On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and 310 returns 0. */ 311 312int 313dyn_string_append (dest, s) 314 dyn_string_t dest; 315 dyn_string_t s; 316{ 317 if (dyn_string_resize (dest, dest->length + s->length) == 0) 318 return 0; 319 strcpy (dest->s + dest->length, s->s); 320 dest->length += s->length; 321 return 1; 322} 323 324/* Append the NUL-terminated string S to DS, resizing DS if necessary. 325 Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE, 326 deletes DEST and returns 0. */ 327 328int 329dyn_string_append_cstr (dest, s) 330 dyn_string_t dest; 331 const char *s; 332{ 333 int len = strlen (s); 334 335 /* The new length is the old length plus the size of our string, plus 336 one for the null at the end. */ 337 if (dyn_string_resize (dest, dest->length + len) == NULL) 338 return 0; 339 strcpy (dest->s + dest->length, s); 340 dest->length += len; 341 return 1; 342} 343 344/* Appends C to the end of DEST. Returns 1 on success. On failiure, 345 if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */ 346 347int 348dyn_string_append_char (dest, c) 349 dyn_string_t dest; 350 int c; 351{ 352 /* Make room for the extra character. */ 353 if (dyn_string_resize (dest, dest->length + 1) == NULL) 354 return 0; 355 /* Append the character; it will overwrite the old NUL. */ 356 dest->s[dest->length] = c; 357 /* Add a new NUL at the end. */ 358 dest->s[dest->length + 1] = '\0'; 359 /* Update the length. */ 360 ++(dest->length); 361 return 1; 362} 363 364/* Sets the contents of DEST to the substring of SRC starting at START 365 and ending before END. START must be less than or equal to END, 366 and both must be between zero and the length of SRC, inclusive. 367 Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE, 368 deletes DEST and returns 0. */ 369 370int 371dyn_string_substring (dest, src, start, end) 372 dyn_string_t dest; 373 dyn_string_t src; 374 int start; 375 int end; 376{ 377 int i; 378 int length = end - start; 379 380 if (start > end || start > src->length || end > src->length) 381 abort (); 382 383 /* Make room for the substring. */ 384 if (dyn_string_resize (dest, length) == NULL) 385 return 0; 386 /* Copy the characters in the substring, */ 387 for (i = length; --i >= 0; ) 388 dest->s[i] = src->s[start + i]; 389 /* NUL-terimate the result. */ 390 dest->s[length] = '\0'; 391 /* Record the length of the substring. */ 392 dest->length = length; 393 394 return 1; 395} 396 397/* Returns non-zero if DS1 and DS2 have the same contents. */ 398 399int 400dyn_string_eq (ds1, ds2) 401 dyn_string_t ds1; 402 dyn_string_t ds2; 403{ 404 /* If DS1 and DS2 have different lengths, they must not be the same. */ 405 if (ds1->length != ds2->length) 406 return 0; 407 else 408 return !strcmp (ds1->s, ds2->s); 409} 410