1 /* An abstract string datatype. 2 Copyright (C) 1998, 1999, 2000, 2002, 2004 Free Software Foundation, Inc. 3 Contributed by Mark Mitchell (mark (at) 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 failure, 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 } 398
