Fix prototypes and parameters for compiling with enabled warnings.
authordrepper <drepper>
Thu, 27 Mar 1997 01:51:46 +0000 (01:51 +0000)
committerdrepper <drepper>
Thu, 27 Mar 1997 01:51:46 +0000 (01:51 +0000)
sunrpc/rpc_tblout.c
sunrpc/rpc_util.c

index 7a36247..4f62e2e 100644 (file)
  * Mountain View, California  94043
  */
 
-/* 
+/*
  * From: @(#)rpc_tblout.c 1.4 89/02/22 (C) 1988 SMI
  */
-char tblout_rcsid[] = 
+char tblout_rcsid[] =
   "$Id$";
 
 /*
@@ -47,124 +47,136 @@ char tblout_rcsid[] =
 #define TABCOUNT       5
 #define TABSTOP                (TABSIZE*TABCOUNT)
 
-static char tabstr[TABCOUNT+1] = "\t\t\t\t\t";
+static const char tabstr[TABCOUNT + 1] = "\t\t\t\t\t";
 
-static char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n";
-static char tbl_end[] = "};\n";
+static const char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n";
+static const char tbl_end[] = "};\n";
 
-static char null_entry[] = "\n\t(char *(*)())0,\n\
+static const char null_entry[] = "\n\t(char *(*)())0,\n\
  \t(xdrproc_t) xdr_void,\t\t\t0,\n\
  \t(xdrproc_t) xdr_void,\t\t\t0,\n";
 
 
-static char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n";
+static const char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n";
 
-static void write_table(const definition *def);
-static void printit(const char *prefix, const char *type);
+static void write_table (const definition * def);
+static void printit (const char *prefix, const char *type);
 
 void
-write_tables(void)
+write_tables (void)
 {
-       list *l;
-       definition *def;
-
-       f_print(fout, "\n");
-       for (l = defined; l != NULL; l = l->next) {
-               def = (definition *) l->val;
-               if (def->def_kind == DEF_PROGRAM) {
-                       write_table(def);
-               }
+  list *l;
+  definition *def;
+
+  f_print (fout, "\n");
+  for (l = defined; l != NULL; l = l->next)
+    {
+      def = (definition *) l->val;
+      if (def->def_kind == DEF_PROGRAM)
+       {
+         write_table (def);
        }
+    }
 }
 
 static void
-write_table(const definition *def)
+write_table (const definition * def)
 {
-       version_list *vp;
-       proc_list *proc;
-       int current;
-       int expected;
-       char progvers[100];
-       int warning;
-
-       for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-               warning = 0;
-               s_print(progvers, "%s_%s",
-                   locase(def->def_name), vp->vers_num);
-               /* print the table header */
-               f_print(fout, tbl_hdr, progvers);
-
-               if (nullproc(vp->procs)) {
-                       expected = 0;
-               } 
-               else {
-                       expected = 1;
-                       f_print(fout, null_entry);
-               }
-               for (proc = vp->procs; proc != NULL; proc = proc->next) {
-                       current = atoi(proc->proc_num);
-                       if (current != expected++) {
-                               f_print(fout,
-                       "\n/*\n * WARNING: table out of order\n */\n");
-                               if (warning == 0) {
-                                       f_print(stderr,
-                                   "WARNING %s table is out of order\n",
-                                           progvers);
-                                       warning = 1;
-                                       nonfatalerrors = 1;
-                               }
-                               expected = current + 1;
-                       }
-                       f_print(fout, "\n\t(char *(*)())RPCGEN_ACTION(");
-
-                       /* routine to invoke */
-                       if( Cflag && !newstyle )
-                         pvname_svc(proc->proc_name, vp->vers_num);
-                       else {
-                         if( newstyle )
-                           f_print( fout, "_");   /* calls internal func */
-                         pvname(proc->proc_name, vp->vers_num);
-                       }
-                       f_print(fout, "),\n");
-
-                       /* argument info */
-                       if( proc->arg_num > 1 )
-                         printit((char*) NULL, proc->args.argname );
-                       else  
-                         /* do we have to do something special for newstyle */
-                         printit( proc->args.decls->decl.prefix,
-                                 proc->args.decls->decl.type );
-                       /* result info */
-                       printit(proc->res_prefix, proc->res_type);
+  version_list *vp;
+  proc_list *proc;
+  int current;
+  int expected;
+  char progvers[100];
+  int warning;
+
+  for (vp = def->def.pr.versions; vp != NULL; vp = vp->next)
+    {
+      warning = 0;
+      s_print (progvers, "%s_%s",
+              locase (def->def_name), vp->vers_num);
+      /* print the table header */
+      f_print (fout, tbl_hdr, progvers);
+
+      if (nullproc (vp->procs))
+       {
+         expected = 0;
+       }
+      else
+       {
+         expected = 1;
+         f_print (fout, null_entry);
+       }
+      for (proc = vp->procs; proc != NULL; proc = proc->next)
+       {
+         current = atoi (proc->proc_num);
+         if (current != expected++)
+           {
+             f_print (fout,
+                      "\n/*\n * WARNING: table out of order\n */\n");
+             if (warning == 0)
+               {
+                 f_print (stderr,
+                          "WARNING %s table is out of order\n",
+                          progvers);
+                 warning = 1;
+                 nonfatalerrors = 1;
                }
-
-               /* print the table trailer */
-               f_print(fout, tbl_end);
-               f_print(fout, tbl_nproc, progvers, progvers, progvers);
+             expected = current + 1;
+           }
+         f_print (fout, "\n\t(char *(*)())RPCGEN_ACTION(");
+
+         /* routine to invoke */
+         if (Cflag && !newstyle)
+           pvname_svc (proc->proc_name, vp->vers_num);
+         else
+           {
+             if (newstyle)
+               f_print (fout, "_");    /* calls internal func */
+             pvname (proc->proc_name, vp->vers_num);
+           }
+         f_print (fout, "),\n");
+
+         /* argument info */
+         if (proc->arg_num > 1)
+           printit ((char *) NULL, proc->args.argname);
+         else
+           /* do we have to do something special for newstyle */
+           printit (proc->args.decls->decl.prefix,
+                    proc->args.decls->decl.type);
+         /* result info */
+         printit (proc->res_prefix, proc->res_type);
        }
+
+      /* print the table trailer */
+      f_print (fout, tbl_end);
+      f_print (fout, tbl_nproc, progvers, progvers, progvers);
+    }
 }
 
 static void
-printit(const char *prefix, const char *type)
+printit (const char *prefix, const char *type)
 {
-       int len;
-       int tabs;
-
-
-       len = fprintf(fout, "\txdr_%s,", stringfix(type));
-       /* account for leading tab expansion */
-       len += TABSIZE - 1;
-       /* round up to tabs required */
-       tabs = (TABSTOP - len + TABSIZE - 1)/TABSIZE;
-       f_print(fout, "%s", &tabstr[TABCOUNT-tabs]);
-
-       if (streq(type, "void")) {
-               f_print(fout, "0");
-       } else {
-               f_print(fout, "sizeof ( ");
-               /* XXX: should "follow" be 1 ??? */
-               ptype(prefix, type, 0);
-               f_print(fout, ")");
-       }
-       f_print(fout, ",\n");
+  int len;
+  int tabs;
+
+
+  len = fprintf (fout, "\txdr_%s,", stringfix (type));
+  /* account for leading tab expansion */
+  len += TABSIZE - 1;
+  /* round up to tabs required */
+  tabs = (TABSTOP - len + TABSIZE - 1) / TABSIZE;
+  f_print (fout, "%s", &tabstr[TABCOUNT - tabs]);
+
+  if (streq (type, "void"))
+    {
+      f_print (fout, "0");
+    }
+  else
+    {
+      f_print (fout, "sizeof ( ");
+      /* XXX: should "follow" be 1 ??? */
+      ptype (prefix, type, 0);
+      f_print (fout, ")");
+    }
+  f_print (fout, ",\n");
 }
index cb4561e..a5fa727 100644 (file)
  * Mountain View, California  94043
  */
 
-/* 
+/*
  * From: @(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI
  */
 char util_rcsid[] =
   "$Id$";
 
 /*
- * rpc_util.c, Utility routines for the RPC protocol compiler 
+ * rpc_util.c, Utility routines for the RPC protocol compiler
  */
 #include <stdio.h>
 #include <ctype.h>
@@ -63,425 +63,464 @@ FILE *fin;                        /* file pointer of current input */
 
 list *defined;                 /* list of defined things */
 
-static int findit(const definition *def, const char *type);
-static const char *fixit(const char *type, const char *orig);
-static int typedefed(const definition *def, const char *type);
-static const char *toktostr(tok_kind kind);
-static void printbuf(void);
-static void printwhere(void);
+static int findit (const definition * def, const char *type);
+static const char *fixit (const char *type, const char *orig);
+static int typedefed (const definition * def, const char *type);
+static const char *toktostr (tok_kind kind);
+static void printbuf (void);
+static void printwhere (void);
 
 /*
- * Reinitialize the world 
+ * Reinitialize the world
  */
 void
-reinitialize(void)
+reinitialize (void)
 {
-       memset(curline, 0, MAXLINESIZE);
-       where = curline;
-       linenum = 0;
-       defined = NULL;
+  memset (curline, 0, MAXLINESIZE);
+  where = curline;
+  linenum = 0;
+  defined = NULL;
 }
 
 /*
- * string equality 
+ * string equality
  */
 int
-streq(const char *a, const char *b)
+streq (const char *a, const char *b)
 {
-       return (strcmp(a, b) == 0);
+  return strcmp (a, b) == 0;
 }
 
 /*
- * find a value in a list 
+ * find a value in a list
  */
 definition *
-findval(list *lst, const char *val, 
-       int (*cmp)(const definition *, const char *))
+findval (list * lst, const char *val,
+        int (*cmp) (const definition *, const char *))
 {
-         
-       for (; lst != NULL; lst = lst->next) {
-               if (cmp(lst->val, val)) {
-                       return (lst->val);
-               }
+
+  for (; lst != NULL; lst = lst->next)
+    {
+      if (cmp (lst->val, val))
+       {
+         return lst->val;
        }
-       return NULL;
+    }
+  return NULL;
 }
 
 /*
- * store a value in a list 
+ * store a value in a list
  */
 void
-storeval(list **lstp, definition *val)
+storeval (list ** lstp, definition * val)
 {
-       list **l;
-       list *lst;
-
-       
-       for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
-       lst = ALLOC(list);
-       lst->val = val;
-       lst->next = NULL;
-       *l = lst;
+  list **l;
+  list *lst;
+
+
+  for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
+  lst = ALLOC (list);
+  lst->val = val;
+  lst->next = NULL;
+  *l = lst;
 }
 
 static int
-findit(const definition *def, const char *type)
+findit (const definition * def, const char *type)
 {
-       return (streq(def->def_name, type));
+  return streq (def->def_name, type);
 }
 
 static const char *
-fixit(const char *type, const char *orig)
+fixit (const char *type, const char *orig)
 {
-       definition *def;
+  definition *def;
 
-       def = findval(defined, type, findit);
-       if (def == NULL || def->def_kind != DEF_TYPEDEF) {
-               return (orig);
-       }
-       switch (def->def.ty.rel) {
-       case REL_VECTOR:
-               return (def->def.ty.old_type);
-       case REL_ALIAS:
-               return (fixit(def->def.ty.old_type, orig));
-       default:
-               return (orig);
-       }
+  def = findval (defined, type, findit);
+  if (def == NULL || def->def_kind != DEF_TYPEDEF)
+    {
+      return orig;
+    }
+  switch (def->def.ty.rel)
+    {
+    case REL_VECTOR:
+      return (def->def.ty.old_type);
+    case REL_ALIAS:
+      return (fixit (def->def.ty.old_type, orig));
+    default:
+      return orig;
+    }
 }
 
 const char *
-fixtype(const char *type)
+fixtype (const char *type)
 {
-       return (fixit(type, type));
+  return fixit (type, type);
 }
 
 const char *
-stringfix(const char *type)
+stringfix (const char *type)
 {
-       if (streq(type, "string")) {
-               return "wrapstring";
-       } 
-       else {
-               return type;
-       }
+  if (streq (type, "string"))
+    {
+      return "wrapstring";
+    }
+  else
+    {
+      return type;
+    }
 }
 
 void
-ptype(const char *prefix, const char *type, int follow)
+ptype (const char *prefix, const char *type, int follow)
 {
-       if (prefix != NULL) {
-               if (streq(prefix, "enum")) {
-                       f_print(fout, "enum ");
-               } else {
-                       f_print(fout, "struct ");
-               }
+  if (prefix != NULL)
+    {
+      if (streq (prefix, "enum"))
+       {
+         f_print (fout, "enum ");
        }
-       if (streq(type, "bool")) {
-               f_print(fout, "bool_t ");
-       } else if (streq(type, "string")) {
-               f_print(fout, "char *");
-       } else {
-               f_print(fout, "%s ", follow ? fixtype(type) : type);
+      else
+       {
+         f_print (fout, "struct ");
        }
+    }
+  if (streq (type, "bool"))
+    {
+      f_print (fout, "bool_t ");
+    }
+  else if (streq (type, "string"))
+    {
+      f_print (fout, "char *");
+    }
+  else
+    {
+      f_print (fout, "%s ", follow ? fixtype (type) : type);
+    }
 }
 
 static int
-typedefed(const definition *def, const char *type)
+typedefed (const definition * def, const char *type)
 {
-       if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) {
-               return (0);
-       } else {
-               return (streq(def->def_name, type));
-       }
+  if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL)
+    {
+      return 0;
+    }
+  else
+    {
+      return streq (def->def_name, type);
+    }
 }
 
 int
-isvectordef(const char *type, relation rel)
+isvectordef (const char *type, relation rel)
 {
-       definition *def;
-
-       for (;;) {
-               switch (rel) {
-               case REL_VECTOR:
-                       return (!streq(type, "string"));
-               case REL_ARRAY:
-                       return (0);
-               case REL_POINTER:
-                       return (0);
-               case REL_ALIAS:
-                       def = findval(defined, type, typedefed);
-                       if (def == NULL) {
-                               return (0);
-                       }
-                       type = def->def.ty.old_type;
-                       rel = def->def.ty.rel;
-               }
+  definition *def;
+
+  for (;;)
+    {
+      switch (rel)
+       {
+       case REL_VECTOR:
+         return !streq (type, "string");
+       case REL_ARRAY:
+         return 0;
+       case REL_POINTER:
+         return (0);
+       case REL_ALIAS:
+         def = findval (defined, type, typedefed);
+         if (def == NULL)
+           {
+             return 0;
+           }
+         type = def->def.ty.old_type;
+         rel = def->def.ty.rel;
        }
+    }
 }
 
 char *
-locase(const char *str)
+locase (const char *str)
 {
-       char c;
-       static char buf[100];
-       char *p = buf;
+  char c;
+  static char buf[100];
+  char *p = buf;
 
-       while ((c = *str++)!=0) {
-               *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
-       }
-       *p = 0;
-       return (buf);
+  while ((c = *str++) != 0)
+    {
+      *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
+    }
+  *p = 0;
+  return buf;
 }
 
 void
-pvname_svc(const char *pname, const char *vnum)
+pvname_svc (const char *pname, const char *vnum)
 {
-       f_print(fout, "%s_%s_svc", locase(pname), vnum);
+  f_print (fout, "%s_%s_svc", locase (pname), vnum);
 }
 
 void
-pvname(const char *pname, const char *vnum)
+pvname (const char *pname, const char *vnum)
 {
-       f_print(fout, "%s_%s", locase(pname), vnum);
+  f_print (fout, "%s_%s", locase (pname), vnum);
 }
 
 /*
- * print a useful (?) error message, and then die 
+ * print a useful (?) error message, and then die
  */
 void
-error(const char *msg)
+error (const char *msg)
 {
-       printwhere();
-       f_print(stderr, "%s, line %d: ", infilename, linenum);
-       f_print(stderr, "%s\n", msg);
-       crash();
+  printwhere ();
+  f_print (stderr, "%s, line %d: ", infilename, linenum);
+  f_print (stderr, "%s\n", msg);
+  crash ();
 }
 
 /*
  * Something went wrong, unlink any files that we may have created and then
- * die. 
+ * die.
  */
 void
-crash(void)
+crash (void)
 {
-       int i;
+  int i;
 
-       for (i = 0; i < nfiles; i++) {
-               (void) unlink(outfiles[i]);
-       }
-       exit(1);
+  for (i = 0; i < nfiles; i++)
+    {
+      (void) unlink (outfiles[i]);
+    }
+  exit (1);
 }
 
 void
-record_open(const char *file)
+record_open (const char *file)
 {
-       if (nfiles < NFILES) {
-               outfiles[nfiles++] = file;
-       } 
-       else {
-               f_print(stderr, "too many files!\n");
-               crash();
-       }
+  if (nfiles < NFILES)
+    {
+      outfiles[nfiles++] = file;
+    }
+  else
+    {
+      f_print (stderr, "too many files!\n");
+      crash ();
+    }
 }
 
 static char expectbuf[100];
 
 /*
- * error, token encountered was not the expected one 
+ * error, token encountered was not the expected one
  */
 void
-expected1(tok_kind exp1)
+expected1 (tok_kind exp1)
 {
-       s_print(expectbuf, "expected '%s'",
-               toktostr(exp1));
-       error(expectbuf);
+  s_print (expectbuf, "expected '%s'",
+          toktostr (exp1));
+  error (expectbuf);
 }
 
 /*
- * error, token encountered was not one of two expected ones 
+ * error, token encountered was not one of two expected ones
  */
 void
-expected2(tok_kind exp1, tok_kind exp2)
+expected2 (tok_kind exp1, tok_kind exp2)
 {
-       s_print(expectbuf, "expected '%s' or '%s'",
-               toktostr(exp1),
-               toktostr(exp2));
-       error(expectbuf);
+  s_print (expectbuf, "expected '%s' or '%s'",
+          toktostr (exp1),
+          toktostr (exp2));
+  error (expectbuf);
 }
 
 /*
- * error, token encountered was not one of 3 expected ones 
+ * error, token encountered was not one of 3 expected ones
  */
 void
-expected3(tok_kind exp1, tok_kind exp2, tok_kind exp3)
+expected3 (tok_kind exp1, tok_kind exp2, tok_kind exp3)
 {
-       s_print(expectbuf, "expected '%s', '%s' or '%s'",
-               toktostr(exp1),
-               toktostr(exp2),
-               toktostr(exp3));
-       error(expectbuf);
+  s_print (expectbuf, "expected '%s', '%s' or '%s'",
+          toktostr (exp1),
+          toktostr (exp2),
+          toktostr (exp3));
+  error (expectbuf);
 }
 
 void
-tabify(FILE *f, int tab)
+tabify (FILE * f, int tab)
 {
-       while (tab--) {
-               (void) fputc('\t', f);
-       }
+  while (tab--)
+    {
+      (void) fputc ('\t', f);
+    }
 }
 
 
-static token tokstrings[] = {
-                            {TOK_IDENT, "identifier"},
-                            {TOK_CONST, "const"},
-                            {TOK_RPAREN, ")"},
-                            {TOK_LPAREN, "("},
-                            {TOK_RBRACE, "}"},
-                            {TOK_LBRACE, "{"},
-                            {TOK_LBRACKET, "["},
-                            {TOK_RBRACKET, "]"},
-                            {TOK_STAR, "*"},
-                            {TOK_COMMA, ","},
-                            {TOK_EQUAL, "="},
-                            {TOK_COLON, ":"},
-                            {TOK_SEMICOLON, ";"},
-                            {TOK_UNION, "union"},
-                            {TOK_STRUCT, "struct"},
-                            {TOK_SWITCH, "switch"},
-                            {TOK_CASE, "case"},
-                            {TOK_DEFAULT, "default"},
-                            {TOK_ENUM, "enum"},
-                            {TOK_TYPEDEF, "typedef"},
-                            {TOK_INT, "int"},
-                            {TOK_SHORT, "short"},
-                            {TOK_LONG, "long"},
-                            {TOK_UNSIGNED, "unsigned"},
-                            {TOK_DOUBLE, "double"},
-                            {TOK_FLOAT, "float"},
-                            {TOK_CHAR, "char"},
-                            {TOK_STRING, "string"},
-                            {TOK_OPAQUE, "opaque"},
-                            {TOK_BOOL, "bool"},
-                            {TOK_VOID, "void"},
-                            {TOK_PROGRAM, "program"},
-                            {TOK_VERSION, "version"},
-                            {TOK_EOF, "??????"}
+static const token tokstrings[] =
+{
+  {TOK_IDENT, "identifier"},
+  {TOK_CONST, "const"},
+  {TOK_RPAREN, ")"},
+  {TOK_LPAREN, "("},
+  {TOK_RBRACE, "}"},
+  {TOK_LBRACE, "{"},
+  {TOK_LBRACKET, "["},
+  {TOK_RBRACKET, "]"},
+  {TOK_STAR, "*"},
+  {TOK_COMMA, ","},
+  {TOK_EQUAL, "="},
+  {TOK_COLON, ":"},
+  {TOK_SEMICOLON, ";"},
+  {TOK_UNION, "union"},
+  {TOK_STRUCT, "struct"},
+  {TOK_SWITCH, "switch"},
+  {TOK_CASE, "case"},
+  {TOK_DEFAULT, "default"},
+  {TOK_ENUM, "enum"},
+  {TOK_TYPEDEF, "typedef"},
+  {TOK_INT, "int"},
+  {TOK_SHORT, "short"},
+  {TOK_LONG, "long"},
+  {TOK_UNSIGNED, "unsigned"},
+  {TOK_DOUBLE, "double"},
+  {TOK_FLOAT, "float"},
+  {TOK_CHAR, "char"},
+  {TOK_STRING, "string"},
+  {TOK_OPAQUE, "opaque"},
+  {TOK_BOOL, "bool"},
+  {TOK_VOID, "void"},
+  {TOK_PROGRAM, "program"},
+  {TOK_VERSION, "version"},
+  {TOK_EOF, "??????"}
 };
 
 static const char *
-toktostr(tok_kind kind)
+toktostr (tok_kind kind)
 {
-       token *sp;
+  token *sp;
 
-       for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
-       return (sp->str);
+  for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
+  return (sp->str);
 }
 
 static void
-printbuf(void)
+printbuf (void)
 {
-       char c;
-       int i;
-       int cnt;
-
-#      define TABSIZE 4
-
-       for (i = 0; (c = curline[i])!=0; i++) {
-               if (c == '\t') {
-                       cnt = 8 - (i % TABSIZE);
-                       c = ' ';
-               } else {
-                       cnt = 1;
-               }
-               while (cnt--) {
-                       (void) fputc(c, stderr);
-               }
+  char c;
+  int i;
+  int cnt;
+
+#define TABSIZE 4
+
+  for (i = 0; (c = curline[i]) != 0; i++)
+    {
+      if (c == '\t')
+       {
+         cnt = 8 - (i % TABSIZE);
+         c = ' ';
+       }
+      else
+       {
+         cnt = 1;
        }
+      while (cnt--)
+       {
+         (void) fputc (c, stderr);
+       }
+    }
 }
 
 static void
-printwhere(void)
+printwhere (void)
 {
-       int i;
-       char c;
-       int cnt;
-
-       printbuf();
-       for (i = 0; i < where - curline; i++) {
-               c = curline[i];
-               if (c == '\t') {
-                       cnt = 8 - (i % TABSIZE);
-               } else {
-                       cnt = 1;
-               }
-               while (cnt--) {
-                       (void) fputc('^', stderr);
-               }
+  int i;
+  char c;
+  int cnt;
+
+  printbuf ();
+  for (i = 0; i < where - curline; i++)
+    {
+      c = curline[i];
+      if (c == '\t')
+       {
+         cnt = 8 - (i % TABSIZE);
+       }
+      else
+       {
+         cnt = 1;
+       }
+      while (cnt--)
+       {
+         (void) fputc ('^', stderr);
        }
-       (void) fputc('\n', stderr);
+    }
+  (void) fputc ('\n', stderr);
 }
 
-char * 
-make_argname(const char *pname, const char *vname) 
+char *
+make_argname (const char *pname, const char *vname)
 {
-       char *name;
-       
-       name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3);
-       if (!name) {
-               fprintf(stderr, "failed in malloc");
-               exit(1);
-       }
-       sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT);
-       return name;
+  char *name;
+
+  name = malloc (strlen (pname) + strlen (vname) + strlen (ARGEXT) + 3);
+  if (!name)
+    {
+      fprintf (stderr, "failed in malloc");
+      exit (1);
+    }
+  sprintf (name, "%s_%s_%s", locase (pname), vname, ARGEXT);
+  return name;
 }
 
 bas_type *typ_list_h;
 bas_type *typ_list_t;
 
 void
-add_type(int len, const char *type)
+add_type (int len, const char *type)
 {
   bas_type *ptr;
 
 
-  if ((ptr = malloc(sizeof(bas_type))) == NULL) {
-      fprintf(stderr, "failed in malloc");
-      exit(1);
-  }
+  if ((ptr = malloc (sizeof (bas_type))) == NULL)
+    {
+      fprintf (stderr, "failed in malloc");
+      exit (1);
+    }
 
-  ptr->name=type;
-  ptr->length=len;
-  ptr->next=NULL;
-  if(typ_list_t == NULL)
+  ptr->name = type;
+  ptr->length = len;
+  ptr->next = NULL;
+  if (typ_list_t == NULL)
     {
 
-      typ_list_t=ptr;
-      typ_list_h=ptr;
+      typ_list_t = ptr;
+      typ_list_h = ptr;
     }
   else
     {
 
-    typ_list_t->next=ptr;
-    typ_list_t=ptr;
+      typ_list_t->next = ptr;
+      typ_list_t = ptr;
     }
 
 }
 
 
-bas_type *find_type(const char *type)
+bas_type *
+find_type (const char *type)
 {
   bas_type *ptr;
 
-  ptr=typ_list_h;
+  ptr = typ_list_h;
 
 
-  while(ptr != NULL)
+  while (ptr != NULL)
     {
-    if(strcmp(ptr->name,type) == 0)
-           return(ptr);
-    else
-      ptr=ptr->next;
+      if (strcmp (ptr->name, type) == 0)
+       return ptr;
+      else
+       ptr = ptr->next;
     };
-return(NULL);
+  return NULL;
 }
-