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
  37 /* These routines are about manipulating strings.
  38
  39    They are managed in things called `sb's which is an abbreviation
  40    for string buffers.  An sb has to be created, things can be glued
  41    on to it, and at the end of it's life it should be freed.  The
  42    contents should never be pointed at whilst it is still growing,
  43    since it could be moved at any time
  44
  45    eg:
  46    sb_new (&foo);
  47    sb_grow... (&foo,...);
  48    use foo->ptr[*];
  49    sb_kill (&foo);
  50
  51 */
  52
  53 static int dsize = 5;
  54 static void sb_check (sb *, int);
  55
  56 /* Statistics of sb structures.  */
  57 static int string_count[sb_max_power_two];
  58
  59 /* Free list of sb structures.  */
  60 static sb_list_vector free_list;
  61
  62 /* initializes an sb.  */
  63
  64 static void
  65 sb_build (sb *ptr, int size)
  66 {
  67   /* see if we can find one to allocate */
  68   sb_element *e;
  69
  70   if (size > sb_max_power_two)
  71     abort ();
  72
  73   e = free_list.size[size];
  74   if (!e)
  75     {
  76       /* nothing there, allocate one and stick into the free list */
  77       e = (sb_element *) xmalloc (sizeof (sb_element) + (1 << size));
  78       e->next = free_list.size[size];
  79       e->size = 1 << size;
  80       free_list.size[size] = e;
  81       string_count[size]++;
  82     }
  83
  84   /* remove from free list */
  85
  86   free_list.size[size] = e->next;
  87
  88   /* copy into callers world */
  89   ptr->ptr = e->data;
  90   ptr->pot = size;
  91   ptr->len = 0;
  92   ptr->item = e;
  93 }
  94
  95 void
  96 sb_new (sb *ptr)
  97 {
  98   sb_build (ptr, dsize);
  99 }
 100
 101 /* deallocate the sb at ptr */
 102
 103 void
 104 sb_kill (sb *ptr)
 105 {
 106   /* return item to free list */
 107   ptr->item->next = free_list.size[ptr->pot];
 108   free_list.size[ptr->pot] = ptr->item;
 109 }
 110
 111 /* add the sb at s to the end of the sb at ptr */
 112
 113 void
 114 sb_add_sb (sb *ptr, sb *s)
 115 {
 116   sb_check (ptr, s->len);
 117   memcpy (ptr->ptr + ptr->len, s->ptr, s->len);
 118   ptr->len += s->len;
 119 }
 120
 121 /* make sure that the sb at ptr has room for another len characters,
 122    and grow it if it doesn't.  */
 123
 124 static void
 125 sb_check (sb *ptr, int len)
 126 {
 127   if (ptr->len + len >= 1 << ptr->pot)
 128     {
 129       sb tmp;
 130       int pot = ptr->pot;
 131       while (ptr->len + len >= 1 << pot)
 132         pot++;
 133       sb_build (&tmp, pot);
 134       sb_add_sb (&tmp, ptr);
 135       sb_kill (ptr);
 136       *ptr = tmp;
 137     }
 138 }
 139
 140 /* make the sb at ptr point back to the beginning.  */
 141
 142 void
 143 sb_reset (sb *ptr)
 144 {
 145   ptr->len = 0;
 146 }
 147
 148 /* add character c to the end of the sb at ptr.  */
 149
 150 void
 151 sb_add_char (sb *ptr, int c)
 152 {
 153   sb_check (ptr, 1);
 154   ptr->ptr[ptr->len++] = c;
 155 }
 156
 157 /* add null terminated string s to the end of sb at ptr.  */
 158
 159 void
 160 sb_add_string (sb *ptr, const char *s)
 161 {
 162   int len = strlen (s);
 163   sb_check (ptr, len);
 164   memcpy (ptr->ptr + ptr->len, s, len);
 165   ptr->len += len;
 166 }
 167
 168 /* add string at s of length len to sb at ptr */
 169
 170 void
 171 sb_add_buffer (sb *ptr, const char *s, int len)
 172 {
 173   sb_check (ptr, len);
 174   memcpy (ptr->ptr + ptr->len, s, len);
 175   ptr->len += len;
 176 }
 177
 178 /* like sb_name, but don't include the null byte in the string.  */
 179
 180 char *
 181 sb_terminate (sb *in)
 182 {
 183   sb_add_char (in, 0);
 184   --in->len;
 185   return in->ptr;
 186 }
 187
 188 /* start at the index idx into the string in sb at ptr and skip
 189    whitespace. return the index of the first non whitespace character */
 190
 191 int
 192 sb_skip_white (int idx, sb *ptr)
 193 {
 194   while (idx < ptr->len
 195          && (ptr->ptr[idx] == ' '
 196              || ptr->ptr[idx] == '\t'))
 197     idx++;
 198   return idx;
 199 }
 200
 201 /* start at the index idx into the sb at ptr. skips whitespace,
 202    a comma and any following whitespace. returns the index of the
 203    next character.  */
 204
 205 int
 206 sb_skip_comma (int idx, sb *ptr)
 207 {
 208   while (idx < ptr->len
 209          && (ptr->ptr[idx] == ' '
 210              || ptr->ptr[idx] == '\t'))
 211     idx++;
 212
 213   if (idx < ptr->len
 214       && ptr->ptr[idx] == ',')
 215     idx++;
 216
 217   while (idx < ptr->len
 218          && (ptr->ptr[idx] == ' '
 219              || ptr->ptr[idx] == '\t'))
 220     idx++;
 221
 222   return idx;
 223 }