contrib/binutils-2.17/gas/sb.c

   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 }