Re: [Bug-gnulib] 03-getndelim2-c89.diff

[Derek Robert Price]

Ok, I replaced the *loadavg with loadavg[] as you requested, left the 
(void)s, and removed all __ptr_t references, replacing them with void * 
when necessary since I confirmed that this was part of the ANSI C spec.

Index: bcopy.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/bcopy.c,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 bcopy.c
--- bcopy.c     8 Nov 1992 02:50:45 -0000       1.1.1.1
+++ bcopy.c     24 Jul 2003 13:04:49 -0000
@@ -4,9 +4,7 @@
   By David MacKenzie <address@hidden>.  */

void
-bcopy (source, dest, length)
-     char *source, *dest;
-     unsigned length;
+bcopy (char *source, char *dest, unsigned int length)
{
  if (source < dest)
    /* Moving from low mem to hi mem; start at end.  */
Index: gethostname.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/gethostname.c,v
retrieving revision 1.5
diff -u -r1.5 gethostname.c
--- gethostname.c       7 Aug 2000 15:48:18 -0000       1.5
+++ gethostname.c       24 Jul 2003 13:04:49 -0000
@@ -30,9 +30,7 @@
   Return 0 if ok, -1 if error.  */

int
-gethostname (name, len)
-     char *name;
-     int len;
+gethostname (char *name, int len)
{
#ifdef HAVE_UNAME
  struct utsname uts;
Index: getloadavg.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/getloadavg.c,v
retrieving revision 1.16
diff -u -r1.16 getloadavg.c
--- getloadavg.c        19 Jun 2000 07:25:01 -0000      1.16
+++ getloadavg.c        24 Jul 2003 13:04:49 -0000
@@ -552,9 +552,7 @@
   or -1 if an error occurred.  */

int
-getloadavg (loadavg, nelem)
-     double loadavg[];
-     int nelem;
+getloadavg (double loadavg[], int nelem)
{
  int elem = 0;                 /* Return value.  */

@@ -1046,9 +1044,7 @@

#ifdef TEST
void
-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)
{
  int naptime = 0;

Index: getusershell.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/getusershell.c,v
retrieving revision 1.14
diff -u -r1.14 getusershell.c
--- getusershell.c      17 Nov 2001 13:29:42 -0000      1.14
+++ getusershell.c      24 Jul 2003 13:04:50 -0000
@@ -82,7 +82,7 @@
   Return NULL if there are no more entries.  */

char *
-getusershell ()
+getusershell (void)
{
  if (default_index > 0)
    {
@@ -114,7 +114,7 @@
/* Rewind the shells file. */

void
-setusershell ()
+setusershell (void)
{
  default_index = 0;
  if (shellstream)
@@ -124,7 +124,7 @@
/* Close the shells file. */

void
-endusershell ()
+endusershell (void)
{
  if (shellstream)
    {
@@ -142,10 +142,7 @@
   if some nonempty sequence was found, otherwise 0.  */

static int
-readname (name, size, stream)
-     char **name;
-     int *size;
-     FILE *stream;
+readname (char **name, int *size, FILE *stream)
{
  int c;
  int name_index = 0;
Index: md5.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/md5.c,v
retrieving revision 1.13
diff -u -r1.13 md5.c
--- md5.c       17 Nov 2001 13:29:42 -0000      1.13
+++ md5.c       24 Jul 2003 13:04:50 -0000
@@ -61,8 +61,7 @@
/* Initialize structure containing state of computation.
   (RFC 1321, 3.3: Step 3)  */
void
-md5_init_ctx (ctx)
-     struct md5_ctx *ctx;
+md5_init_ctx (struct md5_ctx *ctx)
{
  ctx->A = 0x67452301;
  ctx->B = 0xefcdab89;
@@ -79,9 +78,7 @@
   IMPORTANT: On some systems it is required that RESBUF is correctly
   aligned for a 32 bits value.  */
void *
-md5_read_ctx (ctx, resbuf)
-     const struct md5_ctx *ctx;
-     void *resbuf;
+md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
{
  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
@@ -97,9 +94,7 @@
   IMPORTANT: On some systems it is required that RESBUF is correctly
   aligned for a 32 bits value.  */
void *
-md5_finish_ctx (ctx, resbuf)
-     struct md5_ctx *ctx;
-     void *resbuf;
+md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
{
  /* Take yet unprocessed bytes into account.  */
  md5_uint32 bytes = ctx->buflen;
@@ -128,9 +123,7 @@
   resulting message digest number will be written into the 16 bytes
   beginning at RESBLOCK.  */
int
-md5_stream (stream, resblock)
-     FILE *stream;
-     void *resblock;
+md5_stream (FILE *stream, void *resblock)
{
  /* Important: BLOCKSIZE must be a multiple of 64.  */
#define BLOCKSIZE 4096
@@ -185,10 +178,7 @@
   output yields to the wanted ASCII representation of the message
   digest.  */
void *
-md5_buffer (buffer, len, resblock)
-     const char *buffer;
-     size_t len;
-     void *resblock;
+md5_buffer (const char *buffer, size_t len, void *resblock)
{
  struct md5_ctx ctx;

@@ -204,10 +194,7 @@


void
-md5_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct md5_ctx *ctx;
+md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
{
  /* When we already have some bits in our internal buffer concatenate
     both inputs first.  */
@@ -262,10 +249,7 @@
   It is assumed that LEN % 64 == 0.  */

void
-md5_process_block (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct md5_ctx *ctx;
+md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
{
  md5_uint32 correct_words[16];
  const md5_uint32 *words = buffer;
Index: memchr.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/memchr.c,v
retrieving revision 1.15
diff -u -r1.15 memchr.c
--- memchr.c    28 Oct 2000 08:22:11 -0000      1.15
+++ memchr.c    24 Jul 2003 13:04:50 -0000
@@ -27,13 +27,6 @@
# include <config.h>
#endif

-#undef __ptr_t
-#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
-# define __ptr_t void *
-#else /* Not C++ or ANSI C.  */
-# define __ptr_t char *
-#endif /* C++ or ANSI C.  */
-
#if defined _LIBC
# include <string.h>
# include <memcopy.h>
@@ -66,11 +59,8 @@
#undef __memchr

/* Search no more than N bytes of S for C.  */
-__ptr_t
-__memchr (s, c_in, n)
-     const __ptr_t s;
-     int c_in;
-     size_t n;
+void *
+__memchr (const void *s, int c_in, size_t n)
{
  const unsigned char *char_ptr;
  const unsigned long int *longword_ptr;
@@ -86,7 +76,7 @@
                 & (sizeof (longword) - 1)) != 0;
       --n, ++char_ptr)
    if (*char_ptr == c)
-      return (__ptr_t) char_ptr;
+      return (void *) char_ptr;

  /* All these elucidatory comments refer to 4-byte longwords,
     but the theory applies equally well to 8-byte longwords.  */
@@ -177,22 +167,22 @@
          const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);

          if (cp[0] == c)
-           return (__ptr_t) cp;
+           return (void *) cp;
          if (cp[1] == c)
-           return (__ptr_t) &cp[1];
+           return (void *) &cp[1];
          if (cp[2] == c)
-           return (__ptr_t) &cp[2];
+           return (void *) &cp[2];
          if (cp[3] == c)
-           return (__ptr_t) &cp[3];
+           return (void *) &cp[3];
#if LONG_MAX > 2147483647
          if (cp[4] == c)
-           return (__ptr_t) &cp[4];
+           return (void *) &cp[4];
          if (cp[5] == c)
-           return (__ptr_t) &cp[5];
+           return (void *) &cp[5];
          if (cp[6] == c)
-           return (__ptr_t) &cp[6];
+           return (void *) &cp[6];
          if (cp[7] == c)
-           return (__ptr_t) &cp[7];
+           return (void *) &cp[7];
#endif
        }

@@ -204,7 +194,7 @@
  while (n-- > 0)
    {
      if (*char_ptr == c)
-       return (__ptr_t) char_ptr;
+       return (void *) char_ptr;
      else
        ++char_ptr;
    }
Index: memcmp.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/memcmp.c,v
retrieving revision 1.10
diff -u -r1.10 memcmp.c
--- memcmp.c    28 Oct 2000 08:24:44 -0000      1.10
+++ memcmp.c    24 Jul 2003 13:04:50 -0000
@@ -23,15 +23,6 @@
# include "config.h"
#endif

-#undef __ptr_t
-#if defined __cplusplus || (defined __STDC__ && __STDC__)
-# define __ptr_t       void *
-#else /* Not C++ or ANSI C.  */
-# undef        const
-# define const
-# define __ptr_t       char *
-#endif /* C++ or ANSI C.  */
-
#ifndef __P
# if defined __GNUC__ || (defined __STDC__ && __STDC__)
#  define __P(args) args
Index: memmove.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/memmove.c,v
retrieving revision 1.7
diff -u -r1.7 memmove.c
--- memmove.c   17 Oct 1996 03:05:09 -0000      1.7
+++ memmove.c   24 Jul 2003 13:04:50 -0000
@@ -8,10 +8,7 @@
#endif

void *
-memmove (dest, source, length)
-     char *dest;
-     const char *source;
-     unsigned length;
+memmove (char *dest, const char *source, unsigned int length)
{
  char *d0 = dest;
  if (source < dest)
Index: memrchr.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/memrchr.c,v
retrieving revision 1.3
diff -u -r1.3 memrchr.c
--- memrchr.c   9 Jul 2003 22:48:53 -0000       1.3
+++ memrchr.c   24 Jul 2003 13:04:50 -0000
@@ -26,13 +26,6 @@

#include <stdlib.h>

-#undef __ptr_t
-#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
-# define __ptr_t void *
-#else /* Not C++ or ANSI C.  */
-# define __ptr_t char *
-#endif /* C++ or ANSI C.  */
-
#if defined (_LIBC)
# include <string.h>
# include <memcopy.h>
@@ -60,11 +53,8 @@
#endif

/* Search no more than N bytes of S for C.  */
-__ptr_t
-__memrchr (s, c_in, n)
-     const __ptr_t s;
-     int c_in;
-     size_t n;
+void *
+__memrchr (const void *s, int c_in, size_t n)
{
  const unsigned char *char_ptr;
  const unsigned long int *longword_ptr;
@@ -80,7 +70,7 @@
                 & (sizeof (longword) - 1)) != 0;
       --n)
    if (*--char_ptr == c)
-      return (__ptr_t) char_ptr;
+      return (void *) char_ptr;

  /* All these elucidatory comments refer to 4-byte longwords,
     but the theory applies equally well to 8-byte longwords.  */
@@ -172,22 +162,22 @@

#if LONG_MAX > 2147483647
          if (cp[7] == c)
-           return (__ptr_t) &cp[7];
+           return (void *) &cp[7];
          if (cp[6] == c)
-           return (__ptr_t) &cp[6];
+           return (void *) &cp[6];
          if (cp[5] == c)
-           return (__ptr_t) &cp[5];
+           return (void *) &cp[5];
          if (cp[4] == c)
-           return (__ptr_t) &cp[4];
+           return (void *) &cp[4];
#endif
          if (cp[3] == c)
-           return (__ptr_t) &cp[3];
+           return (void *) &cp[3];
          if (cp[2] == c)
-           return (__ptr_t) &cp[2];
+           return (void *) &cp[2];
          if (cp[1] == c)
-           return (__ptr_t) &cp[1];
+           return (void *) &cp[1];
          if (cp[0] == c)
-           return (__ptr_t) cp;
+           return (void *) cp;
        }

      n -= sizeof (longword);
@@ -198,7 +188,7 @@
  while (n-- > 0)
    {
      if (*--char_ptr == c)
-       return (__ptr_t) char_ptr;
+       return (void *) char_ptr;
    }

  return 0;
Index: readtokens.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/readtokens.c,v
retrieving revision 1.11
diff -u -r1.11 readtokens.c
--- readtokens.c        7 Jun 2003 10:16:29 -0000       1.11
+++ readtokens.c        24 Jul 2003 13:04:50 -0000
@@ -58,8 +58,7 @@
/* Initialize a tokenbuffer. */

void
-init_tokenbuffer (tokenbuffer)
-     token_buffer *tokenbuffer;
+init_tokenbuffer (token_buffer *tokenbuffer)
{
  tokenbuffer->size = INITIAL_TOKEN_LENGTH;
  tokenbuffer->buffer = xmalloc (INITIAL_TOKEN_LENGTH);
Index: realloc.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/realloc.c,v
retrieving revision 1.7
diff -u -r1.7 realloc.c
--- realloc.c   4 Jun 2003 19:22:29 -0000       1.7
+++ realloc.c   24 Jul 2003 13:04:50 -0000
@@ -32,9 +32,7 @@
   use malloc.  */

char *
-rpl_realloc (p, n)
-     char *p;
-     size_t n;
+rpl_realloc (char *p, size_t n)
{
  if (n == 0)
    n = 1;
Index: regex.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/regex.c,v
retrieving revision 1.79
diff -u -r1.79 regex.c
--- regex.c     25 Nov 2002 00:17:33 -0000      1.79
+++ regex.c     24 Jul 2003 13:04:52 -0000
@@ -276,7 +276,7 @@
static void init_syntax_once PARAMS ((void));

static void
-init_syntax_once ()
+init_syntax_once (void)
{
   register int c;
   static int done = 0;
@@ -688,9 +688,7 @@
# ifdef DEBUG
static void PREFIX(extract_number) _RE_ARGS ((int *dest, UCHAR_T *source));
static void
-PREFIX(extract_number) (dest, source)
-    int *dest;
-    UCHAR_T *source;
+PREFIX(extract_number) (int *dest, UCHAR_T *source)
{
#  ifdef WCHAR
  *dest = *source;
@@ -721,9 +719,7 @@
static void PREFIX(extract_number_and_incr) _RE_ARGS ((int *destination,
                                                       UCHAR_T **source));
static void
-PREFIX(extract_number_and_incr) (destination, source)
-    int *destination;
-    UCHAR_T **source;
+PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source)
{
  PREFIX(extract_number) (destination, *source);
  *source += OFFSET_ADDRESS_SIZE;
@@ -774,8 +770,7 @@

#  ifndef DEFINED_ONCE
void
-print_fastmap (fastmap)
-    char *fastmap;
+print_fastmap (char *fastmap)
{
  unsigned was_a_range = 0;
  unsigned i = 0;
@@ -807,9 +802,7 @@
   the START pointer into it and ending just before the pointer END.  */

void
-PREFIX(print_partial_compiled_pattern) (start, end)
-    UCHAR_T *start;
-    UCHAR_T *end;
+PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
{
  int mcnt, mcnt2;
  UCHAR_T *p1;
@@ -1142,8 +1135,7 @@


void
-PREFIX(print_compiled_pattern) (bufp)
-    struct re_pattern_buffer *bufp;
+PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp)
{
  UCHAR_T *buffer = (UCHAR_T*) bufp->buffer;

@@ -1175,12 +1167,8 @@


void
-PREFIX(print_double_string) (where, string1, size1, string2, size2)
-    const CHAR_T *where;
-    const CHAR_T *string1;
-    const CHAR_T *string2;
-    int size1;
-    int size2;
+PREFIX(print_double_string) (const CHAR_T *where, const CHAR_T *string1,
+                            int size1, const CHAR_T *string2, int size2)
{
  int this_char;

@@ -1213,8 +1201,7 @@

#  ifndef DEFINED_ONCE
void
-printchar (c)
-     int c;
+printchar (int c)
{
  putc (c, stderr);
}
@@ -1247,15 +1234,9 @@
   We assume offset_buffer and is_binary is already allocated
   enough space.  */

-static size_t convert_mbs_to_wcs (CHAR_T *dest, const unsigned char* src,
-                                 size_t len, int *offset_buffer,
-                                 char *is_binary);
static size_t
-convert_mbs_to_wcs (dest, src, len, offset_buffer, is_binary)
-     CHAR_T *dest;
-     const unsigned char* src;
-     size_t len; /* the length of multibyte string.  */
-
+convert_mbs_to_wcs (CHAR_T *dest, const unsigned char* src,
+                   size_t len, /* the length of multibyte string.  */
     /* It hold correspondances between src(char string) and
        dest(wchar_t string) for optimization.
        e.g. src  = "xxxyzz"
@@ -1265,8 +1246,7 @@
          offset_buffer = {0, 0+3("xxx"), 0+3+1("y"), 0+3+1+2("zz")}
                        = {0, 3, 4, 6}
     */
-     int *offset_buffer;
-     char *is_binary;
+                   int *offset_buffer, char *is_binary)
{
  wchar_t *pdest = dest;
  const unsigned char *psrc = src;
@@ -1333,8 +1313,7 @@
   defined in regex.h.  We return the old syntax.  */

reg_syntax_t
-re_set_syntax (syntax)
-    reg_syntax_t syntax;
+re_set_syntax (reg_syntax_t syntax)
{
  reg_syntax_t ret = re_syntax_options;

@@ -2293,8 +2272,7 @@
   but don't make them smaller.  */

static void
-PREFIX(regex_grow_registers) (num_regs)
-     int num_regs;
+PREFIX(regex_grow_registers) (int num_regs)
{
  if (num_regs > regs_allocated_size)
    {
@@ -2348,11 +2326,9 @@
# endif /* WCHAR */

static reg_errcode_t
-PREFIX(regex_compile) (ARG_PREFIX(pattern), ARG_PREFIX(size), syntax, bufp)
-     const char *ARG_PREFIX(pattern);
-     size_t ARG_PREFIX(size);
-     reg_syntax_t syntax;
-     struct re_pattern_buffer *bufp;
+PREFIX(regex_compile) (const char *ARG_PREFIX(pattern),
+                      size_t ARG_PREFIX(size), reg_syntax_t syntax,
+                      struct re_pattern_buffer *bufp)
{
  /* We fetch characters from PATTERN here.  Even though PATTERN is
     `char *' (i.e., signed), we declare these variables as unsigned, so
@@ -4292,10 +4268,7 @@
/* ifdef WCHAR, integer parameter is 1 wchar_t.  */

static void
-PREFIX(store_op1) (op, loc, arg)
-    re_opcode_t op;
-    UCHAR_T *loc;
-    int arg;
+PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg)
{
  *loc = (UCHAR_T) op;
  STORE_NUMBER (loc + 1, arg);
@@ -4306,10 +4279,7 @@
/* ifdef WCHAR, integer parameter is 1 wchar_t.  */

static void
-PREFIX(store_op2) (op, loc, arg1, arg2)
-    re_opcode_t op;
-    UCHAR_T *loc;
-    int arg1, arg2;
+PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2)
{
  *loc = (UCHAR_T) op;
  STORE_NUMBER (loc + 1, arg1);
@@ -4322,11 +4292,7 @@
/* ifdef WCHAR, integer parameter is 1 wchar_t.  */

static void
-PREFIX(insert_op1) (op, loc, arg, end)
-    re_opcode_t op;
-    UCHAR_T *loc;
-    int arg;
-    UCHAR_T *end;
+PREFIX(insert_op1) ( re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end)
{
  register UCHAR_T *pfrom = end;
  register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
@@ -4342,11 +4308,8 @@
/* ifdef WCHAR, integer parameter is 1 wchar_t.  */

static void
-PREFIX(insert_op2) (op, loc, arg1, arg2, end)
-    re_opcode_t op;
-    UCHAR_T *loc;
-    int arg1, arg2;
-    UCHAR_T *end;
+PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2,
+                   UCHAR_T *end)
{
  register UCHAR_T *pfrom = end;
  register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE;
@@ -4363,9 +4326,8 @@
   least one character before the ^.  */

static boolean
-PREFIX(at_begline_loc_p) (pattern, p, syntax)
-    const CHAR_T *pattern, *p;
-    reg_syntax_t syntax;
+PREFIX(at_begline_loc_p) (const CHAR_T *pattern, const CHAR_T *p,
+                         reg_syntax_t syntax)
{
  const CHAR_T *prev = p - 2;
  boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
@@ -4382,9 +4344,8 @@
   at least one character after the $, i.e., `P < PEND'.  */

static boolean
-PREFIX(at_endline_loc_p) (p, pend, syntax)
-    const CHAR_T *p, *pend;
-    reg_syntax_t syntax;
+PREFIX(at_endline_loc_p) (const CHAR_T *p, const CHAR_T *pend,
+                         reg_syntax_t syntax)
{
  const CHAR_T *next = p;
  boolean next_backslash = *next == '\\';
@@ -4405,9 +4366,7 @@
   false if it's not.  */

static boolean
-group_in_compile_stack (compile_stack, regnum)
-    compile_stack_type compile_stack;
-    regnum_t regnum;
+group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
{
  int this_element;

@@ -4427,10 +4386,7 @@
/* This insert space, which size is "num", into the pattern at "loc".
   "end" must point the end of the allocated buffer.  */
static void
-insert_space (num, loc, end)
-     int num;
-     CHAR_T *loc;
-     CHAR_T *end;
+insert_space (int num, CHAR_T *loc, CHAR_T *end)
{
  register CHAR_T *pto = end;
  register CHAR_T *pfrom = end - num;
@@ -4442,13 +4398,9 @@

#ifdef WCHAR
static reg_errcode_t
-wcs_compile_range (range_start_char, p_ptr, pend, translate, syntax, b,
-                  char_set)
-     CHAR_T range_start_char;
-     const CHAR_T **p_ptr, *pend;
-     CHAR_T *char_set, *b;
-     RE_TRANSLATE_TYPE translate;
-     reg_syntax_t syntax;
+wcs_compile_range (CHAR_T range_start_char, const CHAR_T **p_ptr,
+                  const CHAR_T *pend, RE_TRANSLATE_TYPE translate,
+                  reg_syntax_t syntax, CHAR_T *b, CHAR_T *char_set)
{
  const CHAR_T *p = *p_ptr;
  CHAR_T range_start, range_end;
@@ -4529,12 +4481,9 @@
   `regex_compile' itself.  */

static reg_errcode_t
-byte_compile_range (range_start_char, p_ptr, pend, translate, syntax, b)
-     unsigned int range_start_char;
-     const char **p_ptr, *pend;
-     RE_TRANSLATE_TYPE translate;
-     reg_syntax_t syntax;
-     unsigned char *b;
+byte_compile_range (unsigned int range_start_char, const char **p_ptr,
+                   const char *pend, char *translate, reg_syntax_t syntax,
+                   unsigned char *b)
{
  unsigned this_char;
  const char *p = *p_ptr;
@@ -4615,8 +4564,7 @@
static unsigned char truncate_wchar (CHAR_T c);

static unsigned char
-truncate_wchar (c)
-     CHAR_T c;
+truncate_wchar (CHAR_T c)
{
  unsigned char buf[MB_CUR_MAX];
  mbstate_t state;
@@ -4628,8 +4576,7 @@
#endif /* WCHAR */

static int
-PREFIX(re_compile_fastmap) (bufp)
-     struct re_pattern_buffer *bufp;
+PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp)
{
  int j, k;
#ifdef MATCH_MAY_ALLOCATE
@@ -4948,8 +4895,7 @@
#else /* not INSIDE_RECURSION */

int
-re_compile_fastmap (bufp)
-     struct re_pattern_buffer *bufp;
+re_compile_fastmap (struct re_pattern_buffer *bufp)
{
# ifdef MBS_SUPPORT
  if (MB_CUR_MAX != 1)
@@ -4977,11 +4923,8 @@
   freeing the old data.  */

void
-re_set_registers (bufp, regs, num_regs, starts, ends)
-    struct re_pattern_buffer *bufp;
-    struct re_registers *regs;
-    unsigned num_regs;
-    regoff_t *starts, *ends;
+re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs,
+                 unsigned int num_regs, regoff_t *starts, regoff_t *ends)
{
  if (num_regs)
    {
@@ -5007,11 +4950,8 @@
   doesn't let you say where to stop matching.  */

int
-re_search (bufp, string, size, startpos, range, regs)
-     struct re_pattern_buffer *bufp;
-     const char *string;
-     int size, startpos, range;
-     struct re_registers *regs;
+re_search (struct re_pattern_buffer *bufp, const char *string, int size,
+          int startpos, int range, struct re_registers *regs)
{
  return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
                      regs, size);
@@ -5043,14 +4983,9 @@
   stack overflow).  */

int
-re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
-     struct re_pattern_buffer *bufp;
-     const char *string1, *string2;
-     int size1, size2;
-     int startpos;
-     int range;
-     struct re_registers *regs;
-     int stop;
+re_search_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
+            const char *string2, int size2, int startpos, int range,
+            struct re_registers *regs, int stop)
{
# ifdef MBS_SUPPORT
  if (MB_CUR_MAX != 1)
@@ -5106,15 +5041,10 @@


static int
-PREFIX(re_search_2) (bufp, string1, size1, string2, size2, startpos, range,
-                    regs, stop)
-     struct re_pattern_buffer *bufp;
-     const char *string1, *string2;
-     int size1, size2;
-     int startpos;
-     int range;
-     struct re_registers *regs;
-     int stop;
+PREFIX(re_search_2) (struct re_pattern_buffer *bufp,
+                    const char *string1, int size1, const char *string2,
+                    int size2, int startpos, int range,
+                    struct re_registers *regs, int stop)
{
  int val;
  register char *fastmap = bufp->fastmap;
@@ -5497,11 +5427,8 @@
/* re_match is like re_match_2 except it takes only a single string.  */

int
-re_match (bufp, string, size, pos, regs)
-     struct re_pattern_buffer *bufp;
-     const char *string;
-     int size, pos;
-     struct re_registers *regs;
+re_match (struct re_pattern_buffer *bufp, const char *string, int size,
+         int pos, struct re_registers *regs)
{
  int result;
# ifdef MBS_SUPPORT
@@ -5555,13 +5482,9 @@
   matched substring.  */

int
-re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
-     struct re_pattern_buffer *bufp;
-     const char *string1, *string2;
-     int size1, size2;
-     int pos;
-     struct re_registers *regs;
-     int stop;
+re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
+           const char *string2, int size2, int pos, struct re_registers *regs,
+           int stop)
{
  int result;
# ifdef MBS_SUPPORT
@@ -5598,9 +5521,7 @@
   See convert_mbs_to_wcs.  */

static int
-count_mbs_length(offset_buffer, length)
-     int *offset_buffer;
-     int length;
+count_mbs_length (int *offset_buffer, int length)
{
  int upper, lower;

@@ -5640,34 +5561,25 @@
/* This is a separate function so that we can force an alloca cleanup
   afterwards.  */
#ifdef WCHAR
+/* string1 == string2 == NULL means string1/2, size1/2 and
+   mbs_offset1/2 need seting up in this function.  */
+/* We need wchar_t* buffers correspond to cstring1, cstring2.  */
+/* We need the size of wchar_t buffers correspond to csize1, csize2.  */
+/* mbs_offset1 & mbsoffset2 are offset buffer for optimizatoin.  See
+   convert_mbs_to_wc.  */
static int
-wcs_re_match_2_internal (bufp, cstring1, csize1, cstring2, csize2, pos,
-                        regs, stop, string1, size1, string2, size2,
-                        mbs_offset1, mbs_offset2)
-     struct re_pattern_buffer *bufp;
-     const char *cstring1, *cstring2;
-     int csize1, csize2;
-     int pos;
-     struct re_registers *regs;
-     int stop;
-     /* string1 == string2 == NULL means string1/2, size1/2 and
-       mbs_offset1/2 need seting up in this function.  */
-     /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
-     wchar_t *string1, *string2;
-     /* We need the size of wchar_t buffers correspond to csize1, csize2.  */
-     int size1, size2;
-     /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
-     int *mbs_offset1, *mbs_offset2;
+wcs_re_match_2_internal (struct re_pattern_buffer *bufp;
+                        const char *cstring1, int csize1,
+                        const char *cstring2, int csize2, int pos,
+                        struct re_registers *regs, int stop,
+                        wchar_t *string1, int size1,
+                        wchar_t *string2, int size2,
+                        int *mbs_offset1, int *mbs_offset2)
#else /* BYTE */
static int
-byte_re_match_2_internal (bufp, string1, size1,string2, size2, pos,
-                         regs, stop)
-     struct re_pattern_buffer *bufp;
-     const char *string1, *string2;
-     int size1, size2;
-     int pos;
-     struct re_registers *regs;
-     int stop;
+byte_re_match_2_internal (struct re_pattern_buffer *bufp, const char *string1,
+                         int size1, const char *string2, int size2, int pos,
+                         struct re_registers *regs, int stop)
#endif /* BYTE */
{
  /* General temporaries.  */
@@ -7696,9 +7608,8 @@
   We don't handle duplicates properly (yet).  */

static boolean
-PREFIX(group_match_null_string_p) (p, end, reg_info)
-    UCHAR_T **p, *end;
-    PREFIX(register_info_type) *reg_info;
+PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
+                                  PREFIX(register_info_type) *reg_info)
{
  int mcnt;
  /* Point to after the args to the start_memory.  */
@@ -7808,9 +7719,8 @@
   byte past the last. The alternative can contain groups.  */

static boolean
-PREFIX(alt_match_null_string_p) (p, end, reg_info)
-    UCHAR_T *p, *end;
-    PREFIX(register_info_type) *reg_info;
+PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end,
+                                PREFIX(register_info_type) *reg_info)
{
  int mcnt;
  UCHAR_T *p1 = p;
@@ -7845,9 +7755,8 @@
   Sets P to one after the op and its arguments, if any.  */

static boolean
-PREFIX(common_op_match_null_string_p) (p, end, reg_info)
-    UCHAR_T **p, *end;
-    PREFIX(register_info_type) *reg_info;
+PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
+                                      PREFIX(register_info_type) *reg_info)
{
  int mcnt;
  boolean ret;
@@ -7933,10 +7842,8 @@
   bytes; nonzero otherwise.  */

static int
-PREFIX(bcmp_translate) (s1, s2, len, translate)
-     const CHAR_T *s1, *s2;
-     register int len;
-     RE_TRANSLATE_TYPE translate;
+PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2, register int len,
+                       RE_TRANSLATE_TYPE translate)
{
  register const UCHAR_T *p1 = (const UCHAR_T *) s1;
  register const UCHAR_T *p2 = (const UCHAR_T *) s2;
@@ -7969,10 +7876,8 @@
   We call regex_compile to do the actual compilation.  */

const char *
-re_compile_pattern (pattern, length, bufp)
-     const char *pattern;
-     size_t length;
-     struct re_pattern_buffer *bufp;
+re_compile_pattern (const char *pattern, size_t length,
+                   struct re_pattern_buffer *bufp)
{
  reg_errcode_t ret;

@@ -8018,8 +7923,7 @@
   regcomp/regexec below without link errors.  */
weak_function
#endif
-re_comp (s)
-    const char *s;
+re_comp (const char *s)
{
  reg_errcode_t ret;

@@ -8069,8 +7973,7 @@
#ifdef _LIBC
weak_function
#endif
-re_exec (s)
-    const char *s;
+re_exec (const char *s)
{
  const int len = strlen (s);
  return
@@ -8119,10 +8022,7 @@
   the return codes and their meanings.)  */

int
-regcomp (preg, pattern, cflags)
-    regex_t *preg;
-    const char *pattern;
-    int cflags;
+regcomp (regex_t *preg, const char *pattern, int cflags)
{
  reg_errcode_t ret;
  reg_syntax_t syntax
@@ -8215,12 +8115,8 @@
   We return 0 if we find a match and REG_NOMATCH if not.  */

int
-regexec (preg, string, nmatch, pmatch, eflags)
-    const regex_t *preg;
-    const char *string;
-    size_t nmatch;
-    regmatch_t pmatch[];
-    int eflags;
+regexec (const regex_t *preg, const char *string, size_t nmatch,
+        regmatch_t *pmatch, int eflags)
{
  int ret;
  struct re_registers regs;
@@ -8282,11 +8178,7 @@
   from either regcomp or regexec.   We don't use PREG here.  */

size_t
-regerror (errcode, preg, errbuf, errbuf_size)
-    int errcode;
-    const regex_t *preg;
-    char *errbuf;
-    size_t errbuf_size;
+regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
{
  const char *msg;
  size_t msg_size;
@@ -8329,8 +8221,7 @@
/* Free dynamically allocated space used by PREG.  */

void
-regfree (preg)
-    regex_t *preg;
+regfree (regex_t *preg)
{
  if (preg->buffer != NULL)
    free (preg->buffer);
Index: rmdir.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/rmdir.c,v
retrieving revision 1.10
diff -u -r1.10 rmdir.c
--- rmdir.c     7 Aug 2000 15:48:18 -0000       1.10
+++ rmdir.c     24 Jul 2003 13:04:52 -0000
@@ -41,8 +41,7 @@
   Return 0 if successful, -1 if not.  */

int
-rmdir (dpath)
-     char *dpath;
+rmdir (char *dpath)
{
  pid_t cpid;
  int status;
Index: strchrnul.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/strchrnul.c,v
retrieving revision 1.1
diff -u -r1.1 strchrnul.c
--- strchrnul.c 10 Jun 2003 12:13:32 -0000      1.1
+++ strchrnul.c 24 Jul 2003 13:04:52 -0000
@@ -20,9 +20,7 @@

/* Find the first occurrence of C in S or the final NUL byte.  */
char *
-strchrnul (s, c_in)
-     const char *s;
-     int c_in;
+strchrnul (const char *s, int c_in)
{
  while (*s && (*s != c_in))
    s++;
Index: strerror.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/strerror.c,v
retrieving revision 1.1
diff -u -r1.1 strerror.c
--- strerror.c  3 Sep 2002 15:36:39 -0000       1.1
+++ strerror.c  24 Jul 2003 13:04:52 -0000
@@ -24,8 +24,7 @@
extern char *sys_errlist[];

char *
-strerror(n)
-int n;
+strerror(int n)
{
        static char mesg[30];

Index: xgethostname.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/xgethostname.c,v
retrieving revision 1.13
diff -u -r1.13 xgethostname.c
--- xgethostname.c      22 Jul 2003 22:56:34 -0000      1.13
+++ xgethostname.c      24 Jul 2003 13:04:52 -0000
@@ -46,7 +46,7 @@
#endif

char *
-xgethostname ()
+xgethostname (void)
{
  char *hostname;
  size_t size;
Index: xstrtod.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/xstrtod.c,v
retrieving revision 1.7
diff -u -r1.7 xstrtod.c
--- xstrtod.c   6 Jan 2000 21:01:06 -0000       1.7
+++ xstrtod.c   24 Jul 2003 13:04:52 -0000
@@ -43,10 +43,7 @@
   non-zero and don't modify *RESULT upon any failure.  */

int
-xstrtod (str, ptr, result)
-     const char *str;
-     const char **ptr;
-     double *result;
+xstrtod (const char *str, const char **ptr, double *result)
{
  double val;
  char *terminator;
Index: yesno.c
===================================================================
RCS file: /cvsroot/gnulib/gnulib/lib/yesno.c,v
retrieving revision 1.8
diff -u -r1.8 yesno.c
--- yesno.c     17 Nov 2001 13:29:42 -0000      1.8
+++ yesno.c     24 Jul 2003 13:04:52 -0000
@@ -33,7 +33,7 @@
int rpmatch ();

int
-yesno ()
+yesno (void)
{
  /* We make some assumptions here:
     a) leading white space in the response are not vital



Derek

--
               *8^)

Email: address@hidden

Get CVS support at <http://ximbiot.com>!
--
OPHELIA  Could beauty, my lord, have better commerce
 than with honesty?
HAMLET  Ay, truly.  For the power of beauty will sooner
 transform honesty from what it is to a bawd than the
 force of honesty can translate beauty into his likeness.
 This was sometime a paradox, but now the time gives it
 proof.  I did love you once.
OPHELIA  Indeed, my lord, you made me believe so.

    - Hamlet, Act III, Scene 1, Lines 109-116