X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fdoc%2Fchew.c;h=1695173970aaef463d48f86d502690d9726c22d6;hb=9c0ea783421477fccd2ca8e77e91983775be7d55;hp=bf3d2494c7b10626b8f27e2384532c3b797ab98b;hpb=5fbe0d878a691b9be42bb2bdebd027ac3dfd38c2;p=binutils-gdb.git

diff --git a/bfd/doc/chew.c b/bfd/doc/chew.c
index bf3d2494c7b..1695173970a 100644
--- a/bfd/doc/chew.c
+++ b/bfd/doc/chew.c
@@ -1,5 +1,5 @@
 /* chew
-   Copyright (C) 1990-2016 Free Software Foundation, Inc.
+   Copyright (C) 1990-2022 Free Software Foundation, Inc.
    Contributed by steve chamberlain @cygnus
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -81,7 +81,6 @@
 
    Foo.  */
 
-#include "ansidecl.h"
 #include <assert.h>
 #include <stdio.h>
 #include <ctype.h>
@@ -91,11 +90,6 @@
 #define DEF_SIZE 5000
 #define STACK 50
 
-int internal_wanted;
-int internal_mode;
-
-int warning;
-
 /* Here is a string type ...  */
 
 typedef struct buffer
@@ -105,43 +99,105 @@ typedef struct buffer
   unsigned long size;
 } string_type;
 
-#ifdef __STDC__
-static void init_string_with_size (string_type *, unsigned int);
-static void init_string (string_type *);
-static int find (string_type *, char *);
-static void write_buffer (string_type *, FILE *);
-static void delete_string (string_type *);
-static char *addr (string_type *, unsigned int);
-static char at (string_type *, unsigned int);
-static void catchar (string_type *, int);
-static void overwrite_string (string_type *, string_type *);
-static void catbuf (string_type *, char *, unsigned int);
-static void cattext (string_type *, char *);
-static void catstr (string_type *, string_type *);
-static void die (char *);
-#endif
+/* Compiled programs consist of arrays of these.  */
+
+typedef union
+{
+  void (*f) (void);
+  struct dict_struct *e;
+  char *s;
+  long l;
+} pcu;
+
+typedef struct dict_struct
+{
+  char *word;
+  struct dict_struct *next;
+  pcu *code;
+  int code_length;
+  int code_end;
+} dict_type;
+
+int internal_wanted;
+int internal_mode;
+
+int warning;
+
+string_type stack[STACK];
+string_type *tos;
+
+unsigned int idx = 0; /* Pos in input buffer */
+string_type *ptr; /* and the buffer */
+
+long istack[STACK];
+long *isp = &istack[0];
+
+dict_type *root;
+
+pcu *pc;
 
 static void
-init_string_with_size (buffer, size)
-     string_type *buffer;
-     unsigned int size;
+die (char *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+  exit (1);
+}
+
+void *
+xmalloc (size_t size)
+{
+  void *newmem;
+
+  if (size == 0)
+    size = 1;
+  newmem = malloc (size);
+  if (!newmem)
+    die ("out of memory");
+
+  return newmem;
+}
+
+void *
+xrealloc (void *oldmem, size_t size)
+{
+  void *newmem;
+
+  if (size == 0)
+    size = 1;
+  if (!oldmem)
+    newmem = malloc (size);
+  else
+    newmem = realloc (oldmem, size);
+  if (!newmem)
+    die ("out of memory");
+
+  return newmem;
+}
+
+char *
+xstrdup (const char *s)
+{
+  size_t len = strlen (s) + 1;
+  char *ret = xmalloc (len);
+  return memcpy (ret, s, len);
+}
+
+static void
+init_string_with_size (string_type *buffer, unsigned int size)
 {
   buffer->write_idx = 0;
   buffer->size = size;
-  buffer->ptr = (char *) malloc (size);
+  buffer->ptr = xmalloc (size);
 }
 
 static void
-init_string (buffer)
-     string_type *buffer;
+init_string (string_type *buffer)
 {
   init_string_with_size (buffer, DEF_SIZE);
 }
 
 static int
-find (str, what)
-     string_type *str;
-     char *what;
+find (string_type *str, char *what)
 {
   unsigned int i;
   char *p;
@@ -157,9 +213,7 @@ find (str, what)
 }
 
 static void
-write_buffer (buffer, f)
-     string_type *buffer;
-     FILE *f;
+write_buffer (string_type *buffer, FILE *f)
 {
   if (buffer->write_idx != 0
       && fwrite (buffer->ptr, buffer->write_idx, 1, f) != 1)
@@ -167,26 +221,20 @@ write_buffer (buffer, f)
 }
 
 static void
-delete_string (buffer)
-     string_type *buffer;
+delete_string (string_type *buffer)
 {
-  if (buffer->ptr)
-    free (buffer->ptr);
+  free (buffer->ptr);
   buffer->ptr = NULL;
 }
 
 static char *
-addr (buffer, idx)
-     string_type *buffer;
-     unsigned int idx;
+addr (string_type *buffer, unsigned int idx)
 {
   return buffer->ptr + idx;
 }
 
 static char
-at (buffer, pos)
-     string_type *buffer;
-     unsigned int pos;
+at (string_type *buffer, unsigned int pos)
 {
   if (pos >= buffer->write_idx)
     return 0;
@@ -194,23 +242,19 @@ at (buffer, pos)
 }
 
 static void
-catchar (buffer, ch)
-     string_type *buffer;
-     int ch;
+catchar (string_type *buffer, int ch)
 {
   if (buffer->write_idx == buffer->size)
     {
       buffer->size *= 2;
-      buffer->ptr = (char *) realloc (buffer->ptr, buffer->size);
+      buffer->ptr = xrealloc (buffer->ptr, buffer->size);
     }
 
   buffer->ptr[buffer->write_idx++] = ch;
 }
 
 static void
-overwrite_string (dst, src)
-     string_type *dst;
-     string_type *src;
+overwrite_string (string_type *dst, string_type *src)
 {
   free (dst->ptr);
   dst->size = src->size;
@@ -219,41 +263,32 @@ overwrite_string (dst, src)
 }
 
 static void
-catbuf (buffer, buf, len)
-     string_type *buffer;
-     char *buf;
-     unsigned int len;
+catbuf (string_type *buffer, char *buf, unsigned int len)
 {
   if (buffer->write_idx + len >= buffer->size)
     {
       while (buffer->write_idx + len >= buffer->size)
 	buffer->size *= 2;
-      buffer->ptr = (char *) realloc (buffer->ptr, buffer->size);
+      buffer->ptr = xrealloc (buffer->ptr, buffer->size);
     }
   memcpy (buffer->ptr + buffer->write_idx, buf, len);
   buffer->write_idx += len;
 }
 
 static void
-cattext (buffer, string)
-     string_type *buffer;
-     char *string;
+cattext (string_type *buffer, char *string)
 {
   catbuf (buffer, string, (unsigned int) strlen (string));
 }
 
 static void
-catstr (dst, src)
-     string_type *dst;
-     string_type *src;
+catstr (string_type *dst, string_type *src)
 {
   catbuf (dst, src->ptr, src->write_idx);
 }
 
 static unsigned int
-skip_white_and_stars (src, idx)
-     string_type *src;
-     unsigned int idx;
+skip_white_and_stars (string_type *src, unsigned int idx)
 {
   char c;
   while ((c = at (src, idx)),
@@ -268,9 +303,7 @@ skip_white_and_stars (src, idx)
 }
 
 static unsigned int
-skip_past_newline_1 (ptr, idx)
-     string_type *ptr;
-     unsigned int idx;
+skip_past_newline_1 (string_type *ptr, unsigned int idx)
 {
   while (at (ptr, idx)
 	 && at (ptr, idx) != '\n')
@@ -280,44 +313,8 @@ skip_past_newline_1 (ptr, idx)
   return idx;
 }
 
-/***********************************************************************/
-
-string_type stack[STACK];
-string_type *tos;
-
-unsigned int idx = 0; /* Pos in input buffer */
-string_type *ptr; /* and the buffer */
-typedef void (*stinst_type)();
-stinst_type *pc;
-stinst_type sstack[STACK];
-stinst_type *ssp = &sstack[0];
-long istack[STACK];
-long *isp = &istack[0];
-
-typedef int *word_type;
-
-struct dict_struct
-{
-  char *word;
-  struct dict_struct *next;
-  stinst_type *code;
-  int code_length;
-  int code_end;
-  int var;
-};
-
-typedef struct dict_struct dict_type;
-
-static void
-die (msg)
-     char *msg;
-{
-  fprintf (stderr, "%s\n", msg);
-  exit (1);
-}
-
 static void
-check_range ()
+check_range (void)
 {
   if (tos < stack)
     die ("underflow in string stack");
@@ -326,7 +323,7 @@ check_range ()
 }
 
 static void
-icheck_range ()
+icheck_range (void)
 {
   if (isp < istack)
     die ("underflow in integer stack");
@@ -334,63 +331,25 @@ icheck_range ()
     die ("overflow in integer stack");
 }
 
-#ifdef __STDC__
-static void exec (dict_type *);
-static void call (void);
-static void remchar (void), strip_trailing_newlines (void), push_number (void);
-static void push_text (void);
-static void remove_noncomments (string_type *, string_type *);
-static void print_stack_level (void);
-static void paramstuff (void), translatecomments (void);
-static void outputdots (void), courierize (void), bulletize (void);
-static void do_fancy_stuff (void);
-static int iscommand (string_type *, unsigned int);
-static int copy_past_newline (string_type *, unsigned int, string_type *);
-static void icopy_past_newline (void), kill_bogus_lines (void), indent (void);
-static void get_stuff_in_command (void), swap (void), other_dup (void);
-static void drop (void), idrop (void);
-static void icatstr (void), skip_past_newline (void), internalmode (void);
-static void maybecatstr (void);
-static char *nextword (char *, char **);
-dict_type *lookup_word (char *);
-static void perform (void);
-dict_type *newentry (char *);
-unsigned int add_to_definition (dict_type *, stinst_type);
-void add_intrinsic (char *, void (*)());
-void add_var (char *);
-void compile (char *);
-static void bang (void);
-static void atsign (void);
-static void hello (void);
-static void stdout_ (void);
-static void stderr_ (void);
-static void print (void);
-static void read_in (string_type *, FILE *);
-static void usage (void);
-static void chew_exit (void);
-#endif
-
 static void
-exec (word)
-     dict_type *word;
+exec (dict_type *word)
 {
   pc = word->code;
-  while (*pc)
-    (*pc) ();
+  while (pc->f)
+    pc->f ();
 }
 
 static void
-call ()
+call (void)
 {
-  stinst_type *oldpc = pc;
-  dict_type *e;
-  e = (dict_type *) (pc[1]);
+  pcu *oldpc = pc;
+  dict_type *e = pc[1].e;
   exec (e);
   pc = oldpc + 2;
 }
 
 static void
-remchar ()
+remchar (void)
 {
   if (tos->write_idx)
     tos->write_idx--;
@@ -398,7 +357,7 @@ remchar ()
 }
 
 static void
-strip_trailing_newlines ()
+strip_trailing_newlines (void)
 {
   while ((isspace ((unsigned char) at (tos, tos->write_idx - 1))
 	  || at (tos, tos->write_idx - 1) == '\n')
@@ -408,23 +367,23 @@ strip_trailing_newlines ()
 }
 
 static void
-push_number ()
+push_number (void)
 {
   isp++;
   icheck_range ();
   pc++;
-  *isp = (long) (*pc);
+  *isp = pc->l;
   pc++;
 }
 
 static void
-push_text ()
+push_text (void)
 {
   tos++;
   check_range ();
   init_string (tos);
   pc++;
-  cattext (tos, *((char **) pc));
+  cattext (tos, pc->s);
   pc++;
 }
 
@@ -434,9 +393,7 @@ push_text ()
    Blank lines are turned into one blank line.  */
 
 static void
-remove_noncomments (src, dst)
-     string_type *src;
-     string_type *dst;
+remove_noncomments (string_type *src, string_type *dst)
 {
   unsigned int idx = 0;
 
@@ -487,7 +444,7 @@ remove_noncomments (src, dst)
 }
 
 static void
-print_stack_level ()
+print_stack_level (void)
 {
   fprintf (stderr, "current string stack depth = %ld, ",
 	   (long) (tos - stack));
@@ -505,7 +462,7 @@ print_stack_level ()
  */
 
 static void
-paramstuff ()
+paramstuff (void)
 {
   unsigned int openp;
   unsigned int fname;
@@ -578,7 +535,7 @@ paramstuff ()
    and *} into comments */
 
 static void
-translatecomments ()
+translatecomments (void)
 {
   unsigned int idx = 0;
   string_type out;
@@ -610,7 +567,7 @@ translatecomments ()
 
 /* Mod tos so that only lines with leading dots remain */
 static void
-outputdots ()
+outputdots (void)
 {
   unsigned int idx = 0;
   string_type out;
@@ -659,7 +616,7 @@ outputdots ()
 
 /* Find lines starting with . and | and put example around them on tos */
 static void
-courierize ()
+courierize (void)
 {
   string_type out;
   unsigned int idx = 0;
@@ -746,7 +703,7 @@ courierize ()
    itemize, inplace at TOS*/
 
 static void
-bulletize ()
+bulletize (void)
 {
   unsigned int idx = 0;
   int on = 0;
@@ -801,7 +758,7 @@ bulletize ()
 /* Turn <<foo>> into @code{foo} in place at TOS*/
 
 static void
-do_fancy_stuff ()
+do_fancy_stuff (void)
 {
   unsigned int idx = 0;
   string_type out;
@@ -840,9 +797,7 @@ do_fancy_stuff ()
 /* A command is all upper case,and alone on a line.  */
 
 static int
-iscommand (ptr, idx)
-     string_type *ptr;
-     unsigned int idx;
+iscommand (string_type *ptr, unsigned int idx)
 {
   unsigned int len = 0;
   while (at (ptr, idx))
@@ -866,10 +821,7 @@ iscommand (ptr, idx)
 }
 
 static int
-copy_past_newline (ptr, idx, dst)
-     string_type *ptr;
-     unsigned int idx;
-     string_type *dst;
+copy_past_newline (string_type *ptr, unsigned int idx, string_type *dst)
 {
   int column = 0;
 
@@ -898,7 +850,7 @@ copy_past_newline (ptr, idx, dst)
 }
 
 static void
-icopy_past_newline ()
+icopy_past_newline (void)
 {
   tos++;
   check_range ();
@@ -911,7 +863,7 @@ icopy_past_newline ()
    Take the string at the top of the stack, do some prettying.  */
 
 static void
-kill_bogus_lines ()
+kill_bogus_lines (void)
 {
   int sl;
 
@@ -998,7 +950,7 @@ kill_bogus_lines ()
 }
 
 static void
-indent ()
+indent (void)
 {
   string_type out;
   int tab = 0;
@@ -1049,7 +1001,7 @@ indent ()
 }
 
 static void
-get_stuff_in_command ()
+get_stuff_in_command (void)
 {
   tos++;
   check_range ();
@@ -1065,7 +1017,7 @@ get_stuff_in_command ()
 }
 
 static void
-swap ()
+swap (void)
 {
   string_type t;
 
@@ -1076,7 +1028,7 @@ swap ()
 }
 
 static void
-other_dup ()
+other_dup (void)
 {
   tos++;
   check_range ();
@@ -1086,7 +1038,7 @@ other_dup ()
 }
 
 static void
-drop ()
+drop (void)
 {
   tos--;
   check_range ();
@@ -1095,7 +1047,7 @@ drop ()
 }
 
 static void
-idrop ()
+idrop (void)
 {
   isp--;
   icheck_range ();
@@ -1103,7 +1055,7 @@ idrop ()
 }
 
 static void
-icatstr ()
+icatstr (void)
 {
   tos--;
   check_range ();
@@ -1113,14 +1065,14 @@ icatstr ()
 }
 
 static void
-skip_past_newline ()
+skip_past_newline (void)
 {
   idx = skip_past_newline_1 (ptr, idx);
   pc++;
 }
 
 static void
-internalmode ()
+internalmode (void)
 {
   internal_mode = *(isp);
   isp--;
@@ -1129,7 +1081,7 @@ internalmode ()
 }
 
 static void
-maybecatstr ()
+maybecatstr (void)
 {
   if (internal_wanted == internal_mode)
     {
@@ -1142,9 +1094,7 @@ maybecatstr ()
 }
 
 char *
-nextword (string, word)
-     char *string;
-     char **word;
+nextword (char *string, char **word)
 {
   char *word_start;
   int idx;
@@ -1167,7 +1117,10 @@ nextword (string, word)
 	}
     }
   if (!*string)
-    return 0;
+    {
+      *word = NULL;
+      return NULL;
+    }
 
   word_start = string;
   if (*string == '"')
@@ -1194,7 +1147,7 @@ nextword (string, word)
 	}
     }
 
-  *word = (char *) malloc (length + 1);
+  *word = xmalloc (length + 1);
 
   dst = *word;
   src = word_start;
@@ -1225,14 +1178,11 @@ nextword (string, word)
   if (*string)
     return string + 1;
   else
-    return 0;
+    return NULL;
 }
 
-dict_type *root;
-
 dict_type *
-lookup_word (word)
-     char *word;
+lookup_word (char *word)
 {
   dict_type *ptr = root;
   while (ptr)
@@ -1243,7 +1193,7 @@ lookup_word (word)
     }
   if (warning)
     fprintf (stderr, "Can't find %s\n", word);
-  return 0;
+  return NULL;
 }
 
 static void
@@ -1255,17 +1205,16 @@ free_words (void)
     {
       dict_type *next;
 
-      if (ptr->word)
-	free (ptr->word);
+      free (ptr->word);
       if (ptr->code)
 	{
 	  int i;
-	  for (i = 0; i < ptr->code_length; i ++)
-	    if (ptr->code[i] == push_text
-		&& ptr->code[i + 1])
+	  for (i = 0; i < ptr->code_end - 1; i ++)
+	    if (ptr->code[i].f == push_text
+		&& ptr->code[i + 1].s)
 	      {
-		free (ptr->code[i + 1] - 1);
-		++ i;
+		free (ptr->code[i + 1].s - 1);
+		++i;
 	      }
 	  free (ptr->code);
 	}
@@ -1276,7 +1225,7 @@ free_words (void)
 }
 
 static void
-perform ()
+perform (void)
 {
   tos = stack;
 
@@ -1300,40 +1249,36 @@ perform ()
 	    {
 	      if (warning)
 		fprintf (stderr, "warning, %s is not recognised\n", next);
-	      skip_past_newline ();
+	      idx = skip_past_newline_1 (ptr, idx);
 	    }
 	  free (next);
 	}
       else
-	skip_past_newline ();
+	idx = skip_past_newline_1 (ptr, idx);
     }
 }
 
 dict_type *
-newentry (word)
-     char *word;
+newentry (char *word)
 {
-  dict_type *new_d = (dict_type *) malloc (sizeof (dict_type));
+  dict_type *new_d = xmalloc (sizeof (*new_d));
   new_d->word = word;
   new_d->next = root;
   root = new_d;
-  new_d->code = (stinst_type *) malloc (sizeof (stinst_type));
+  new_d->code = xmalloc (sizeof (*new_d->code));
   new_d->code_length = 1;
   new_d->code_end = 0;
   return new_d;
 }
 
 unsigned int
-add_to_definition (entry, word)
-     dict_type *entry;
-     stinst_type word;
+add_to_definition (dict_type *entry, pcu word)
 {
   if (entry->code_end == entry->code_length)
     {
       entry->code_length += 2;
-      entry->code =
-	(stinst_type *) realloc ((char *) (entry->code),
-				 entry->code_length * sizeof (word_type));
+      entry->code = xrealloc (entry->code,
+			      entry->code_length * sizeof (*entry->code));
     }
   entry->code[entry->code_end] = word;
 
@@ -1341,28 +1286,17 @@ add_to_definition (entry, word)
 }
 
 void
-add_intrinsic (name, func)
-     char *name;
-     void (*func) ();
+add_intrinsic (char *name, void (*func) (void))
 {
-  dict_type *new_d = newentry (strdup (name));
-  add_to_definition (new_d, func);
-  add_to_definition (new_d, 0);
+  dict_type *new_d = newentry (xstrdup (name));
+  pcu p = { func };
+  add_to_definition (new_d, p);
+  p.f = 0;
+  add_to_definition (new_d, p);
 }
 
 void
-add_var (name)
-     char *name;
-{
-  dict_type *new_d = newentry (name);
-  add_to_definition (new_d, push_number);
-  add_to_definition (new_d, (stinst_type) (&(new_d->var)));
-  add_to_definition (new_d, 0);
-}
-
-void
-compile (string)
-     char *string;
+compile (char *string)
 {
   /* Add words to the dictionary.  */
   char *word;
@@ -1370,22 +1304,24 @@ compile (string)
   string = nextword (string, &word);
   while (string && *string && word[0])
     {
-      if (strcmp (word, "var") == 0)
-	{
-	  free (word);
-	  string = nextword (string, &word);
-	  add_var (word);
-	  string = nextword (string, &word);
-	}
-      else if (word[0] == ':')
+      if (word[0] == ':')
 	{
 	  dict_type *ptr;
+	  pcu p;
 
 	  /* Compile a word and add to dictionary.  */
 	  free (word);
 	  string = nextword (string, &word);
+	  if (!string)
+	    continue;
 	  ptr = newentry (word);
 	  string = nextword (string, &word);
+	  if (!string)
+	    {
+	      free (ptr->code);
+	      free (ptr);
+	      continue;
+	    }
 	  
 	  while (word[0] != ';')
 	    {
@@ -1394,8 +1330,10 @@ compile (string)
 		case '"':
 		  /* got a string, embed magic push string
 		     function */
-		  add_to_definition (ptr, push_text);
-		  add_to_definition (ptr, (stinst_type) (word + 1));
+		  p.f = push_text;
+		  add_to_definition (ptr, p);
+		  p.s = word + 1;
+		  add_to_definition (ptr, p);
 		  break;
 		case '0':
 		case '1':
@@ -1409,21 +1347,25 @@ compile (string)
 		case '9':
 		  /* Got a number, embedd the magic push number
 		     function */
-		  add_to_definition (ptr, push_number);
-		  add_to_definition (ptr, (stinst_type) atol (word));
+		  p.f = push_number;
+		  add_to_definition (ptr, p);
+		  p.l = atol (word);
+		  add_to_definition (ptr, p);
 		  free (word);
 		  break;
 		default:
-		  add_to_definition (ptr, call);
-		  add_to_definition (ptr, (stinst_type) lookup_word (word));
+		  p.f = call;
+		  add_to_definition (ptr, p);
+		  p.e = lookup_word (word);
+		  add_to_definition (ptr, p);
 		  free (word);
 		}
 
 	      string = nextword (string, &word);
 	    }
-	  add_to_definition (ptr, 0);
+	  p.f = 0;
+	  add_to_definition (ptr, p);
 	  free (word);
-	  word = NULL;
 	  string = nextword (string, &word);
 	}
       else
@@ -1431,12 +1373,11 @@ compile (string)
 	  fprintf (stderr, "syntax error at %s\n", string - 1);
 	}
     }
-  if (word)
-    free (word);
+  free (word);
 }
 
 static void
-bang ()
+bang (void)
 {
   *(long *) ((isp[0])) = isp[-1];
   isp -= 2;
@@ -1445,21 +1386,21 @@ bang ()
 }
 
 static void
-atsign ()
+atsign (void)
 {
   isp[0] = *(long *) (isp[0]);
   pc++;
 }
 
 static void
-hello ()
+hello (void)
 {
   printf ("hello\n");
   pc++;
 }
 
 static void
-stdout_ ()
+stdout_ (void)
 {
   isp++;
   icheck_range ();
@@ -1468,7 +1409,7 @@ stdout_ ()
 }
 
 static void
-stderr_ ()
+stderr_ (void)
 {
   isp++;
   icheck_range ();
@@ -1477,7 +1418,7 @@ stderr_ ()
 }
 
 static void
-print ()
+print (void)
 {
   if (*isp == 1)
     write_buffer (tos, stdout);
@@ -1493,9 +1434,7 @@ print ()
 }
 
 static void
-read_in (str, file)
-     string_type *str;
-     FILE *file;
+read_in (string_type *str, FILE *file)
 {
   char buff[10000];
   unsigned int r;
@@ -1511,7 +1450,7 @@ read_in (str, file)
 }
 
 static void
-usage ()
+usage (void)
 {
   fprintf (stderr, "usage: -[d|i|g] <file >file\n");
   exit (33);
@@ -1523,15 +1462,13 @@ usage ()
    is a pointless waste of time.  */
 
 static void
-chew_exit ()
+chew_exit (void)
 {
   exit (0);
 }
 
 int
-main (ac, av)
-     int ac;
-     char *av[];
+main (int ac, char *av[])
 {
   unsigned int i;
   string_type buffer;