1 /* sb.c - string buffer manipulation routines 2 Copyright 1994, 1995, 2000, 2003 Free Software Foundation, Inc. 3 4 Written by Steve and Judy Chamberlain of Cygnus Support, 5 sac@cygnus.com 6 7 This file is part of GAS, the GNU Assembler. 8 9 GAS is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2, or (at your option) 12 any later version. 13 14 GAS is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GAS; see the file COPYING. If not, write to the Free 21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 22 02110-1301, USA. */ 23 24 #include "config.h" 25 #include <stdio.h> 26 #ifdef HAVE_STDLIB_H 27 #include <stdlib.h> 28 #endif 29 #ifdef HAVE_STRING_H 30 #include <string.h> 31 #else 32 #include <strings.h> 33 #endif 34 #include "libiberty.h" 35 #include "sb.h" 36 #include "as.h" 37 38 /* These routines are about manipulating strings. 39 40 They are managed in things called `sb's which is an abbreviation 41 for string buffers. An sb has to be created, things can be glued 42 on to it, and at the end of it's life it should be freed. The 43 contents should never be pointed at whilst it is still growing, 44 since it could be moved at any time 45 46 eg: 47 sb_new (&foo); 48 sb_grow... (&foo,...); 49 use foo->ptr[*]; 50 sb_kill (&foo); */ 51 52 static int dsize = 5; 53 static void sb_check (sb *, int); 54 55 /* Statistics of sb structures. */ 56 static int string_count[sb_max_power_two]; 57 58 /* Free list of sb structures. */ 59 static sb_list_vector free_list; 60 61 /* Initializes an sb. */ 62 63 static void 64 sb_build (sb *ptr, int size) 65 { 66 /* See if we can find one to allocate. */ 67 sb_element *e; 68 69 if (size > sb_max_power_two) 70 abort (); 71 72 e = free_list.size[size]; 73 if (!e) 74 { 75 /* Nothing there, allocate one and stick into the free list. */ 76 e = (sb_element *) xmalloc (sizeof (sb_element) + (1 << size)); 77 e->next = free_list.size[size]; 78 e->size = 1 << size; 79 free_list.size[size] = e; 80 string_count[size]++; 81 } 82 83 /* Remove from free list. */ 84 free_list.size[size] = e->next; 85 86 /* Copy into callers world. */ 87 ptr->ptr = e->data; 88 ptr->pot = size; 89 ptr->len = 0; 90 ptr->item = e; 91 } 92 93 void 94 sb_new (sb *ptr) 95 { 96 sb_build (ptr, dsize); 97 } 98 99 /* Deallocate the sb at ptr. */ 100 101 void 102 sb_kill (sb *ptr) 103 { 104 /* Return item to free list. */ 105 ptr->item->next = free_list.size[ptr->pot]; 106 free_list.size[ptr->pot] = ptr->item; 107 } 108 109 /* Add the sb at s to the end of the sb at ptr. */ 110 111 void 112 sb_add_sb (sb *ptr, sb *s) 113 { 114 sb_check (ptr, s->len); 115 memcpy (ptr->ptr + ptr->len, s->ptr, s->len); 116 ptr->len += s->len; 117 } 118 119 /* Helper for sb_scrub_and_add_sb. */ 120 121 static sb *sb_to_scrub; 122 static char *scrub_position; 123 static int 124 scrub_from_sb (char *buf, int buflen) 125 { 126 int copy; 127 copy = sb_to_scrub->len - (scrub_position - sb_to_scrub->ptr); 128 if (copy > buflen) 129 copy = buflen; 130 memcpy (buf, scrub_position, copy); 131 scrub_position += copy; 132 return copy; 133 } 134 135 /* Run the sb at s through do_scrub_chars and add the result to the sb 136 at ptr. */ 137 138 void 139 sb_scrub_and_add_sb (sb *ptr, sb *s) 140 { 141 sb_to_scrub = s; 142 scrub_position = s->ptr; 143 144 sb_check (ptr, s->len); 145 ptr->len += do_scrub_chars (scrub_from_sb, ptr->ptr + ptr->len, s->len); 146 147 sb_to_scrub = 0; 148 scrub_position = 0; 149 } 150 151 /* Make sure that the sb at ptr has room for another len characters, 152 and grow it if it doesn't. */ 153 154 static void 155 sb_check (sb *ptr, int len) 156 { 157 if (ptr->len + len >= 1 << ptr->pot) 158 { 159 sb tmp; 160 int pot = ptr->pot; 161 162 while (ptr->len + len >= 1 << pot) 163 pot++; 164 sb_build (&tmp, pot); 165 sb_add_sb (&tmp, ptr); 166 sb_kill (ptr); 167 *ptr = tmp; 168 } 169 } 170 171 /* Make the sb at ptr point back to the beginning. */ 172 173 void 174 sb_reset (sb *ptr) 175 { 176 ptr->len = 0; 177 } 178 179 /* Add character c to the end of the sb at ptr. */ 180 181 void 182 sb_add_char (sb *ptr, int c) 183 { 184 sb_check (ptr, 1); 185 ptr->ptr[ptr->len++] = c; 186 } 187 188 /* Add null terminated string s to the end of sb at ptr. */ 189 190 void 191 sb_add_string (sb *ptr, const char *s) 192 { 193 int len = strlen (s); 194 sb_check (ptr, len); 195 memcpy (ptr->ptr + ptr->len, s, len); 196 ptr->len += len; 197 } 198 199 /* Add string at s of length len to sb at ptr */ 200 201 void 202 sb_add_buffer (sb *ptr, const char *s, int len) 203 { 204 sb_check (ptr, len); 205 memcpy (ptr->ptr + ptr->len, s, len); 206 ptr->len += len; 207 } 208 209 /* Like sb_name, but don't include the null byte in the string. */ 210 211 char * 212 sb_terminate (sb *in) 213 { 214 sb_add_char (in, 0); 215 --in->len; 216 return in->ptr; 217 } 218 219 /* Start at the index idx into the string in sb at ptr and skip 220 whitespace. return the index of the first non whitespace character. */ 221 222 int 223 sb_skip_white (int idx, sb *ptr) 224 { 225 while (idx < ptr->len 226 && (ptr->ptr[idx] == ' ' 227 || ptr->ptr[idx] == '\t')) 228 idx++; 229 return idx; 230 } 231 232 /* Start at the index idx into the sb at ptr. skips whitespace, 233 a comma and any following whitespace. returns the index of the 234 next character. */ 235 236 int 237 sb_skip_comma (int idx, sb *ptr) 238 { 239 while (idx < ptr->len 240 && (ptr->ptr[idx] == ' ' 241 || ptr->ptr[idx] == '\t')) 242 idx++; 243 244 if (idx < ptr->len 245 && ptr->ptr[idx] == ',') 246 idx++; 247 248 while (idx < ptr->len 249 && (ptr->ptr[idx] == ' ' 250 || ptr->ptr[idx] == '\t')) 251 idx++; 252 253 return idx; 254 } 255