gcc:

[pf3gnuchains/gcc-fork.git] / libiberty / dyn-string.c

diff --git a/libiberty/dyn-string.c b/libiberty/dyn-string.c
index 5d48cdc..b6f5d4b 100644 (file)
--- a/libiberty/dyn-string.c
+++ b/libiberty/dyn-string.c
@@ -56,9 +56,7 @@ Boston, MA 02111-1307, USA.  */
    fails, returns 0.  Otherwise returns 1.  */
 
 int
-dyn_string_init (ds_struct_ptr, space)
-     struct dyn_string *ds_struct_ptr;
-     int space;
+dyn_string_init (struct dyn_string *ds_struct_ptr, int space)
 {
   /* We need at least one byte in which to store the terminating NUL.  */
   if (space == 0)
@@ -85,8 +83,7 @@ dyn_string_init (ds_struct_ptr, space)
    returns the newly allocated string.  */
 
 dyn_string_t 
-dyn_string_new (space)
-     int space;
+dyn_string_new (int space)
 {
   dyn_string_t result;
 #ifdef RETURN_ON_ALLOCATION_FAILURE
@@ -108,8 +105,7 @@ dyn_string_new (space)
 /* Free the memory used by DS.  */
 
 void 
-dyn_string_delete (ds)
-     dyn_string_t ds;
+dyn_string_delete (dyn_string_t ds)
 {
   free (ds->s);
   free (ds);
@@ -120,8 +116,7 @@ dyn_string_delete (ds)
    DS is then set to the empty string.  Deletes DS itself.  */
 
 char*
-dyn_string_release (ds)
-     dyn_string_t ds;
+dyn_string_release (dyn_string_t ds)
 {
   /* Store the old buffer.  */
   char* result = ds->s;
@@ -141,9 +136,7 @@ dyn_string_release (ds)
    operation fails, deletes DS and returns NULL.  */
 
 dyn_string_t 
-dyn_string_resize (ds, space)
-     dyn_string_t ds;
-     int space;
+dyn_string_resize (dyn_string_t ds, int space)
 {
   int new_allocated = ds->allocated;
 
@@ -176,8 +169,7 @@ dyn_string_resize (ds, space)
 /* Sets the contents of DS to the empty string.  */
 
 void
-dyn_string_clear (ds)
-     dyn_string_t ds;
+dyn_string_clear (dyn_string_t ds)
 {
   /* A dyn_string always has room for at least the NUL terminator.  */
   ds->s[0] = '\0';
@@ -189,9 +181,7 @@ dyn_string_clear (ds)
    RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
 
 int
-dyn_string_copy (dest, src)
-     dyn_string_t dest;
-     dyn_string_t src;
+dyn_string_copy (dyn_string_t dest, dyn_string_t src)
 {
   if (dest == src)
     abort ();
@@ -211,9 +201,7 @@ dyn_string_copy (dest, src)
    and returns 0.  */
 
 int
-dyn_string_copy_cstr (dest, src)
-     dyn_string_t dest;
-     const char *src;
+dyn_string_copy_cstr (dyn_string_t dest, const char *src)
 {
   int length = strlen (src);
   /* Make room in DEST.  */
@@ -232,9 +220,7 @@ dyn_string_copy_cstr (dest, src)
    returns 0.  */
 
 int
-dyn_string_prepend (dest, src)
-     dyn_string_t dest;
-     dyn_string_t src;
+dyn_string_prepend (dyn_string_t dest, dyn_string_t src)
 {
   return dyn_string_insert (dest, 0, src);
 }
@@ -244,9 +230,7 @@ dyn_string_prepend (dest, src)
    if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
 
 int
-dyn_string_prepend_cstr (dest, src)
-     dyn_string_t dest;
-     const char *src;
+dyn_string_prepend_cstr (dyn_string_t dest, const char *src)
 {
   return dyn_string_insert_cstr (dest, 0, src);
 }
@@ -257,10 +241,7 @@ dyn_string_prepend_cstr (dest, src)
    and returns 0.  */
 
 int
-dyn_string_insert (dest, pos, src)
-     dyn_string_t dest;
-     int pos;
-     dyn_string_t src;
+dyn_string_insert (dyn_string_t dest, int pos, dyn_string_t src)
 {
   int i;
 
@@ -285,10 +266,7 @@ dyn_string_insert (dest, pos, src)
    and returns 0.  */
 
 int
-dyn_string_insert_cstr (dest, pos, src)
-     dyn_string_t dest;
-     int pos;
-     const char *src;
+dyn_string_insert_cstr (dyn_string_t dest, int pos, const char *src)
 {
   int i;
   int length = strlen (src);
@@ -310,10 +288,7 @@ dyn_string_insert_cstr (dest, pos, src)
    RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
 
 int
-dyn_string_insert_char (dest, pos, c)
-     dyn_string_t dest;
-     int pos;
-     int c;
+dyn_string_insert_char (dyn_string_t dest, int pos, int c)
 {
   int i;
 
@@ -334,9 +309,7 @@ dyn_string_insert_char (dest, pos, c)
    returns 0.  */
 
 int
-dyn_string_append (dest, s)
-     dyn_string_t dest;
-     dyn_string_t s;
+dyn_string_append (dyn_string_t dest, dyn_string_t s)
 {
   if (dyn_string_resize (dest, dest->length + s->length) == 0)
     return 0;
@@ -350,9 +323,7 @@ dyn_string_append (dest, s)
    deletes DEST and returns 0.  */
 
 int
-dyn_string_append_cstr (dest, s)
-     dyn_string_t dest;
-     const char *s;
+dyn_string_append_cstr (dyn_string_t dest, const char *s)
 {
   int len = strlen (s);
 
@@ -369,9 +340,7 @@ dyn_string_append_cstr (dest, s)
    if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
 
 int
-dyn_string_append_char (dest, c)
-     dyn_string_t dest;
-     int c;
+dyn_string_append_char (dyn_string_t dest, int c)
 {
   /* Make room for the extra character.  */
   if (dyn_string_resize (dest, dest->length + 1) == NULL)
@@ -392,11 +361,8 @@ dyn_string_append_char (dest, c)
    deletes DEST and returns 0.  */
 
 int
-dyn_string_substring (dest, src, start, end)
-     dyn_string_t dest;
-     dyn_string_t src;
-     int start;
-     int end;
+dyn_string_substring (dyn_string_t dest, dyn_string_t src,
+                      int start, int end)
 {
   int i;
   int length = end - start;
@@ -421,9 +387,7 @@ dyn_string_substring (dest, src, start, end)
 /* Returns non-zero if DS1 and DS2 have the same contents.  */
 
 int
-dyn_string_eq (ds1, ds2)
-     dyn_string_t ds1;
-     dyn_string_t ds2;
+dyn_string_eq (dyn_string_t ds1, dyn_string_t ds2)
 {
   /* If DS1 and DS2 have different lengths, they must not be the same.  */
   if (ds1->length != ds2->length)