diff options
Diffstat (limited to 'binutils-2.25/gas/sb.c')
-rw-r--r-- | binutils-2.25/gas/sb.c | 237 |
1 files changed, 237 insertions, 0 deletions
diff --git a/binutils-2.25/gas/sb.c b/binutils-2.25/gas/sb.c new file mode 100644 index 00000000..7710cbc0 --- /dev/null +++ b/binutils-2.25/gas/sb.c @@ -0,0 +1,237 @@ +/* sb.c - string buffer manipulation routines + Copyright 1994, 1995, 2000, 2003, 2005, 2006, 2007, 2009, 2012 + Free Software Foundation, Inc. + + Written by Steve and Judy Chamberlain of Cygnus Support, + sac@cygnus.com + + This file is part of GAS, the GNU Assembler. + + GAS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GAS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GAS; see the file COPYING. If not, write to the Free + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ + +#include "as.h" +#include "sb.h" + +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +/* These routines are about manipulating strings. + + They are managed in things called `sb's which is an abbreviation + for string buffers. An sb has to be created, things can be glued + on to it, and at the end of it's life it should be freed. The + contents should never be pointed at whilst it is still growing, + since it could be moved at any time + + eg: + sb_new (&foo); + sb_grow... (&foo,...); + use foo->ptr[*]; + sb_kill (&foo); */ + +/* Buffers start at INIT_ALLOC size, and roughly double each time we + go over the current allocation. MALLOC_OVERHEAD is a guess at the + system malloc overhead. We aim to not waste any memory in the + underlying page/chunk allocated by the system malloc. */ +#define MALLOC_OVERHEAD (2 * sizeof (size_t)) +#define INIT_ALLOC (64 - MALLOC_OVERHEAD - 1) + +static void sb_check (sb *, size_t); + +/* Initializes an sb. */ + +void +sb_build (sb *ptr, size_t size) +{ + ptr->ptr = xmalloc (size + 1); + ptr->max = size; + ptr->len = 0; +} + +void +sb_new (sb *ptr) +{ + sb_build (ptr, INIT_ALLOC); +} + +/* Deallocate the sb at ptr. */ + +void +sb_kill (sb *ptr) +{ + free (ptr->ptr); +} + +/* Add the sb at s to the end of the sb at ptr. */ + +void +sb_add_sb (sb *ptr, sb *s) +{ + sb_check (ptr, s->len); + memcpy (ptr->ptr + ptr->len, s->ptr, s->len); + ptr->len += s->len; +} + +/* Helper for sb_scrub_and_add_sb. */ + +static sb *sb_to_scrub; +static char *scrub_position; +static size_t +scrub_from_sb (char *buf, size_t buflen) +{ + size_t copy; + copy = sb_to_scrub->len - (scrub_position - sb_to_scrub->ptr); + if (copy > buflen) + copy = buflen; + memcpy (buf, scrub_position, copy); + scrub_position += copy; + return copy; +} + +/* Run the sb at s through do_scrub_chars and add the result to the sb + at ptr. */ + +void +sb_scrub_and_add_sb (sb *ptr, sb *s) +{ + sb_to_scrub = s; + scrub_position = s->ptr; + + sb_check (ptr, s->len); + ptr->len += do_scrub_chars (scrub_from_sb, ptr->ptr + ptr->len, s->len); + + sb_to_scrub = 0; + scrub_position = 0; +} + +/* Make sure that the sb at ptr has room for another len characters, + and grow it if it doesn't. */ + +static void +sb_check (sb *ptr, size_t len) +{ + size_t want = ptr->len + len; + + if (want > ptr->max) + { + size_t max; + + want += MALLOC_OVERHEAD + 1; + if ((ssize_t) want < 0) + as_fatal ("string buffer overflow"); +#if GCC_VERSION >= 3004 + max = (size_t) 1 << (CHAR_BIT * sizeof (want) + - (sizeof (want) <= sizeof (long) + ? __builtin_clzl ((long) want) + : __builtin_clzll ((long long) want))); +#else + max = 128; + while (want > max) + max <<= 1; +#endif + max -= MALLOC_OVERHEAD + 1; + ptr->max = max; + ptr->ptr = xrealloc (ptr->ptr, max + 1); + } +} + +/* Make the sb at ptr point back to the beginning. */ + +void +sb_reset (sb *ptr) +{ + ptr->len = 0; +} + +/* Add character c to the end of the sb at ptr. */ + +void +sb_add_char (sb *ptr, size_t c) +{ + sb_check (ptr, 1); + ptr->ptr[ptr->len++] = c; +} + +/* Add null terminated string s to the end of sb at ptr. */ + +void +sb_add_string (sb *ptr, const char *s) +{ + size_t len = strlen (s); + sb_check (ptr, len); + memcpy (ptr->ptr + ptr->len, s, len); + ptr->len += len; +} + +/* Add string at s of length len to sb at ptr */ + +void +sb_add_buffer (sb *ptr, const char *s, size_t len) +{ + sb_check (ptr, len); + memcpy (ptr->ptr + ptr->len, s, len); + ptr->len += len; +} + +/* Write terminating NUL and return string. */ + +char * +sb_terminate (sb *in) +{ + in->ptr[in->len] = 0; + return in->ptr; +} + +/* Start at the index idx into the string in sb at ptr and skip + whitespace. return the index of the first non whitespace character. */ + +size_t +sb_skip_white (size_t idx, sb *ptr) +{ + while (idx < ptr->len + && (ptr->ptr[idx] == ' ' + || ptr->ptr[idx] == '\t')) + idx++; + return idx; +} + +/* Start at the index idx into the sb at ptr. skips whitespace, + a comma and any following whitespace. returns the index of the + next character. */ + +size_t +sb_skip_comma (size_t idx, sb *ptr) +{ + while (idx < ptr->len + && (ptr->ptr[idx] == ' ' + || ptr->ptr[idx] == '\t')) + idx++; + + if (idx < ptr->len + && ptr->ptr[idx] == ',') + idx++; + + while (idx < ptr->len + && (ptr->ptr[idx] == ' ' + || ptr->ptr[idx] == '\t')) + idx++; + + return idx; +} |