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