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