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