OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gas/] [sb.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.