mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2024-12-03 01:10:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

in include/ChangeLog:

Browse Source 
* dyn-string.h (dyn_string_init, dyn_string_new,
	dyn_string_delete, dyn_string_release, dyn_string_resize,
	dyn_string_clear, dyn_string_copy, dyn_string_copy_cstr,
	dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
	dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
	dyn_string_append_char, dyn_string_substring_dyn_string_eq):
	Define as same name with __cxa_ prepended, if IN_LIBGCC2.
	(dyn_string_init, dyn_string_copy, dyn_string_copy_cstr,
	dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
	dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
	dyn_string_append_char, dyn_string_substring): Change return type
	to int.

in libiberty/ChangeLog:

	* cp-demangle.c: Don't include ctype.h.
	(IS_DIGIT): New macro.
	(IS_ALPHA): Likewise.  Use IS_DIGIT and IS_ALPHA throughout
	instead of isdigit and isalpanum.
	(demangling_def): Make name and next const pointers.
	(STATUS_ALLOCATION_FAILED): New status code.
	(dyn_string_append_space): Handle failure in
	dyn_string_append_char.
	(int_to_dyn_string): Likewise.  Change return value to status_t.
	(string_list_new): Handle failure of dyn_string_init.
	(result_close_template_list): Change return type to status_t.
	Handle failure in dyn_string_append.
	(result_push): Change return value to status_t.  Handle failure in
	string_list_new.  Handle failure of result_push throughout.
	(substitution_add): Change return value to status_t.  Handle
	dyn_string failures.  Handle failure of substitution_add
	throughout.
	(template_arg_list_new): Return NULL on allocation failure.
	(result_append_string): Return STATUS_ALLOCATION_FAILED on error.
	Handle error result throughout.
	(result_append): Likewise.
	(result_append_char): Likewise.
	(result_append_space): Likewise.
	(demangling_new): Make argument a const pointer.  Handle
	allocation failures.
	(demangle_template_args): Handle failure in template_arg_list_new
	and result_close_template_list.
	(demangle_discriminator): Return if int_to_dyn_string fails.
	(cp_demangle): Likewise.
	(cp_demangle_type): New function.
	(cplus_demangle_new_abi): Don't call dyn_string_delete.  Abort on
	memory allocation failure.
	(main): Likewise.
	* dyn-string.c (RETURN_ON_ALLOCATION_FAILURE): Define if
	IN_LIBGCC2.
	(dyn_string_init): Change return value to int.  Handle
	RETURN_ON_ALLOCATION_FAILURE case.
	(dyn_string_new): Handle RETURN_ON_ALLOCATION_FAILURE case.
	(dyn_string_release): Delete the dyn_string.
	(dyn_string_resize): Handle RETURN_ON_ALLOCATION_FAILURE case.
	(dyn_string_copy): Change return type to int.
	(dyn_string_copy_cstr): Likewise.
	(dyn_string_prepend): Likewise.
	(dyn_string_prepend_cstr): Likewise.
	(dyn_string_insert): Likewise.
	(dyn_string_insert_cstr): Likewise.
	(dyn_string_append): Likewise.
	(dyn_string_append_cstr): Likewise.
	(dyn_string_append_char): Likewise.
	(dyn_string_substring): Likewise.

in gcc/cp/ChangeLog:

	* Make-lang.in (CXX_LIB2FUNCS): Add cp-demangle.o and dyn-string.o.
	(CXX_LIB2SRCS): Add cp-demangle.c and dyn-string.c.
	(cp-demangle.o): New rule.
	(dyn-string.o): Likewise.
	* inc/cxxabi.h (__cxa_demangle): New declaration.

From-SVN: r34657
This commit is contained in:
Alex Samuel 2000-06-23 03:58:44 +00:00 committed by Alex Samuel
parent 31f8e4f306
commit 051664b069
8 changed files with 895 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gcc/cp/ChangeLog
View File

@ -1,3 +1,11 @@
2000-06-21 Alex Samuel <samuel@codesourcery.com>
* Make-lang.in (CXX_LIB2FUNCS): Add cp-demangle.o and dyn-string.o.
(CXX_LIB2SRCS): Add cp-demangle.c and dyn-string.c.
(cp-demangle.o): New rule.
(dyn-string.o): Likewise.
* inc/cxxabi.h (__cxa_demangle): New declaration.
2000-06-22 Mark Mitchell <mark@codesourcery.com>
* cp-tree.h (BV_USE_VCALL_INDEX_P): New macro.

15
gcc/cp/Make-lang.in
View File

@ -62,10 +62,13 @@ CXX_EXTRA_HEADERS = $(srcdir)/cp/inc/typeinfo $(srcdir)/cp/inc/exception \
# Extra code to include in libgcc2.
CXX_LIB2FUNCS = tinfo.o tinfo2.o new.o opnew.o opnewnt.o opvnew.o opvnewnt.o \
opdel.o opdelnt.o opvdel.o opvdelnt.o exception.o vec.o
opdel.o opdelnt.o opvdel.o opvdelnt.o exception.o vec.o \
cp-demangle.o dyn-string.o
CXX_LIB2SRCS = $(srcdir)/cp/new.cc $(srcdir)/cp/new1.cc $(srcdir)/cp/new2.cc \
$(srcdir)/cp/exception.cc $(srcdir)/cp/tinfo.cc \
$(srcdir)/cp/tinfo2.cc $(srcdir)/cp/tinfo.h
$(srcdir)/cp/tinfo2.cc $(srcdir)/cp/tinfo.h \
$(srcdir)/../libiberty/cp-demangle.c \
$(srcdir)/../libiberty/dyn-string.c
#
# Define the names for selecting c++ in LANGUAGES.
# Note that it would be nice to move the dependency on g++
@ -178,6 +181,14 @@ opvdelnt.o: cc1plus$(exeext) $(srcdir)/cp/new2.cc
vec.o: cc1plus$(exeext) $(srcdir)/cp/vec.cc
$(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(GXX_ABI_FLAG) $(CXXFLAGS) $(INCLUDES) \
-c $(srcdir)/cp/vec.cc -o vec.o
cp-demangle.o: $(srcdir)/../libiberty/cp-demangle.c
$(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(CFLAGS) $(INCLUDES) \
-DHAVE_CONFIG_H \
-c $(srcdir)/../libiberty/cp-demangle.c -o cp-demangle.o
dyn-string.o: $(srcdir)/../libiberty/dyn-string.c
$(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(CFLAGS) $(INCLUDES) \
-DHAVE_CONFIG_H \
-c $(srcdir)/../libiberty/dyn-string.c -o dyn-string.o
# We want to update cplib2.txt if any of the source files change...
cplib2.txt: $(CXX_LIB2SRCS) $(CXX_EXTRA_HEADERS)

8
gcc/cp/inc/cxxabi.h
View File

@ -459,6 +459,14 @@ void __cxa_vec_delete (void *__array_address,
__SIZE_TYPE__ __padding_size,
void (*__destructor) (void *));
/* demangling routines */
extern "C"
char *__cxa_demangle (const char *__mangled_name,
char *__output_buffer,
__SIZE_TYPE__ *__length,
int *__status);
} /* namespace __cxxabiv1 */
/* User programs should use the alias `abi'. */

15
include/ChangeLog
View File

@ -1,3 +1,18 @@
2000-06-21 Alex Samuel <samuel@codesourcery.com>
* dyn-string.h (dyn_string_init, dyn_string_new,
dyn_string_delete, dyn_string_release, dyn_string_resize,
dyn_string_clear, dyn_string_copy, dyn_string_copy_cstr,
dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
dyn_string_append_char, dyn_string_substring_dyn_string_eq):
Define as same name with __cxa_ prepended, if IN_LIBGCC2.
(dyn_string_init, dyn_string_copy, dyn_string_copy_cstr,
dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
dyn_string_append_char, dyn_string_substring): Change return type
to int.
2000-06-07 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* demangle.h (demangling_styles): Remove trailing comma in enum.

50
include/dyn-string.h
View File

@ -40,25 +40,53 @@ typedef struct dyn_string
(strcmp ((DS1)->s, (DS2)->s))
extern void dyn_string_init PARAMS ((struct dyn_string *, int));
/* dyn_string functions are used in the demangling implementation
included in the G++ runtime library. To prevent collisions with
names in user programs, the functions that are used in the
demangler are given implementation-reserved names. */
#ifdef IN_LIBGCC2
#define dyn_string_init __cxa_dyn_string_init
#define dyn_string_new __cxa_dyn_string_new
#define dyn_string_delete __cxa_dyn_string_delete
#define dyn_string_release __cxa_dyn_string_release
#define dyn_string_resize __cxa_dyn_string_resize
#define dyn_string_clear __cxa_dyn_string_clear
#define dyn_string_copy __cxa_dyn_string_copy
#define dyn_string_copy_cstr __cxa_dyn_string_copy_cstr
#define dyn_string_prepend __cxa_dyn_string_prepend
#define dyn_string_prepend_cstr __cxa_dyn_string_prepend_cstr
#define dyn_string_insert __cxa_dyn_string_insert
#define dyn_string_insert_cstr __cxa_dyn_string_insert_cstr
#define dyn_string_append __cxa_dyn_string_append
#define dyn_string_append_cstr __cxa_dyn_string_append_cstr
#define dyn_string_append_char __cxa_dyn_string_append_char
#define dyn_string_substring __cxa_dyn_string_substring
#define dyn_string_eq __cxa_dyn_string_eq
#endif /* IN_LIBGCC2 */
extern int dyn_string_init PARAMS ((struct dyn_string *, int));
extern dyn_string_t dyn_string_new PARAMS ((int));
extern void dyn_string_delete PARAMS ((dyn_string_t));
extern char *dyn_string_release PARAMS ((dyn_string_t));
extern dyn_string_t dyn_string_resize PARAMS ((dyn_string_t, int));
extern void dyn_string_clear PARAMS ((dyn_string_t));
extern void dyn_string_copy PARAMS ((dyn_string_t, dyn_string_t));
extern void dyn_string_copy_cstr PARAMS ((dyn_string_t, const char *));
extern void dyn_string_prepend PARAMS ((dyn_string_t, dyn_string_t));
extern void dyn_string_prepend_cstr PARAMS ((dyn_string_t, const char *));
extern void dyn_string_insert PARAMS ((dyn_string_t, int,
extern int dyn_string_copy PARAMS ((dyn_string_t, dyn_string_t));
extern int dyn_string_copy_cstr PARAMS ((dyn_string_t, const char *));
extern int dyn_string_prepend PARAMS ((dyn_string_t, dyn_string_t));
extern int dyn_string_prepend_cstr PARAMS ((dyn_string_t, const char *));
extern int dyn_string_insert PARAMS ((dyn_string_t, int,
dyn_string_t));
extern void dyn_string_insert_cstr PARAMS ((dyn_string_t, int,
extern int dyn_string_insert_cstr PARAMS ((dyn_string_t, int,
const char *));
extern dyn_string_t dyn_string_append PARAMS ((dyn_string_t, dyn_string_t));
extern dyn_string_t dyn_string_append_cstr
extern int dyn_string_append PARAMS ((dyn_string_t, dyn_string_t));
extern int dyn_string_append_cstr
PARAMS ((dyn_string_t, const char *));
extern dyn_string_t dyn_string_append_char
extern int dyn_string_append_char
PARAMS ((dyn_string_t, int));
extern void dyn_string_substring PARAMS ((dyn_string_t,
extern int dyn_string_substring PARAMS ((dyn_string_t,
dyn_string_t, int, int));
extern int dyn_string_eq PARAMS ((dyn_string_t, dyn_string_t));

53
libiberty/ChangeLog
View File

@ -1,3 +1,56 @@
2000-06-21 Alex Samuel <samuel@codesourcery.com>
* cp-demangle.c: Don't include ctype.h.
(IS_DIGIT): New macro.
(IS_ALPHA): Likewise. Use IS_DIGIT and IS_ALPHA throughout
instead of isdigit and isalpanum.
(demangling_def): Make name and next const pointers.
(STATUS_ALLOCATION_FAILED): New status code.
(dyn_string_append_space): Handle failure in
dyn_string_append_char.
(int_to_dyn_string): Likewise. Change return value to status_t.
(string_list_new): Handle failure of dyn_string_init.
(result_close_template_list): Change return type to status_t.
Handle failure in dyn_string_append.
(result_push): Change return value to status_t. Handle failure in
string_list_new. Handle failure of result_push throughout.
(substitution_add): Change return value to status_t. Handle
dyn_string failures. Handle failure of substitution_add
throughout.
(template_arg_list_new): Return NULL on allocation failure.
(result_append_string): Return STATUS_ALLOCATION_FAILED on error.
Handle error result throughout.
(result_append): Likewise.
(result_append_char): Likewise.
(result_append_space): Likewise.
(demangling_new): Make argument a const pointer. Handle
allocation failures.
(demangle_template_args): Handle failure in template_arg_list_new
and result_close_template_list.
(demangle_discriminator): Return if int_to_dyn_string fails.
(cp_demangle): Likewise.
(cp_demangle_type): New function.
(cplus_demangle_new_abi): Don't call dyn_string_delete. Abort on
memory allocation failure.
(main): Likewise.
* dyn-string.c (RETURN_ON_ALLOCATION_FAILURE): Define if
IN_LIBGCC2.
(dyn_string_init): Change return value to int. Handle
RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_new): Handle RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_release): Delete the dyn_string.
(dyn_string_resize): Handle RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_copy): Change return type to int.
(dyn_string_copy_cstr): Likewise.
(dyn_string_prepend): Likewise.
(dyn_string_prepend_cstr): Likewise.
(dyn_string_insert): Likewise.
(dyn_string_insert_cstr): Likewise.
(dyn_string_append): Likewise.
(dyn_string_append_cstr): Likewise.
(dyn_string_append_char): Likewise.
(dyn_string_substring): Likewise.
2000-06-09 Zack Weinberg <zack@wolery.cumb.org>
* cp-demangle.c (demangle_operator_name): Add spaces before

870
libiberty/cp-demangle.c
View File

File diff suppressed because it is too large Load Diff

198
libiberty/dyn-string.c
View File

@ -36,14 +36,26 @@ Boston, MA 02111-1307, USA. */
#include "libiberty.h"
#include "dyn-string.h"
/* If this file is being compiled for inclusion in the C++ runtime
library, as part of the demangler implementation, we don't want to
abort if an allocation fails. Instead, percolate an error code up
through the call chain. */
#ifdef IN_LIBGCC2
#define RETURN_ON_ALLOCATION_FAILURE
#endif
/* Performs in-place initialization of a dyn_string struct. This
function can be used with a dyn_string struct on the stack or
embedded in another object. The contents of of the string itself
are still dynamically allocated. The string initially is capable
of holding at least SPACE characeters, including the terminating
NUL. If SPACE is 0, it will silently be increated to 1. */
NUL. If SPACE is 0, it will silently be increated to 1.
void
If RETURN_ON_ALLOCATION_FAILURE is defined and memory allocation
fails, returns 0. Otherwise returns 1. */
int
dyn_string_init (ds_struct_ptr, space)
struct dyn_string *ds_struct_ptr;
int space;
@ -52,22 +64,44 @@ dyn_string_init (ds_struct_ptr, space)
if (space == 0)
space = 1;
ds_struct_ptr->allocated = space;
#ifdef RETURN_ON_ALLOCATION_FAILURE
ds_struct_ptr->s = (char *) malloc (space);
if (ds_struct_ptr->s == NULL)
return 0;
#else
ds_struct_ptr->s = (char *) xmalloc (space);
#endif
ds_struct_ptr->allocated = space;
ds_struct_ptr->length = 0;
ds_struct_ptr->s[0] = '\0';
}
/* Create a new dynamic string capable of holding at least SPACE characters,
including the terminating NUL. If SPACE is 0, it will be silently
increased to 1. */
return 1;
}
/* Create a new dynamic string capable of holding at least SPACE
characters, including the terminating NUL. If SPACE is 0, it will
be silently increased to 1. If RETURN_ON_ALLOCATION_FAILURE is
defined and memory allocation fails, returns NULL. Otherwise
returns the newly allocated string. */
dyn_string_t
dyn_string_new (space)
int space;
{
dyn_string_t result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
dyn_string_t result;
#ifdef RETURN_ON_ALLOCATION_FAILURE
result = (dyn_string_t) malloc (sizeof (struct dyn_string));
if (result == NULL)
return NULL;
if (!dyn_string_init (result, space))
{
free (result);
return NULL;
}
#else
result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
dyn_string_init (result, space);
#endif
return result;
}
@ -83,7 +117,7 @@ dyn_string_delete (ds)
/* Returns the contents of DS in a buffer allocated with malloc. It
is the caller's responsibility to deallocate the buffer using free.
DS is then set to the empty string. */
DS is then set to the empty string. Deletes DS itself. */
char*
dyn_string_release (ds)
@ -93,15 +127,18 @@ dyn_string_release (ds)
char* result = ds->s;
/* The buffer is no longer owned by DS. */
ds->s = NULL;
/* Reinitialize DS to the empty string. */
dyn_string_init (ds, 0);
/* Delete DS. */
free (ds);
/* Return the old buffer. */
return result;
}
/* Increase the capacity of DS so it can hold at least SPACE
characters, plus the terminating NUL. This function will not (at
present) reduce the capacity of DS. */
present) reduce the capacity of DS. Returns DS on success.
If RETURN_ON_ALLOCATION_FAILURE is defined and a memory allocation
operation fails, deletes DS and returns NULL. */
dyn_string_t
dyn_string_resize (ds, space)
@ -113,14 +150,24 @@ dyn_string_resize (ds, space)
/* Increase SPACE to hold the NUL termination. */
++space;
/* Increase allocation by factors of two. */
while (space > new_allocated)
new_allocated *= 2;
if (new_allocated != ds->allocated)
{
/* We actually need more space. */
ds->allocated = new_allocated;
/* We actually need more space. */
#ifdef RETURN_ON_ALLOCATION_FAILURE
ds->s = (char *) realloc (ds->s, ds->allocated);
if (ds->s == NULL)
{
free (ds);
return NULL;
}
#else
ds->s = (char *) xrealloc (ds->s, ds->allocated);
#endif
}
return ds;
@ -138,9 +185,10 @@ dyn_string_clear (ds)
}
/* Makes the contents of DEST the same as the contents of SRC. DEST
and SRC must be distinct. */
and SRC must be distinct. Returns 1 on success. On failure, if
RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
void
int
dyn_string_copy (dest, src)
dyn_string_t dest;
dyn_string_t src;
@ -149,55 +197,66 @@ dyn_string_copy (dest, src)
abort ();
/* Make room in DEST. */
dyn_string_resize (dest, src->length);
if (dyn_string_resize (dest, src->length) == NULL)
return 0;
/* Copy DEST into SRC. */
strcpy (dest->s, src->s);
/* Update the size of DEST. */
dest->length = src->length;
return 1;
}
/* Copies SRC, a NUL-terminated string, into DEST. */
/* Copies SRC, a NUL-terminated string, into DEST. Returns 1 on
success. On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
and returns 0. */
void
int
dyn_string_copy_cstr (dest, src)
dyn_string_t dest;
const char *src;
{
int length = strlen (src);
/* Make room in DEST. */
dyn_string_resize (dest, length);
if (dyn_string_resize (dest, length) == NULL)
return 0;
/* Copy DEST into SRC. */
strcpy (dest->s, src);
/* Update the size of DEST. */
dest->length = length;
return 1;
}
/* Inserts SRC at the beginning of DEST. DEST is expanded as
necessary. SRC and DEST must be distinct. */
necessary. SRC and DEST must be distinct. Returns 1 on success.
On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
returns 0. */
void
int
dyn_string_prepend (dest, src)
dyn_string_t dest;
dyn_string_t src;
{
dyn_string_insert (dest, 0, src);
return dyn_string_insert (dest, 0, src);
}
/* Inserts SRC, a NUL-terminated string, at the beginning of DEST.
DEST is expanded as necessary. */
DEST is expanded as necessary. Returns 1 on success. On failure,
if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
void
int
dyn_string_prepend_cstr (dest, src)
dyn_string_t dest;
const char *src;
{
dyn_string_insert_cstr (dest, 0, src);
return dyn_string_insert_cstr (dest, 0, src);
}
/* Inserts SRC into DEST starting at position POS. DEST is expanded as
necessary. SRC and DEST must be distinct. */
/* Inserts SRC into DEST starting at position POS. DEST is expanded
as necessary. SRC and DEST must be distinct. Returns 1 on
success. On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
and returns 0. */
void
int
dyn_string_insert (dest, pos, src)
dyn_string_t dest;
int pos;
@ -208,7 +267,8 @@ dyn_string_insert (dest, pos, src)
if (src == dest)
abort ();
dyn_string_resize (dest, dest->length + src->length);
if (dyn_string_resize (dest, dest->length + src->length) == NULL)
return 0;
/* Make room for the insertion. Be sure to copy the NUL. */
for (i = dest->length; i >= pos; --i)
dest->s[i + src->length] = dest->s[i];
@ -216,12 +276,15 @@ dyn_string_insert (dest, pos, src)
strncpy (dest->s + pos, src->s, src->length);
/* Compute the new length. */
dest->length += src->length;
return 1;
}
/* Inserts SRC, a NUL-terminated string, into DEST starting at
position POS. DEST is expanded as necessary. */
position POS. DEST is expanded as necessary. Returns 1 on
success. On failure, RETURN_ON_ALLOCATION_FAILURE, deletes DEST
and returns 0. */
void
int
dyn_string_insert_cstr (dest, pos, src)
dyn_string_t dest;
int pos;
@ -230,7 +293,8 @@ dyn_string_insert_cstr (dest, pos, src)
int i;
int length = strlen (src);
dyn_string_resize (dest, dest->length + length);
if (dyn_string_resize (dest, dest->length + length) == NULL)
return 0;
/* Make room for the insertion. Be sure to copy the NUL. */
for (i = dest->length; i >= pos; --i)
dest->s[i + length] = dest->s[i];
@ -238,63 +302,72 @@ dyn_string_insert_cstr (dest, pos, src)
strncpy (dest->s + pos, src, length);
/* Compute the new length. */
dest->length += length;
return 1;
}
/* Append S to DS, resizing DS if necessary. Returns DS. */
/* Append S to DS, resizing DS if necessary. Returns 1 on success.
On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
returns 0. */
dyn_string_t
dyn_string_append (ds, s)
dyn_string_t ds;
int
dyn_string_append (dest, s)
dyn_string_t dest;
dyn_string_t s;
{
dyn_string_resize (ds, ds->length + s->length);
strcpy (ds->s + ds->length, s->s);
ds->length += s->length;
return ds;
if (dyn_string_resize (dest, dest->length + s->length) == 0)
return 0;
strcpy (dest->s + dest->length, s->s);
dest->length += s->length;
return 1;
}
/* Append the NUL-terminated string S to DS, resizing DS if necessary.
Returns DS. */
Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE,
deletes DEST and returns 0. */
dyn_string_t
dyn_string_append_cstr (ds, s)
dyn_string_t ds;
int
dyn_string_append_cstr (dest, s)
dyn_string_t dest;
const char *s;
{
int len = strlen (s);
/* The new length is the old length plus the size of our string, plus
one for the null at the end. */
dyn_string_resize (ds, ds->length + len);
strcpy (ds->s + ds->length, s);
ds->length += len;
return ds;
if (dyn_string_resize (dest, dest->length + len) == NULL)
return 0;
strcpy (dest->s + dest->length, s);
dest->length += len;
return 1;
}
/* Appends C to the end of DS. */
/* Appends C to the end of DEST. Returns 1 on success. On failiure,
if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
dyn_string_t
dyn_string_append_char (ds, c)
dyn_string_t ds;
int
dyn_string_append_char (dest, c)
dyn_string_t dest;
int c;
{
/* Make room for the extra character. */
dyn_string_resize (ds, ds->length + 1);
if (dyn_string_resize (dest, dest->length + 1) == NULL)
return 0;
/* Append the character; it will overwrite the old NUL. */
ds->s[ds->length] = c;
dest->s[dest->length] = c;
/* Add a new NUL at the end. */
ds->s[ds->length + 1] = '\0';
dest->s[dest->length + 1] = '\0';
/* Update the length. */
++(ds->length);
return ds;
++(dest->length);
return 1;
}
/* Sets the contents of DEST to the substring of SRC starting at START
and ending before END. START must be less than or equal to END,
and both must be between zero and the length of SRC, inclusive. */
and both must be between zero and the length of SRC, inclusive.
Returns 1 on success. On failure, if RETURN_ON_ALLOCATION_FAILURE,
deletes DEST and returns 0. */
void
int
dyn_string_substring (dest, src, start, end)
dyn_string_t dest;
dyn_string_t src;
@ -308,7 +381,8 @@ dyn_string_substring (dest, src, start, end)
abort ();
/* Make room for the substring. */
dyn_string_resize (dest, length);
if (dyn_string_resize (dest, length) == NULL)
return 0;
/* Copy the characters in the substring, */
for (i = length; --i >= 0; )
dest->s[i] = src->s[start + i];
@ -316,6 +390,8 @@ dyn_string_substring (dest, src, start, end)
dest->s[length] = '\0';
/* Record the length of the substring. */
dest->length = length;
return 1;
}
/* Returns non-zero if DS1 and DS2 have the same contents. */