sb_new (&foo);
sb_grow... (&foo,...);
use foo->ptr[*];
- sb_kill (&foo);
-
-*/
+ sb_kill (&foo); */
static int dsize = 5;
static void sb_check (sb *, int);
/* Free list of sb structures. */
static sb_list_vector free_list;
-/* initializes an sb. */
+/* Initializes an sb. */
static void
sb_build (sb *ptr, int size)
{
- /* see if we can find one to allocate */
+ /* See if we can find one to allocate. */
sb_element *e;
if (size > sb_max_power_two)
e = free_list.size[size];
if (!e)
{
- /* nothing there, allocate one and stick into the free list */
+ /* Nothing there, allocate one and stick into the free list. */
e = (sb_element *) xmalloc (sizeof (sb_element) + (1 << size));
e->next = free_list.size[size];
e->size = 1 << size;
string_count[size]++;
}
- /* remove from free list */
-
+ /* Remove from free list. */
free_list.size[size] = e->next;
- /* copy into callers world */
+ /* Copy into callers world. */
ptr->ptr = e->data;
ptr->pot = size;
ptr->len = 0;
sb_build (ptr, dsize);
}
-/* deallocate the sb at ptr */
+/* Deallocate the sb at ptr. */
void
sb_kill (sb *ptr)
{
- /* return item to free list */
+ /* Return item to free list. */
ptr->item->next = free_list.size[ptr->pot];
free_list.size[ptr->pot] = ptr->item;
}
-/* add the sb at s to the end of the sb at ptr */
+/* Add the sb at s to the end of the sb at ptr. */
void
sb_add_sb (sb *ptr, sb *s)
ptr->len += s->len;
}
-/* make sure that the sb at ptr has room for another len characters,
+/* Make sure that the sb at ptr has room for another len characters,
and grow it if it doesn't. */
static void
{
sb tmp;
int pot = ptr->pot;
+
while (ptr->len + len >= 1 << pot)
pot++;
sb_build (&tmp, pot);
}
}
-/* make the sb at ptr point back to the beginning. */
+/* 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. */
+/* Add character c to the end of the sb at ptr. */
void
sb_add_char (sb *ptr, int c)
ptr->ptr[ptr->len++] = c;
}
-/* add null terminated string s to the end of sb at ptr. */
+/* Add null terminated string s to the end of sb at ptr. */
void
sb_add_string (sb *ptr, const char *s)
ptr->len += len;
}
-/* add string at s of length len to sb at ptr */
+/* Add string at s of length len to sb at ptr */
void
sb_add_buffer (sb *ptr, const char *s, int len)
ptr->len += len;
}
-/* like sb_name, but don't include the null byte in the string. */
+/* Like sb_name, but don't include the null byte in the string. */
char *
sb_terminate (sb *in)
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 */
+/* Start at the index idx into the string in sb at ptr and skip
+ whitespace. return the index of the first non whitespace character. */
int
sb_skip_white (int idx, sb *ptr)
return idx;
}
-/* start at the index idx into the sb at ptr. skips whitespace,
+/* 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. */
#include <stdio.h>
#include "ansidecl.h"
-/* string blocks
+/* String blocks
I had a couple of choices when deciding upon this data structure.
gas uses null terminated strings for all its internal work. This
An sb is allocated by the caller, and is initialized to point to an
sb_element. sb_elements are kept on a free lists, and used when
- needed, replaced onto the free list when unused.
- */
+ needed, replaced onto the free list when unused. */
+
+#define sb_max_power_two 30 /* Don't allow strings more than
+ 2^sb_max_power_two long. */
-#define sb_max_power_two 30 /* don't allow strings more than
- 2^sb_max_power_two long */
-/* structure of an sb */
typedef struct sb
- {
- char *ptr; /* points to the current block. */
- int len; /* how much is used. */
- int pot; /* the maximum length is 1<<pot */
- struct le *item;
- }
+{
+ char *ptr; /* Points to the current block. */
+ int len; /* How much is used. */
+ int pot; /* The maximum length is 1<<pot. */
+ struct le *item;
+}
sb;
-/* Structure of the free list object of an sb */
+/* Structure of the free list object of a string block. */
+
typedef struct le
- {
- struct le *next;
- int size;
- char data[1];
- }
+{
+ struct le *next;
+ int size;
+ char data[1];
+}
sb_element;
-/* The free list */
+/* The free list. */
+
typedef struct
- {
- sb_element *size[sb_max_power_two];
- } sb_list_vector;
+{
+ sb_element *size[sb_max_power_two];
+}
+sb_list_vector;
extern void sb_new (sb *);
extern void sb_kill (sb *);
projects / platform / upstream / binutils.git / commitdiff