Updated to fedora-glibc-20080703T1203
[kopensolaris-gnu/glibc.git] / sunrpc / rpc_main.c
index a7e1807..bda432d 100644 (file)
@@ -31,8 +31,6 @@
 /*
  * From @(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI;
  */
-char main_rcsid[] =
-  "$Id$";
 
 /*
  * rpc_main.c, Top level of the RPC protocol compiler.
@@ -42,95 +40,102 @@ char main_rcsid[] =
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
+#include <libintl.h>
 #include <ctype.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/file.h>
 #include <sys/stat.h>
+#include <sys/wait.h>
 #include "rpc_parse.h"
 #include "rpc_util.h"
 #include "rpc_scan.h"
 #include "proto.h"
 
-
 #define EXTEND 1               /* alias for TRUE */
-#define DONT_EXTEND    0               /* alias for FALSE */
-
-#define SVR4_CPP "/usr/ccs/lib/cpp"
-#define SUNOS_CPP "/lib/cpp"
-static int cppDefined = 0;          /* explicit path for C preprocessor */
-
-struct commandline {
-       int cflag;              /* xdr C routines */
-       int hflag;              /* header file */
-       int lflag;              /* client side stubs */
-       int mflag;              /* server side stubs */
-       int nflag;              /* netid flag */
-       int sflag;              /* server stubs for the given transport */
-       int tflag;              /* dispatch Table file */
-       int Ssflag;             /* produce server sample code */
-       int Scflag;             /* produce client sample code */
-       const char *infile;     /* input module name */
-       const char *outfile;    /* output module name */
-};
+#define DONT_EXTEND    0       /* alias for FALSE */
+
+struct commandline
+  {
+    int cflag;                 /* xdr C routines */
+    int hflag;                 /* header file */
+    int lflag;                 /* client side stubs */
+    int mflag;                 /* server side stubs */
+    int nflag;                 /* netid flag */
+    int sflag;                 /* server stubs for the given transport */
+    int tflag;                 /* dispatch Table file */
+    int Ssflag;                        /* produce server sample code */
+    int Scflag;                        /* produce client sample code */
+    int makefileflag;          /* Generate a template Makefile */
+    const char *infile;                /* input module name */
+    const char *outfile;       /* output module name */
+  };
 
 
 static const char *cmdname;
 
+#define SVR4_CPP "/usr/ccs/lib/cpp"
+#define SUNOS_CPP "/lib/cpp"
+
 static const char *svcclosetime = "120";
-static const char *CPP = SVR4_CPP;
-static char CPPFLAGS[] = "-C";
+static int cppDefined; /* explicit path for C preprocessor */
+static const char *CPP = SUNOS_CPP;
+static const char CPPFLAGS[] = "-C";
 static char *pathbuf;
-static const char *allv[] = {
-       "rpcgen", "-s", "udp", "-s", "tcp",
+static int cpp_pid;
+static const char *allv[] =
+{
+  "rpcgen", "-s", "udp", "-s", "tcp"
 };
-static int allc = sizeof(allv)/sizeof(allv[0]);
-static const char *allnv[] = {
-       "rpcgen", "-s", "netpath",
+static int allc = sizeof (allv) / sizeof (allv[0]);
+static const char *allnv[] =
+{
+  "rpcgen", "-s", "netpath",
 };
-static int allnc = sizeof(allnv)/sizeof(allnv[0]);
+static int allnc = sizeof (allnv) / sizeof (allnv[0]);
 
 /*
  * machinations for handling expanding argument list
  */
-static void addarg(const char *);       /* add another argument to the list */
-static void putarg(int, const char *); /* put argument at specified location */
-static void clear_args(void);          /* clear argument list */
-static void checkfiles(const char *, const char *);
-                                        /* check if out file already exists */
-
-static void clear_args(void);
-static char *extendfile(const char *file, const char *ext);
-static void open_output(const char *infile, const char *outfile);
-static void add_warning(void);
-static void clear_args(void);
-static void find_cpp(void);
-static void open_input(const char *infile, const char *define);
-static int check_nettype(const char *name, const char *list_to_check[]);
-static void c_output(const char *infile, const char *define,
-                    int extend, const char *outfile);
-static void h_output(const char *infile, const char *define,
-                    int extend, const char *outfile);
-static void s_output(int argc, const char *argv[], const char *infile,
-                    const char *define, int extend,
-                    const char *outfile, int nomain, int netflag);
-static void l_output(const char *infile, const char *define,
-                    int extend, const char *outfile);
-static void t_output(const char *infile, const char *define,
-                    int extend, const char *outfile);
-static void svc_output(const char *infile, const char *define,
-                      int extend, const char *outfile);
-static void clnt_output(const char *infile, const char *define,
+static void addarg (const char *);     /* add another argument to the list */
+static void putarg (int, const char *);                /* put argument at specified location */
+static void clear_args (void); /* clear argument list */
+static void checkfiles (const char *, const char *);
+                                      /* check if out file already exists */
+
+static void clear_args (void);
+static char *extendfile (const char *file, const char *ext);
+static void open_output (const char *infile, const char *outfile);
+static void add_warning (void);
+static void clear_args (void);
+static void find_cpp (void);
+static void open_input (const char *infile, const char *define);
+static int check_nettype (const char *name, const char *list_to_check[]);
+static void c_output (const char *infile, const char *define,
+                     int extend, const char *outfile);
+static void h_output (const char *infile, const char *define,
+                     int extend, const char *outfile);
+static void s_output (int argc, const char *argv[], const char *infile,
+                     const char *define, int extend,
+                     const char *outfile, int nomain, int netflag);
+static void l_output (const char *infile, const char *define,
+                     int extend, const char *outfile);
+static void t_output (const char *infile, const char *define,
+                     int extend, const char *outfile);
+static void svc_output (const char *infile, const char *define,
                        int extend, const char *outfile);
-static int do_registers(int argc, const char *argv[]);
-static void addarg(const char *cp);
-static void putarg(int whereto, const char *cp);
-static void checkfiles(const char *infile, const char *outfile);
-static int parseargs(int argc, const char *argv[], struct commandline *cmd);
-static void usage(void);
-static void options_usage(void);
-static void c_initialize(void);
-static char *generate_guard(const char *pathname);
+static void clnt_output (const char *infile, const char *define,
+                        int extend, const char *outfile);
+static void mkfile_output (struct commandline *cmd);
+static int do_registers (int argc, const char *argv[]);
+static void addarg (const char *cp);
+static void putarg (int whereto, const char *cp);
+static void checkfiles (const char *infile, const char *outfile);
+static int parseargs (int argc, const char *argv[], struct commandline *cmd);
+static void usage (void) __attribute__ ((noreturn));
+static void options_usage (void) __attribute__ ((noreturn));
+static void c_initialize (void);
+static char *generate_guard (const char *pathname);
 
 
 #define ARGLISTLEN     20
@@ -140,235 +145,282 @@ static const char *arglist[ARGLISTLEN];
 static int argcount = FIXEDARGS;
 
 
-int nonfatalerrors;    /* errors */
-int inetdflag/* = 1*/; /* Support for inetd */ /* is now the default */
-int pmflag;            /* Support for port monitors */
-int logflag;           /* Use syslog instead of fprintf for errors */
-int tblflag;           /* Support for dispatch table file */
+int nonfatalerrors;            /* errors */
+int inetdflag /* = 1 */ ;      /* Support for inetd *//* is now the default */
+int pmflag;                    /* Support for port monitors */
+int logflag;                   /* Use syslog instead of fprintf for errors */
+int tblflag;                   /* Support for dispatch table file */
+int mtflag;                    /* Support for MT */
 
 #define INLINE 3
 /*length at which to start doing an inline */
 
-int inlineflag=INLINE; /* length at which to start doing an inline. 3 = default
-               if 0, no xdr_inline code */
+int inlineflag = INLINE;       /* length at which to start doing an inline. 3 = default
+                                  if 0, no xdr_inline code */
 
-int indefinitewait;    /* If started by port monitors, hang till it wants */
-int exitnow;           /* If started by port monitors, exit after the call */
-int timerflag;         /* TRUE if !indefinite && !exitnow */
-int newstyle;           /* newstyle of passing arguments (by value) */
+int indefinitewait;            /* If started by port monitors, hang till it wants */
+int exitnow;                   /* If started by port monitors, exit after the call */
+int timerflag;                 /* TRUE if !indefinite && !exitnow */
+int newstyle;                  /* newstyle of passing arguments (by value) */
 #ifdef __GNU_LIBRARY__
-int Cflag = 1 ;         /* ANSI C syntax */
+int Cflag = 1;                 /* ANSI C syntax */
 #else
-int Cflag = 0 ;         /* ANSI C syntax */
+int Cflag;                     /* ANSI C/C++ syntax */
 #endif
-static int allfiles;   /* generate all files */
+int CCflag;                    /* C++ files */
+static int allfiles;           /* generate all files */
 #ifdef __GNU_LIBRARY__
-int tirpcflag = 0;       /* generating code for tirpc, by default */
+int tirpcflag;                 /* generating code for tirpc, by default */
 #else
-int tirpcflag = 1;       /* generating code for tirpc, by default */
-#endif
-
-#ifdef __GNU_LIBRARY__
-int building_libc = 0; /* running as part of libc built process */
+int tirpcflag = 1;             /* generating code for tirpc, by default */
 #endif
+xdrfunc *xdrfunc_head;         /* xdr function list */
+xdrfunc *xdrfunc_tail;         /* xdr function list */
 
 int
-main(int argc, const char *argv[])
+main (int argc, const char *argv[])
 {
-       struct commandline cmd;
+  struct commandline cmd;
 
-       (void) memset((char *)&cmd, 0, sizeof (struct commandline));
-       clear_args();
-       if (!parseargs(argc, argv, &cmd))
-               usage();
+  (void) memset ((char *) &cmd, 0, sizeof (struct commandline));
+  clear_args ();
+  if (!parseargs (argc, argv, &cmd))
+    usage ();
 
-       if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
-               cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag ) {
-         checkfiles(cmd.infile, cmd.outfile);
+  if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
+      cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag)
+    {
+      checkfiles (cmd.infile, cmd.outfile);
+    }
+  else
+    checkfiles (cmd.infile, NULL);
+
+  if (cmd.cflag)
+    c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
+  else if (cmd.hflag)
+    h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
+  else if (cmd.lflag)
+    l_output (cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
+  else if (cmd.sflag || cmd.mflag || (cmd.nflag))
+    s_output (argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
+             cmd.outfile, cmd.mflag, cmd.nflag);
+  else if (cmd.tflag)
+    t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
+  else if (cmd.Ssflag)
+    svc_output (cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
+  else if (cmd.Scflag)
+    clnt_output (cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
+  else if (cmd.makefileflag)
+    mkfile_output (&cmd);
+  else
+    {
+      /* the rescans are required, since cpp may effect input */
+      c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
+      reinitialize ();
+      h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");
+      reinitialize ();
+      l_output (cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
+      reinitialize ();
+      if (inetdflag || !tirpcflag)
+       s_output (allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
+                 "_svc.c", cmd.mflag, cmd.nflag);
+      else
+       s_output (allnc, allnv, cmd.infile, "-DRPC_SVC",
+                 EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
+      if (tblflag)
+       {
+         reinitialize ();
+         t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
        }
-       else
-         checkfiles(cmd.infile,NULL);
-
-       if (cmd.cflag) {
-               c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
-       } else if (cmd.hflag) {
-               h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
-       } else if (cmd.lflag) {
-               l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
-       } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
-               s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
-                        cmd.outfile, cmd.mflag, cmd.nflag);
-       } else if (cmd.tflag) {
-               t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
-       } else if  (cmd.Ssflag) {
-                 svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
-       } else if (cmd.Scflag) {
-                 clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
-       } else {
-               /* the rescans are required, since cpp may effect input */
-               c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
-               reinitialize();
-               h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h");
-               reinitialize();
-               l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
-               reinitialize();
-               if (inetdflag || !tirpcflag )
-                       s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
-                                "_svc.c", cmd.mflag, cmd.nflag);
-               else
-                       s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
-                                EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
-               if (tblflag) {
-                       reinitialize();
-                       t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
-               }
-               if (allfiles) {
-                 reinitialize();
-                 svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
-               }
-               if (allfiles) {
-                 reinitialize();
-                 clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
-               }
+      if (allfiles)
+       {
+         reinitialize ();
+         svc_output (cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
+         reinitialize ();
+         clnt_output (cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
+       }
+      if (allfiles || (cmd.makefileflag == 1))
+       {
+         reinitialize ();
+         mkfile_output (&cmd);
        }
-       exit(nonfatalerrors);
-       /* NOTREACHED */
+    }
+
+  return nonfatalerrors;
 }
 
 /*
  * add extension to filename
  */
 static char *
-extendfile(const char *file, const char *ext)
+extendfile (const char *file, const char *ext)
 {
-       char *res;
-       const char *p;
-
-       res = alloc(strlen(file) + strlen(ext) + 1);
-       if (res == NULL) {
-               abort();
-       }
-       p = strrchr(file, '.');
-       if (p == NULL) {
-               p = file + strlen(file);
-       }
-       (void) strcpy(res, file);
-       (void) strcpy(res + (p - file), ext);
-       return (res);
+  char *res;
+  const char *p;
+
+  res = alloc (strlen (file) + strlen (ext) + 1);
+  if (res == NULL)
+    abort ();
+  p = strrchr (file, '.');
+  if (p == NULL)
+    p = file + strlen (file);
+  strcpy (res, file);
+  strcpy (res + (p - file), ext);
+  return res;
 }
 
 /*
  * Open output file with given extension
  */
 static void
-open_output(const char *infile, const char *outfile)
+open_output (const char *infile, const char *outfile)
 {
+  if (outfile == NULL)
+    {
+      fout = stdout;
+      return;
+    }
 
-       if (outfile == NULL) {
-               fout = stdout;
-               return;
-       }
-
-       if (infile != NULL && streq(outfile, infile)) {
-               f_print(stderr, "%s: output would overwrite %s\n", cmdname,
-                       infile);
-               crash();
-       }
-       fout = fopen(outfile, "w");
-       if (fout == NULL) {
-               f_print(stderr, "%s: unable to open ", cmdname);
-               perror(outfile);
-               crash();
-       }
-       record_open(outfile);
+  if (infile != NULL && streq (outfile, infile))
+    {
+      fprintf (stderr, _ ("%s: output would overwrite %s\n"), cmdname,
+              infile);
+      crash ();
+    }
+  fout = fopen (outfile, "w");
+  if (fout == NULL)
+    {
+      fprintf (stderr, _ ("%s: unable to open %s: %m\n"), cmdname, outfile);
+      crash ();
+    }
+  record_open (outfile);
 }
 
+/* Close the output file and check for write errors.  */
 static void
-add_warning(void)
+close_output (const char *outfile)
 {
-       f_print(fout, "/*\n");
-       f_print(fout, " * Please do not edit this file.\n");
-       f_print(fout, " * It was generated using rpcgen.\n");
-       f_print(fout, " */\n\n");
+  if (fclose (fout) == EOF)
+    {
+      fprintf (stderr, _("%s: while writing output %s: %m"), cmdname,
+              outfile ?: "<stdout>");
+      crash ();
+    }
 }
 
 static void
-add_stdheaders(void)
+add_warning (void)
 {
-       f_print(fout, "#include <rpc/types.h>\n");
-       f_print(fout, "#include <rpc/xdr.h>\n\n");
+  fprintf (fout, "/*\n");
+  fprintf (fout, " * Please do not edit this file.\n");
+  fprintf (fout, " * It was generated using rpcgen.\n");
+  fprintf (fout, " */\n\n");
 }
 
 /* clear list of arguments */
-static void clear_args(void)
+static void
+clear_args (void)
 {
   int i;
-  for( i=FIXEDARGS; i<ARGLISTLEN; i++ )
+  for (i = FIXEDARGS; i < ARGLISTLEN; ++i)
     arglist[i] = NULL;
   argcount = FIXEDARGS;
 }
 
 /* make sure that a CPP exists */
-static void find_cpp(void)
+static void
+find_cpp (void)
 {
   struct stat buf;
 
-  if (stat(CPP, &buf) < 0 )  { /* SVR4 or explicit cpp does not exist */
-    if (cppDefined) {
-      fprintf( stderr, "cannot find C preprocessor: %s \n", CPP );
-      crash();
-    } else {                   /* try the other one */
-      CPP = SUNOS_CPP;
-      if( stat( CPP, &buf ) < 0 ) { /* can't find any cpp */
-       fprintf( stderr, "cannot find any C preprocessor (cpp)\n" );
-       crash();
-      }
+  if (stat (CPP, &buf) < 0)
+    {                          /* /lib/cpp or explicit cpp does not exist */
+      if (cppDefined)
+       {
+         fprintf (stderr, _ ("cannot find C preprocessor: %s \n"), CPP);
+         crash ();
+       }
+      else
+       {                       /* try the other one */
+         CPP = SVR4_CPP;
+         if (stat (CPP, &buf) < 0)
+           {                   /* can't find any cpp */
+             fputs (_ ("cannot find any C preprocessor (cpp)\n"), stdout);
+             crash ();
+           }
+       }
     }
-  }
 }
 
 /*
  * Open input file with given define for C-preprocessor
  */
 static void
-open_input(const char *infile, const char *define)
+open_input (const char *infile, const char *define)
 {
-       int pd[2];
+  int pd[2];
 
-       infilename = (infile == NULL) ? "<stdin>" : infile;
-       (void) pipe(pd);
-       switch (fork()) {
-       case 0:
-#ifdef __GNU_LIBRARY__
-               /* While building libc we don't want to use the libc from
-                  the build directory which may be incompatible with the
-                  installed dynamic linker.  */
-               if (building_libc)
-                 unsetenv ("LD_LIBRARY_PATH");
-#endif
-               find_cpp();
-               putarg(0, CPP);
-               putarg(1, CPPFLAGS);
-               addarg(define);
-               addarg(infile);
-               addarg((char *)NULL);
-               (void) close(1);
-               (void) dup2(pd[1], 1);
-               (void) close(pd[0]);
-               execv(arglist[0], (char **)arglist);
-               perror("execv");
-               exit(1);
-       case -1:
-               perror("fork");
-               exit(1);
-       }
-       (void) close(pd[1]);
-       fin = fdopen(pd[0], "r");
-       if (fin == NULL) {
-               f_print(stderr, "%s: ", cmdname);
-               perror(infilename);
-               crash();
-       }
+  infilename = (infile == NULL) ? "<stdin>" : infile;
+  if (pipe (pd) != 0)
+    {
+      perror ("pipe");
+      exit (1);
+    }
+  cpp_pid = fork ();
+  switch (cpp_pid)
+    {
+    case 0:
+      find_cpp ();
+      putarg (0, CPP);
+      putarg (1, CPPFLAGS);
+      addarg (define);
+      if (infile)
+       addarg (infile);
+      addarg ((char *) NULL);
+      close (1);
+      dup2 (pd[1], 1);
+      close (pd[0]);
+      execv (arglist[0], (char **) arglist);
+      perror ("execv");
+      exit (1);
+    case -1:
+      perror ("fork");
+      exit (1);
+    }
+  close (pd[1]);
+  fin = fdopen (pd[0], "r");
+  if (fin == NULL)
+    {
+      fprintf (stderr, "%s: ", cmdname);
+      perror (infilename);
+      crash ();
+    }
+}
+
+/* Close the connection to the C-preprocessor and check for successfull
+   termination.  */
+static void
+close_input (void)
+{
+  int status;
+
+  fclose (fin);
+  /* Check the termination status.  */
+  if (waitpid (cpp_pid, &status, 0) < 0)
+    {
+      perror ("waitpid");
+      crash ();
+    }
+  if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
+    {
+      if (WIFSIGNALED (status))
+       fprintf (stderr, _("%s: C preprocessor failed with signal %d\n"),
+                cmdname, WTERMSIG (status));
+      else
+       fprintf (stderr, _("%s: C preprocessor failed with exit code %d\n"),
+                cmdname, WEXITSTATUS (status));
+      crash ();
+    }
 }
 
 /* valid tirpc nettypes */
@@ -384,7 +436,7 @@ static const char *valid_ti_nettypes[] =
   "tcp",
   "raw",
   NULL
-  };
+};
 
 /* valid inetd nettypes */
 static const char *valid_i_nettypes[] =
@@ -394,14 +446,18 @@ static const char *valid_i_nettypes[] =
   NULL
 };
 
-static int check_nettype(const char *name, const char *list_to_check[]) {
+static int
+check_nettype (const char *name, const char *list_to_check[])
+{
   int i;
-  for( i = 0; list_to_check[i] != NULL; i++ ) {
-         if( strcmp( name, list_to_check[i] ) == 0 ) {
-           return 1;
-         }
-  }
-  f_print( stderr, "illegal nettype :\'%s\'\n", name );
+  for (i = 0; list_to_check[i] != NULL; i++)
+    {
+      if (strcmp (name, list_to_check[i]) == 0)
+       {
+         return 1;
+       }
+    }
+  fprintf (stderr, _ ("illegal nettype: `%s'\n"), name);
   return 0;
 }
 
@@ -410,49 +466,51 @@ static int check_nettype(const char *name, const char *list_to_check[]) {
  */
 
 static void
-c_output(const char *infile, const char *define, int extend,
-        const char *outfile)
+c_output (const char *infile, const char *define, int extend,
+         const char *outfile)
 {
-       definition *def;
-       char *include;
-       const char *outfilename;
-       long tell;
-
-       c_initialize();
-       open_input(infile, define);
-       outfilename = extend ? extendfile(infile, outfile) : outfile;
-       open_output(infile, outfilename);
-       add_warning();
-       add_stdheaders();
-       if (infile && (include = extendfile(infile, ".h"))) {
-               f_print(fout, "#include \"%s\"\n", include);
-               free(include);
-               /* .h file already contains rpc/rpc.h */
-       } else
-         f_print(fout, "#include <rpc/rpc.h>\n");
-       tell = ftell(fout);
-       while ((def = get_definition())!=NULL) {
-               emit(def);
-       }
-       if (extend && tell == ftell(fout)) {
-               (void) unlink(outfilename);
-       }
+  definition *def;
+  char *include;
+  const char *outfilename;
+  long tell;
+
+  c_initialize ();
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  open_output (infile, outfilename);
+  add_warning ();
+  if (infile && (include = extendfile (infile, ".h")))
+    {
+      fprintf (fout, "#include \"%s\"\n", include);
+      free (include);
+      /* .h file already contains rpc/rpc.h */
+    }
+  else
+    fprintf (fout, "#include <rpc/rpc.h>\n");
+  tell = ftell (fout);
+  while ((def = get_definition ()) != NULL)
+    emit (def);
+
+  if (extend && tell == ftell (fout))
+    unlink (outfilename);
+  close_input ();
+  close_output (outfilename);
 }
 
 void
-c_initialize(void)
+c_initialize (void)
 {
 
   /* add all the starting basic types */
 
-  add_type(1,"int");
-  add_type(1,"long");
-  add_type(1,"short");
-  add_type(1,"bool");
+  add_type (1, "int");
+  add_type (1, "long");
+  add_type (1, "short");
+  add_type (1, "bool");
 
-  add_type(1,"u_int");
-  add_type(1,"u_long");
-  add_type(1,"u_short");
+  add_type (1, "u_int");
+  add_type (1, "u_long");
+  add_type (1, "u_short");
 
 }
 
@@ -465,23 +523,25 @@ char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
 };\n";
 
 
-static char *generate_guard(const char *pathname) {
-        const char *filename;
-       char *guard, *tmp;
-
-       filename = strrchr(pathname, '/' );  /* find last component */
-       filename = ((filename == NULL) ? pathname : filename+1);
-       guard = strdup(filename);
-       /* convert to upper case */
-       tmp = guard;
-       while (*tmp) {
-               if (islower(*tmp))
-                       *tmp = toupper(*tmp);
-               tmp++;
-       }
+static char *
+generate_guard (const char *pathname)
+{
+  const char *filename;
+  char *guard, *tmp;
+
+  filename = strrchr (pathname, '/');  /* find last component */
+  filename = ((filename == NULL) ? pathname : filename + 1);
+  guard = extendfile (filename, "_H_RPCGEN");
+  /* convert to upper case */
+  tmp = guard;
+  while (*tmp)
+    {
+      if (islower (*tmp))
+       *tmp = toupper (*tmp);
+      tmp++;
+    }
 
-       guard = extendfile(guard, "_H_RPCGEN");
-       return guard;
+  return guard;
 }
 
 /*
@@ -490,256 +550,363 @@ static char *generate_guard(const char *pathname) {
 
 
 static void
-h_output(const char *infile, const char *define, int extend,
-        const char *outfile)
+h_output (const char *infile, const char *define, int extend,
+         const char *outfile)
 {
-       definition *def;
-       const char *ifilename;
-       const char *outfilename;
-       long tell;
-       char *guard;
-       list *l;
-
-       open_input(infile, define);
-       outfilename =  extend ? extendfile(infile, outfile) : outfile;
-       open_output(infile, outfilename);
-       add_warning();
-       ifilename = (infile == NULL) ? "STDIN" : infile;
-       guard = generate_guard(  outfilename ? outfilename: ifilename );
-
-       f_print(fout,"#ifndef _%s\n#define _%s\n\n", guard,
-               guard);
-
-       f_print(fout, "#include <rpc/rpc.h>\n\n");
-
-       tell = ftell(fout);
-       /* print data definitions */
-       while ((def = get_definition())!=NULL) {
-               print_datadef(def);
-       }
+  xdrfunc *xdrfuncp;
+  definition *def;
+  const char *ifilename;
+  const char *outfilename;
+  long tell;
+  char *guard;
+  list *l;
+
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  open_output (infile, outfilename);
+  add_warning ();
+  ifilename = (infile == NULL) ? "STDIN" : infile;
+  guard = generate_guard (outfilename ? outfilename : ifilename);
+
+  fprintf (fout, "#ifndef _%s\n#define _%s\n\n", guard,
+          guard);
+
+  fprintf (fout, "#include <rpc/rpc.h>\n\n");
+
+  if (mtflag)
+    {
+      fprintf (fout, "#include <pthread.h>\n");
+    }
 
-       /* print function declarations.
-          Do this after data definitions because they might be used as
-          arguments for functions */
-       for (l = defined; l != NULL; l = l->next) {
-               print_funcdef(l->val);
+  /* put the C++ support */
+  if (Cflag && !CCflag)
+    {
+      fprintf (fout, "\n#ifdef __cplusplus\n");
+      fprintf (fout, "extern \"C\" {\n");
+      fprintf (fout, "#endif\n\n");
+    }
+
+  tell = ftell (fout);
+  /* print data definitions */
+  while ((def = get_definition ()) != NULL)
+    {
+      print_datadef (def);
+    }
+
+  /* print function declarations.
+     Do this after data definitions because they might be used as
+     arguments for functions */
+  for (l = defined; l != NULL; l = l->next)
+    {
+      print_funcdef (l->val);
+    }
+  /* Now  print all xdr func declarations */
+  if (xdrfunc_head != NULL)
+    {
+      fprintf (fout, "\n/* the xdr functions */\n");
+      if (CCflag)
+       {
+         fprintf (fout, "\n#ifdef __cplusplus\n");
+         fprintf (fout, "extern \"C\" {\n");
+         fprintf (fout, "#endif\n");
+       }
+      if (!Cflag)
+       {
+         xdrfuncp = xdrfunc_head;
+         while (xdrfuncp != NULL)
+           {
+             print_xdr_func_def (xdrfuncp->name,
+                                 xdrfuncp->pointerp, 2);
+             xdrfuncp = xdrfuncp->next;
+           }
        }
-       if (extend && tell == ftell(fout)) {
-               (void) unlink(outfilename);
-       } else if (tblflag) {
-               f_print(fout, rpcgen_table_dcl);
+      else
+       {
+         int i;
+
+         for (i = 1; i < 3; ++i)
+           {
+             if (i == 1)
+               fprintf (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");
+             else
+               fprintf (fout, "\n#else /* K&R C */\n");
+
+             xdrfuncp = xdrfunc_head;
+             while (xdrfuncp != NULL)
+               {
+                 print_xdr_func_def (xdrfuncp->name,
+                                     xdrfuncp->pointerp, i);
+                 xdrfuncp = xdrfuncp->next;
+               }
+           }
+         fprintf (fout, "\n#endif /* K&R C */\n");
        }
-       f_print(fout, "\n#endif /* !_%s */\n", guard);
+    }
+
+  if (extend && tell == ftell (fout))
+    {
+      unlink (outfilename);
+    }
+  else if (tblflag)
+    {
+      fprintf (fout, rpcgen_table_dcl);
+    }
+
+  if (Cflag)
+    {
+      fprintf (fout, "\n#ifdef __cplusplus\n");
+      fprintf (fout, "}\n");
+      fprintf (fout, "#endif\n");
+    }
+
+  fprintf (fout, "\n#endif /* !_%s */\n", guard);
+  free (guard);
+  close_input ();
+  close_output (outfilename);
 }
 
 /*
  * Compile into an RPC service
  */
 static void
-s_output(int argc, const char *argv[], const char *infile, const char *define,
-        int extend, const char *outfile, int nomain, int netflag)
+s_output (int argc, const char *argv[], const char *infile, const char *define,
+         int extend, const char *outfile, int nomain, int netflag)
 {
-       char *include;
-       definition *def;
-       int foundprogram = 0;
-       const char *outfilename;
-
-       open_input(infile, define);
-       outfilename = extend ? extendfile(infile, outfile) : outfile;
-       open_output(infile, outfilename);
-       add_warning();
-       if (infile && (include = extendfile(infile, ".h"))) {
-               f_print(fout, "#include \"%s\"\n", include);
-               free(include);
-       } else
-         f_print(fout, "#include <rpc/rpc.h>\n");
-
-       f_print(fout, "#include <stdio.h>\n");
-       f_print(fout, "#include <stdlib.h>/* getenv, exit */\n");
-       if (Cflag) {
-               f_print (fout, "#include <rpc/pmap_clnt.h> /* for pmap_unset */\n");
-               f_print (fout, "#include <string.h> /* strcmp */ \n");
-       }
-       if (strcmp(svcclosetime, "-1") == 0)
-               indefinitewait = 1;
-       else if (strcmp(svcclosetime, "0") == 0)
-               exitnow = 1;
-       else if (inetdflag || pmflag) {
-               f_print(fout, "#include <signal.h>\n");
-         timerflag = 1;
-       }
+  char *include;
+  definition *def;
+  int foundprogram = 0;
+  const char *outfilename;
+
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  open_output (infile, outfilename);
+  add_warning ();
+  if (infile && (include = extendfile (infile, ".h")))
+    {
+      fprintf (fout, "#include \"%s\"\n", include);
+      free (include);
+    }
+  else
+    fprintf (fout, "#include <rpc/rpc.h>\n");
+
+  fprintf (fout, "#include <stdio.h>\n");
+  fprintf (fout, "#include <stdlib.h>\n");
+  fprintf (fout, "#include <rpc/pmap_clnt.h>\n");
+  if (Cflag)
+    fprintf (fout, "#include <string.h>\n");
+  if (strcmp (svcclosetime, "-1") == 0)
+    indefinitewait = 1;
+  else if (strcmp (svcclosetime, "0") == 0)
+    exitnow = 1;
+  else if (inetdflag || pmflag)
+    {
+      fprintf (fout, "#include <signal.h>\n");
+      timerflag = 1;
+    }
 
-       if( !tirpcflag && inetdflag )
+  if (!tirpcflag && inetdflag)
 #ifdef __GNU_LIBRARY__
-         f_print(fout, "#include <sys/ioctl.h> /* ioctl, TIOCNOTTY */\n");
+    fprintf (fout, "#include <sys/ioctl.h> /* ioctl, TIOCNOTTY */\n");
 #else
-         f_print(fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
+    fprintf (fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
 #endif
-       if( Cflag && (inetdflag || pmflag ) ) {
+  if (Cflag && (inetdflag || pmflag))
+    {
 #ifdef __GNU_LIBRARY__
-         f_print(fout, "#include <sys/types.h> /* open */\n");
-         f_print(fout, "#include <sys/stat.h> /* open */\n");
-         f_print(fout, "#include <fcntl.h> /* open */\n");
-         f_print(fout, "#include <unistd.h> /* getdtablesize */\n");
+      fprintf (fout, "#include <sys/types.h> /* open */\n");
+      fprintf (fout, "#include <sys/stat.h> /* open */\n");
+      fprintf (fout, "#include <fcntl.h> /* open */\n");
+      fprintf (fout, "#include <unistd.h> /* getdtablesize */\n");
 #else
-         f_print(fout, "#ifdef __cplusplus\n");
-         f_print(fout, "#include <sysent.h> /* getdtablesize, open */\n");
-         f_print(fout, "#endif /* __cplusplus */\n");
+      fprintf (fout, "#ifdef __cplusplus\n");
+      fprintf (fout, "#include <sysent.h> /* getdtablesize, open */\n");
+      fprintf (fout, "#endif /* __cplusplus */\n");
+      if (tirpcflag)
+       fprintf (fout, "#include <unistd.h> /* setsid */\n");
 #endif
-         if( tirpcflag )
-           f_print(fout, "#include <unistd.h> /* setsid */\n");
-       }
-       if( tirpcflag )
-         f_print(fout, "#include <sys/types.h>\n");
+    }
+#ifdef __GNU_LIBRARY__
+  if (tirpcflag && !(Cflag && (inetdflag || pmflag)))
+#else
+  if (tirpcflag)
+#endif
+    fprintf (fout, "#include <sys/types.h>\n");
 
-       f_print(fout, "#include <memory.h>\n");
+  fprintf (fout, "#include <memory.h>\n");
 #ifndef __GNU_LIBRARY__
-       f_print(fout, "#include <stropts.h>\n");
+  fprintf (fout, "#include <stropts.h>\n");
 #endif
-       if (inetdflag || !tirpcflag ) {
-               f_print(fout, "#include <sys/socket.h>\n");
-               f_print(fout, "#include <netinet/in.h>\n");
-       }
+  if (inetdflag || !tirpcflag)
+    {
+      fprintf (fout, "#include <sys/socket.h>\n");
+      fprintf (fout, "#include <netinet/in.h>\n");
+    }
 
-       if ( (netflag || pmflag) && tirpcflag ) {
-               f_print(fout, "#include <netconfig.h>\n");
-       }
-       if (/*timerflag &&*/ tirpcflag)
-               f_print(fout, "#include <sys/resource.h> /* rlimit */\n");
-       if (logflag || inetdflag || pmflag) {
+  if ((netflag || pmflag) && tirpcflag && !nomain)
+    {
+      fprintf (fout, "#include <netconfig.h>\n");
+    }
+  if ( /*timerflag && */ tirpcflag)
+    fprintf (fout, "#include <sys/resource.h> /* rlimit */\n");
+  if (logflag || inetdflag || pmflag)
+    {
 #ifdef __GNU_LIBRARY__
-               f_print(fout, "#include <syslog.h>\n");
+      fprintf (fout, "#include <syslog.h>\n");
 #else
-               f_print(fout, "#ifdef SYSLOG\n");
-               f_print(fout, "#include <syslog.h>\n");
-               f_print(fout, "#else\n");
-               f_print(fout, "#define LOG_ERR 1\n");
-               f_print(fout, "#define openlog(a, b, c)\n");
-               f_print(fout, "#endif\n");
+      fprintf (fout, "#ifdef SYSLOG\n");
+      fprintf (fout, "#include <syslog.h>\n");
+      fprintf (fout, "#else\n");
+      fprintf (fout, "#define LOG_ERR 1\n");
+      fprintf (fout, "#define openlog(a, b, c)\n");
+      fprintf (fout, "#endif\n");
 #endif
-       }
+    }
 
-       /* for ANSI-C */
-       f_print(fout, "\n#ifdef __STDC__\n#define SIG_PF void(*)(int)\n#endif\n");
+  /* for ANSI-C */
+  if (Cflag)
+    fprintf (fout, "\n#ifndef SIG_PF\n#define SIG_PF void(*)(int)\n#endif\n");
 
 #ifndef __GNU_LIBRARY__
-       f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
+  fprintf (fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
 #endif
-       if (timerflag)
-               f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
-       while ((def = get_definition())!=NULL) {
-               foundprogram |= (def->def_kind == DEF_PROGRAM);
-       }
-       if (extend && !foundprogram) {
-               (void) unlink(outfilename);
-               return;
-       }
-       write_most(infile, netflag, nomain);
-       if (!nomain) {
-               if( !do_registers(argc, argv) ) {
-                 if (outfilename)
-                   (void) unlink(outfilename);
-                 usage();
-               }
-               write_rest();
+  if (timerflag)
+    fprintf (fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
+  while ((def = get_definition ()) != NULL)
+    {
+      foundprogram |= (def->def_kind == DEF_PROGRAM);
+    }
+  if (extend && !foundprogram)
+    {
+      unlink (outfilename);
+      return;
+    }
+  write_most (infile, netflag, nomain);
+  if (!nomain)
+    {
+      if (!do_registers (argc, argv))
+       {
+         if (outfilename)
+           unlink (outfilename);
+         usage ();
        }
+      write_rest ();
+    }
+  close_input ();
+  close_output (outfilename);
 }
 
 /*
  * generate client side stubs
  */
 static void
-l_output(const char *infile, const char *define, int extend,
-        const char *outfile)
+l_output (const char *infile, const char *define, int extend,
+         const char *outfile)
 {
-       char *include;
-       definition *def;
-       int foundprogram = 0;
-       const char *outfilename;
-
-       open_input(infile, define);
-       outfilename = extend ? extendfile(infile, outfile) : outfile;
-       open_output(infile, outfilename);
-       add_warning();
-       if (Cflag)
-         f_print (fout, "#include <memory.h> /* for memset */\n");
-       if (infile && (include = extendfile(infile, ".h"))) {
-               f_print(fout, "#include \"%s\"\n", include);
-               free(include);
-       } else
-         f_print(fout, "#include <rpc/rpc.h>\n");
-       while ((def = get_definition())!=NULL) {
-               foundprogram |= (def->def_kind == DEF_PROGRAM);
-       }
-       if (extend && !foundprogram) {
-               (void) unlink(outfilename);
-               return;
-       }
-       write_stubs();
+  char *include;
+  definition *def;
+  int foundprogram = 0;
+  const char *outfilename;
+
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  open_output (infile, outfilename);
+  add_warning ();
+  if (Cflag)
+    fprintf (fout, "#include <memory.h> /* for memset */\n");
+  if (infile && (include = extendfile (infile, ".h")))
+    {
+      fprintf (fout, "#include \"%s\"\n", include);
+      free (include);
+    }
+  else
+    fprintf (fout, "#include <rpc/rpc.h>\n");
+  while ((def = get_definition ()) != NULL)
+    {
+      foundprogram |= (def->def_kind == DEF_PROGRAM);
+    }
+  if (extend && !foundprogram)
+    {
+      unlink (outfilename);
+      return;
+    }
+  write_stubs ();
+  close_input ();
+  close_output (outfilename);
 }
 
 /*
  * generate the dispatch table
  */
 static void
-t_output(const char *infile, const char *define, int extend,
-        const char *outfile)
+t_output (const char *infile, const char *define, int extend,
+         const char *outfile)
 {
-       definition *def;
-       int foundprogram = 0;
-       const char *outfilename;
-
-       open_input(infile, define);
-       outfilename = extend ? extendfile(infile, outfile) : outfile;
-       open_output(infile, outfilename);
-       add_warning();
-       while ((def = get_definition())!=NULL) {
-               foundprogram |= (def->def_kind == DEF_PROGRAM);
-       }
-       if (extend && !foundprogram) {
-               (void) unlink(outfilename);
-               return;
-       }
-       write_tables();
+  definition *def;
+  int foundprogram = 0;
+  const char *outfilename;
+
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  open_output (infile, outfilename);
+  add_warning ();
+  while ((def = get_definition ()) != NULL)
+    {
+      foundprogram |= (def->def_kind == DEF_PROGRAM);
+    }
+  if (extend && !foundprogram)
+    {
+      unlink (outfilename);
+      return;
+    }
+  write_tables ();
+  close_input ();
+  close_output (outfilename);
 }
 
 /* sample routine for the server template */
 static void
-svc_output(const char *infile, const char *define, int extend,
-          const char *outfile)
+svc_output (const char *infile, const char *define, int extend,
+           const char *outfile)
 {
   definition *def;
   char *include;
   const char *outfilename;
   long tell;
 
-  open_input(infile, define);
-  outfilename = extend ? extendfile(infile, outfile) : outfile;
-  checkfiles(infile,outfilename); /*check if outfile already exists.
-                                 if so, print an error message and exit*/
-  open_output(infile, outfilename);
-  add_sample_msg();
-
-  if (infile && (include = extendfile(infile, ".h"))) {
-    f_print(fout, "#include \"%s\"\n", include);
-    free(include);
-  } else
-    f_print(fout, "#include <rpc/rpc.h>\n");
-
-  tell = ftell(fout);
-  while ((def = get_definition())!=NULL) {
-         write_sample_svc(def);
-  }
-  if (extend && tell == ftell(fout)) {
-         (void) unlink(outfilename);
-  }
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  checkfiles (infile, outfilename);
+  /*check if outfile already exists.
+     if so, print an error message and exit */
+  open_output (infile, outfilename);
+  add_sample_msg ();
+
+  if (infile && (include = extendfile (infile, ".h")))
+    {
+      fprintf (fout, "#include \"%s\"\n", include);
+      free (include);
+    }
+  else
+    fprintf (fout, "#include <rpc/rpc.h>\n");
+
+  tell = ftell (fout);
+  while ((def = get_definition ()) != NULL)
+    {
+      write_sample_svc (def);
+    }
+  if (extend && tell == ftell (fout))
+    {
+      unlink (outfilename);
+    }
+  close_input ();
+  close_output (outfilename);
 }
 
 
 /* sample main routine for client */
 static void
-clnt_output(const char *infile, const char *define, int extend,
-           const char *outfile)
+clnt_output (const char *infile, const char *define, int extend,
+            const char *outfile)
 {
   definition *def;
   char *include;
@@ -747,87 +914,228 @@ clnt_output(const char *infile, const char *define, int extend,
   long tell;
   int has_program = 0;
 
-  open_input(infile, define);
-  outfilename = extend ? extendfile(infile, outfile) : outfile;
-  checkfiles(infile,outfilename); /*check if outfile already exists.
-                                 if so, print an error message and exit*/
-
-  open_output(infile, outfilename);
-  add_sample_msg();
-  if (infile && (include = extendfile(infile, ".h"))) {
-    f_print(fout, "#include \"%s\"\n", include);
-    free(include);
-  } else
-    f_print(fout, "#include <rpc/rpc.h>\n");
-  tell = ftell(fout);
-  while ((def = get_definition())!=NULL) {
-    has_program += write_sample_clnt(def);
-  }
-
-  if( has_program )
-    write_sample_clnt_main();
-
-  if (extend && tell == ftell(fout)) {
-    (void) unlink(outfilename);
-  }
+  open_input (infile, define);
+  outfilename = extend ? extendfile (infile, outfile) : outfile;
+  checkfiles (infile, outfilename);
+  /*check if outfile already exists.
+     if so, print an error message and exit */
+
+  open_output (infile, outfilename);
+  add_sample_msg ();
+  if (infile && (include = extendfile (infile, ".h")))
+    {
+      fprintf (fout, "#include \"%s\"\n", include);
+      free (include);
+    }
+  else
+    fprintf (fout, "#include <rpc/rpc.h>\n");
+  tell = ftell (fout);
+  while ((def = get_definition ()) != NULL)
+    {
+      has_program += write_sample_clnt (def);
+    }
+
+  if (has_program)
+    write_sample_clnt_main ();
+
+  if (extend && tell == ftell (fout))
+    {
+      unlink (outfilename);
+    }
+  close_input ();
+  close_output (outfilename);
+}
+
+static const char space[] = " ";
+
+static char *
+file_name (const char *file, const char *ext)
+{
+  char *temp;
+  temp = extendfile (file, ext);
+
+  if (access (temp, F_OK) != -1)
+    return (temp);
+
+  free (temp);
+  return (char *) space;
+}
+
+static void
+mkfile_output (struct commandline *cmd)
+{
+  char *mkfilename;
+  char *clientname, *clntname, *xdrname, *hdrname;
+  char *servername, *svcname, *servprogname, *clntprogname;
+
+  svcname = file_name (cmd->infile, "_svc.c");
+  clntname = file_name (cmd->infile, "_clnt.c");
+  xdrname = file_name (cmd->infile, "_xdr.c");
+  hdrname = file_name (cmd->infile, ".h");
+
+  if (allfiles)
+    {
+      servername = extendfile (cmd->infile, "_server.c");
+      clientname = extendfile (cmd->infile, "_client.c");
+    }
+  else
+    {
+      servername = (char *) space;
+      clientname = (char *) space;
+    }
+  servprogname = extendfile (cmd->infile, "_server");
+  clntprogname = extendfile (cmd->infile, "_client");
+
+  if (allfiles)
+    {
+      char *cp, *temp;
+
+      mkfilename = alloc (strlen ("Makefile.") + strlen (cmd->infile) + 1);
+      if (mkfilename == NULL)
+       abort ();
+      temp = rindex (cmd->infile, '.');
+      cp = stpcpy (mkfilename, "Makefile.");
+      strncpy (cp, cmd->infile, (temp - cmd->infile));
+    }
+  else
+    mkfilename = (char *) cmd->outfile;
+
+  checkfiles (NULL, mkfilename);
+  open_output (NULL, mkfilename);
+
+  fprintf (fout, "\n# This is a template Makefile generated by rpcgen\n");
+
+  f_print (fout, "\n# Parameters\n\n");
+
+  f_print (fout, "CLIENT = %s\nSERVER = %s\n\n", clntprogname, servprogname);
+  f_print (fout, "SOURCES_CLNT.c = \nSOURCES_CLNT.h = \n");
+  f_print (fout, "SOURCES_SVC.c = \nSOURCES_SVC.h = \n");
+  f_print (fout, "SOURCES.x = %s\n\n", cmd->infile);
+  f_print (fout, "TARGETS_SVC.c = %s %s %s \n",
+          svcname, servername, xdrname);
+  f_print (fout, "TARGETS_CLNT.c = %s %s %s \n",
+          clntname, clientname, xdrname);
+  f_print (fout, "TARGETS = %s %s %s %s %s %s\n\n",
+          hdrname, xdrname, clntname,
+          svcname, clientname, servername);
+
+  f_print (fout, "OBJECTS_CLNT = $(SOURCES_CLNT.c:%%.c=%%.o) \
+$(TARGETS_CLNT.c:%%.c=%%.o)");
+
+  f_print (fout, "\nOBJECTS_SVC = $(SOURCES_SVC.c:%%.c=%%.o) \
+$(TARGETS_SVC.c:%%.c=%%.o)");
+
+  f_print (fout, "\n# Compiler flags \n");
+  if (mtflag)
+    fprintf (fout, "\nCPPFLAGS += -D_REENTRANT\nCFLAGS += -g \nLDLIBS \
++= -lnsl -lpthread \n ");
+  else
+    f_print (fout, "\nCFLAGS += -g \nLDLIBS += -lnsl\n");
+  f_print (fout, "RPCGENFLAGS = \n");
+
+  f_print (fout, "\n# Targets \n\n");
+
+  f_print (fout, "all : $(CLIENT) $(SERVER)\n\n");
+  f_print (fout, "$(TARGETS) : $(SOURCES.x) \n");
+  f_print (fout, "\trpcgen $(RPCGENFLAGS) $(SOURCES.x)\n\n");
+  f_print (fout, "$(OBJECTS_CLNT) : $(SOURCES_CLNT.c) $(SOURCES_CLNT.h) \
+$(TARGETS_CLNT.c) \n\n");
+
+  f_print (fout, "$(OBJECTS_SVC) : $(SOURCES_SVC.c) $(SOURCES_SVC.h) \
+$(TARGETS_SVC.c) \n\n");
+  f_print (fout, "$(CLIENT) : $(OBJECTS_CLNT) \n");
+  f_print (fout, "\t$(LINK.c) -o $(CLIENT) $(OBJECTS_CLNT) \
+$(LDLIBS) \n\n");
+  f_print (fout, "$(SERVER) : $(OBJECTS_SVC) \n");
+  f_print (fout, "\t$(LINK.c) -o $(SERVER) $(OBJECTS_SVC) $(LDLIBS)\n\n ");
+  f_print (fout, "clean:\n\t $(RM) core $(TARGETS) $(OBJECTS_CLNT) \
+$(OBJECTS_SVC) $(CLIENT) $(SERVER)\n\n");
+  close_output (mkfilename);
+
+  free (clntprogname);
+  free (servprogname);
+  if (servername != space)
+    free (servername);
+  if (clientname != space)
+    free (clientname);
+  if (mkfilename != (char *) cmd->outfile)
+    free (mkfilename);
+  if (svcname != space)
+    free (svcname);
+  if (clntname != space)
+    free (clntname);
+  if (xdrname != space)
+    free (xdrname);
+  if (hdrname != space)
+    free (hdrname);
 }
 
 /*
  * Perform registrations for service output
  * Return 0 if failed; 1 otherwise.
  */
-static int do_registers(int argc, const char *argv[])
+static int
+do_registers (int argc, const char *argv[])
 {
-       int i;
-
-       if ( inetdflag || !tirpcflag) {
-               for (i = 1; i < argc; i++) {
-                       if (streq(argv[i], "-s")) {
-                               if(!check_nettype( argv[i + 1], valid_i_nettypes ))
-                                 return 0;
-                               write_inetd_register(argv[i + 1]);
-                               i++;
-                       }
-               }
-       } else {
-               for (i = 1; i < argc; i++)
-                       if (streq(argv[i], "-s")) {
-                               if(!check_nettype( argv[i + 1], valid_ti_nettypes ))
-                                 return 0;
-                               write_nettype_register(argv[i + 1]);
-                               i++;
-                       } else if (streq(argv[i], "-n")) {
-                               write_netid_register(argv[i + 1]);
-                               i++;
-                       }
+  int i;
+
+  if (inetdflag || !tirpcflag)
+    {
+      for (i = 1; i < argc; i++)
+       {
+         if (streq (argv[i], "-s"))
+           {
+             if (!check_nettype (argv[i + 1], valid_i_nettypes))
+               return 0;
+             write_inetd_register (argv[i + 1]);
+             i++;
+           }
        }
-       return 1;
+    }
+  else
+    {
+      for (i = 1; i < argc; i++)
+       if (streq (argv[i], "-s"))
+         {
+           if (!check_nettype (argv[i + 1], valid_ti_nettypes))
+             return 0;
+           write_nettype_register (argv[i + 1]);
+           i++;
+         }
+       else if (streq (argv[i], "-n"))
+         {
+           write_netid_register (argv[i + 1]);
+           i++;
+         }
+    }
+  return 1;
 }
 
 /*
  * Add another argument to the arg list
  */
 static void
-addarg(const char *cp)
+addarg (const char *cp)
 {
-       if (argcount >= ARGLISTLEN) {
-               f_print(stderr, "rpcgen: too many defines\n");
-               crash();
-               /*NOTREACHED*/
-       }
-       arglist[argcount++] = cp;
-
+  if (argcount >= ARGLISTLEN)
+    {
+      fprintf (stderr, _("rpcgen: too many defines\n"));
+      crash ();
+      /*NOTREACHED */
+    }
+  arglist[argcount++] = cp;
 }
 
 static void
-putarg(int whereto, const char *cp)
+putarg (int whereto, const char *cp)
 {
-       if (whereto >= ARGLISTLEN) {
-               f_print(stderr, "rpcgen: arglist coding error\n");
-               crash();
-               /*NOTREACHED*/
-       }
-       arglist[whereto] = cp;
+  if (whereto >= ARGLISTLEN)
+    {
+      fprintf (stderr, _("rpcgen: arglist coding error\n"));
+      crash ();
+      /*NOTREACHED */
+    }
+  arglist[whereto] = cp;
 }
 
 /*
@@ -837,292 +1145,339 @@ putarg(int whereto, const char *cp)
  */
 
 static void
-checkfiles(const char *infile, const char *outfile)
+checkfiles (const char *infile, const char *outfile)
 {
-
   struct stat buf;
 
-  if(infile)                   /* infile ! = NULL */
-    if(stat(infile,&buf) < 0)
+  if (infile)                  /* infile ! = NULL */
+    if (stat (infile, &buf) < 0)
       {
-       perror(infile);
-       crash();
-      };
-  if (outfile) {
-    if (stat(outfile, &buf) < 0)
-      return;                  /* file does not exist */
-    else {
-      f_print(stderr,
-             "file '%s' already exists and may be overwritten\n", outfile);
-      crash();
+       perror (infile);
+       crash ();
+      }
+  if (outfile)
+    {
+      if (stat (outfile, &buf) < 0)
+       return;                 /* file does not exist */
+      else
+       {
+         fprintf (stderr,
+                  /* TRANS: the file will not be removed; this is an
+                     TRANS: informative message.  */
+                  _("file `%s' already exists and may be overwritten\n"),
+                  outfile);
+         crash ();
+       }
     }
-  }
 }
 
 /*
  * Parse command line arguments
  */
 static int
-parseargs(int argc, const char *argv[], struct commandline *cmd)
+parseargs (int argc, const char *argv[], struct commandline *cmd)
 {
-       int i;
-       int j;
-       int c;
-       char flag[(1 << 8 * sizeof(char))];
-       int nflags;
-
-       cmdname = argv[0];
-       cmd->infile = cmd->outfile = NULL;
-       if (argc < 2) {
-               return (0);
+  int i;
+  int j;
+  int c;
+  char flag[(1 << 8 * sizeof (char))];
+  int nflags;
+
+  cmdname = argv[0];
+  cmd->infile = cmd->outfile = NULL;
+  if (argc < 2)
+    {
+      return (0);
+    }
+  allfiles = 0;
+  flag['c'] = 0;
+  flag['h'] = 0;
+  flag['l'] = 0;
+  flag['m'] = 0;
+  flag['o'] = 0;
+  flag['s'] = 0;
+  flag['n'] = 0;
+  flag['t'] = 0;
+  flag['S'] = 0;
+  flag['C'] = 0;
+  flag['M'] = 0;
+
+  for (i = 1; i < argc; i++)
+    {
+      if (argv[i][0] != '-')
+       {
+         if (cmd->infile)
+           {
+             fprintf (stderr,
+                      _("Cannot specify more than one input file!\n"));
+             return 0;
+           }
+         cmd->infile = argv[i];
        }
-       allfiles = 0;
-       flag['c'] = 0;
-       flag['h'] = 0;
-       flag['l'] = 0;
-       flag['m'] = 0;
-       flag['o'] = 0;
-       flag['s'] = 0;
-       flag['n'] = 0;
-       flag['t'] = 0;
-       flag['S'] = 0;
-       flag['C'] = 0;
-       for (i = 1; i < argc; i++) {
-               if (argv[i][0] != '-') {
-                       if (cmd->infile) {
-                               f_print( stderr, "Cannot specify more than one input file!\n");
-
-                               return (0);
-                       }
-                       cmd->infile = argv[i];
-               } else {
-                       for (j = 1; argv[i][j] != 0; j++) {
-                               c = argv[i][j];
-                               switch (c) {
-                               case 'a':
-                                       allfiles = 1;
-                                       break;
-                               case 'c':
-                               case 'h':
-                               case 'l':
-                               case 'm':
-                               case 't':
-                                       if (flag[c]) {
-                                               return (0);
-                                       }
-                                       flag[c] = 1;
-                                       break;
-                               case 'S':
-                                       /* sample flag: Ss or Sc.
-                                          Ss means set flag['S'];
-                                          Sc means set flag['C']; */
-                                       c = argv[i][++j];  /* get next char */
-                                       if( c == 's' )
-                                         c = 'S';
-                                       else if( c == 'c' )
-                                         c = 'C';
-                                       else
-                                         return( 0 );
-
-                                       if (flag[c]) {
-                                               return (0);
-                                       }
-                                       flag[c] = 1;
-                                       break;
-                               case 'C':  /* ANSI C syntax */
-                                       Cflag = 1;
-                                       break;
+      else
+       {
+         for (j = 1; argv[i][j] != 0; j++)
+           {
+             c = argv[i][j];
+             switch (c)
+               {
+               case 'a':
+                 allfiles = 1;
+                 break;
+               case 'c':
+               case 'h':
+               case 'l':
+               case 'm':
+               case 't':
+                 if (flag[c])
+                   return 0;
+                 flag[c] = 1;
+                 break;
+               case 'S':
+                 /* sample flag: Ss or Sc.
+                    Ss means set flag['S'];
+                    Sc means set flag['C'];
+                    Sm means set flag['M']; */
+                 c = argv[i][++j];     /* get next char */
+                 if (c == 's')
+                   c = 'S';
+                 else if (c == 'c')
+                   c = 'C';
+                 else if (c == 'm')
+                   c = 'M';
+                 else
+                   return 0;
+
+                 if (flag[c])
+                   return 0;
+                 flag[c] = 1;
+                 break;
+               case 'C':       /* ANSI C syntax */
+                 Cflag = 1;
+                 break;
 
 #ifdef __GNU_LIBRARY__
-                               case 'k':  /* K&R C syntax */
-                                       Cflag = 0;
-                                       break;
+               case 'k':  /* K&R C syntax */
+                 Cflag = 0;
+                 break;
 
 #endif
-                               case 'b':  /* turn TIRPC flag off for
-                                           generating backward compatible
-                                           */
-                                       tirpcflag = 0;
-                                       break;
+               case 'b':  /* turn TIRPC flag off for
+                             generating backward compatible
+                          */
+                 tirpcflag = 0;
+                 break;
 
 #ifdef __GNU_LIBRARY__
-                               case '5':  /* turn TIRPC flag on for
-                                           generating SysVr4 compatible
-                                           */
-                                       tirpcflag = 1;
-                                       break;
-                               case '$':
-                                       building_libc = 1;
-                                       break;
+               case '5':  /* turn TIRPC flag on for
+                             generating SysVr4 compatible
+                          */
+                 tirpcflag = 1;
+                 break;
 #endif
-                               case 'I':
-                                       inetdflag = 1;
-                                       break;
-                               case 'N':
-                                       newstyle = 1;
-                                       break;
-                               case 'L':
-                                       logflag = 1;
-                                       break;
-                               case 'K':
-                                       if (++i == argc) {
-                                               return (0);
-                                       }
-                                       svcclosetime = argv[i];
-                                       goto nextarg;
-                               case 'T':
-                                       tblflag = 1;
-                                       break;
-                               case 'i' :
-                                       if (++i == argc) {
-                                               return (0);
-                                       }
-                                       inlineflag = atoi(argv[i]);
-                                       goto nextarg;
-                               case 'n':
-                               case 'o':
-                               case 's':
-                                       if (argv[i][j - 1] != '-' ||
-                                           argv[i][j + 1] != 0) {
-                                               return (0);
-                                       }
-                                       flag[c] = 1;
-                                       if (++i == argc) {
-                                               return (0);
-                                       }
-                                       if (c == 's') {
-                                               if (!streq(argv[i], "udp") &&
-                                                   !streq(argv[i], "tcp")) {
-                                                       return (0);
-                                               }
-                                       } else if (c == 'o') {
-                                               if (cmd->outfile) {
-                                                       return (0);
-                                               }
-                                               cmd->outfile = argv[i];
-                                       }
-                                       goto nextarg;
-                               case 'D':
-                                       if (argv[i][j - 1] != '-') {
-                                               return (0);
-                                       }
-                                       (void) addarg(argv[i]);
-                                       goto nextarg;
-                               case 'Y':
-                                       if (++i == argc) {
-                                               return (0);
-                                       }
-                                       {
-                                               size_t len = strlen (argv[i]);
-                                               pathbuf = malloc (len + 5);
-                                               if (pathbuf == NULL) {
-                                                       perror(cmdname);
-                                                       crash();
-                                               }
-                                               stpcpy (stpcpy (pathbuf,
-                                                               argv[i]),
-                                                       "/cpp");
-                                               CPP = pathbuf;
-                                               cppDefined = 1;
-                                               goto nextarg;
-                                       }
-
-
-                               default:
-                                       return (0);
-                               }
-                       }
-       nextarg:
-                       ;
+               case 'I':
+                 inetdflag = 1;
+                 break;
+               case 'N':
+                 newstyle = 1;
+                 break;
+               case 'L':
+                 logflag = 1;
+                 break;
+               case 'K':
+                 if (++i == argc)
+                   {
+                     return (0);
+                   }
+                 svcclosetime = argv[i];
+                 goto nextarg;
+               case 'T':
+                 tblflag = 1;
+                 break;
+               case 'M':
+                 mtflag = 1;
+                 break;
+               case 'i':
+                 if (++i == argc)
+                   {
+                     return (0);
+                   }
+                 inlineflag = atoi (argv[i]);
+                 goto nextarg;
+               case 'n':
+               case 'o':
+               case 's':
+                 if (argv[i][j - 1] != '-' ||
+                     argv[i][j + 1] != 0)
+                   {
+                     return (0);
+                   }
+                 flag[c] = 1;
+                 if (++i == argc)
+                   {
+                     return (0);
+                   }
+                 if (c == 's')
+                   {
+                     if (!streq (argv[i], "udp") &&
+                         !streq (argv[i], "tcp"))
+                       return 0;
+                   }
+                 else if (c == 'o')
+                   {
+                     if (cmd->outfile)
+                       return 0;
+                     cmd->outfile = argv[i];
+                   }
+                 goto nextarg;
+               case 'D':
+                 if (argv[i][j - 1] != '-')
+                   return 0;
+                 addarg (argv[i]);
+                 goto nextarg;
+               case 'Y':
+                 if (++i == argc)
+                   return 0;
+                 {
+                   size_t len = strlen (argv[i]);
+                   pathbuf = malloc (len + 5);
+                   if (pathbuf == NULL)
+                     {
+                       perror (cmdname);
+                       crash ();
+                     }
+                   stpcpy (stpcpy (pathbuf,
+                                   argv[i]),
+                           "/cpp");
+                   CPP = pathbuf;
+                   cppDefined = 1;
+                   goto nextarg;
+                 }
+
+               default:
+                 return 0;
                }
+             }
+       nextarg:
+         ;
        }
+    }
 
-       cmd->cflag = flag['c'];
-       cmd->hflag = flag['h'];
-       cmd->lflag = flag['l'];
-       cmd->mflag = flag['m'];
-       cmd->nflag = flag['n'];
-       cmd->sflag = flag['s'];
-       cmd->tflag = flag['t'];
-       cmd->Ssflag = flag['S'];
-       cmd->Scflag = flag['C'];
-
-       if( tirpcflag ) {
-         pmflag = inetdflag ? 0 : 1;     /* pmflag or inetdflag is always TRUE */
-         if( (inetdflag && cmd->nflag)) { /* netid not allowed with inetdflag */
-           f_print(stderr, "Cannot use netid flag with inetd flag!\n");
-           return (0);
-         }
-       } else {  /* 4.1 mode */
-         pmflag = 0;               /* set pmflag only in tirpcmode */
+  cmd->cflag = flag['c'];
+  cmd->hflag = flag['h'];
+  cmd->lflag = flag['l'];
+  cmd->mflag = flag['m'];
+  cmd->nflag = flag['n'];
+  cmd->sflag = flag['s'];
+  cmd->tflag = flag['t'];
+  cmd->Ssflag = flag['S'];
+  cmd->Scflag = flag['C'];
+  cmd->makefileflag = flag['M'];
+
+#ifndef _RPC_THREAD_SAFE_
+  if (mtflag || newstyle)
+    {
+      /* glibc doesn't support these flags.  */
+      f_print (stderr,
+              _("This implementation doesn't support newstyle or MT-safe code!\n"));
+      return (0);
+    }
+#endif
+  if (tirpcflag)
+    {
+      pmflag = inetdflag ? 0 : 1;    /* pmflag or inetdflag is always TRUE */
+      if ((inetdflag && cmd->nflag))
+       {                       /* netid not allowed with inetdflag */
+         fprintf (stderr, _("Cannot use netid flag with inetd flag!\n"));
+         return 0;
+       }
+    }
+  else
+    {                          /* 4.1 mode */
+      pmflag = 0;              /* set pmflag only in tirpcmode */
 #ifndef __GNU_LIBRARY__
-         inetdflag = 1;            /* inetdflag is TRUE by default */
+      inetdflag = 1;            /* inetdflag is TRUE by default */
 #endif
-         if( cmd->nflag ) {          /* netid needs TIRPC */
-           f_print( stderr, "Cannot use netid flag without TIRPC!\n");
-           return( 0 );
-         }
+      if (cmd->nflag)
+       {                       /* netid needs TIRPC */
+         f_print (stderr, _("Cannot use netid flag without TIRPC!\n"));
+         return (0);
        }
+    }
 
-       if( newstyle && ( tblflag || cmd->tflag) ) {
-         f_print( stderr, "Cannot use table flags with newstyle!\n");
-         return( 0 );
-       }
+  if (newstyle && (tblflag || cmd->tflag))
+    {
+      f_print (stderr, _("Cannot use table flags with newstyle!\n"));
+      return (0);
+    }
 
-       /* check no conflicts with file generation flags */
-       nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
-               cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
+  /* check no conflicts with file generation flags */
+  nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
+    cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
 
-       if (nflags == 0) {
-               if (cmd->outfile != NULL || cmd->infile == NULL) {
-                       return (0);
-               }
-       } else if (nflags > 1) {
-               f_print( stderr, "Cannot have more than one file generation flag!\n");
-               return (0);
+  if (nflags == 0)
+    {
+      if (cmd->outfile != NULL || cmd->infile == NULL)
+       {
+         return (0);
        }
-       return (1);
+    }
+  else if (cmd->infile == NULL &&
+          (cmd->Ssflag || cmd->Scflag || cmd->makefileflag))
+    {
+      fprintf (stderr,
+              _("\"infile\" is required for template generation flags.\n"));
+      return 0;
+    }
+  if (nflags > 1)
+    {
+      fprintf (stderr, _("Cannot have more than one file generation flag!\n"));
+      return 0;
+    }
+  return 1;
 }
 
 static void
-usage(void)
+usage (void)
 {
-       f_print(stderr, "usage:  %s infile\n", cmdname);
-       f_print(stderr, "\t%s [-a][-b][-C][-Dname[=value]] -i size  [-I [-K seconds]] [-L][-N][-T] infile\n",
-                       cmdname);
-       f_print(stderr, "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss] [-o outfile] [infile]\n",
-                       cmdname);
-       f_print(stderr, "\t%s [-s nettype]* [-o outfile] [infile]\n", cmdname);
-       f_print(stderr, "\t%s [-n netid]* [-o outfile] [infile]\n", cmdname);
-       options_usage();
-       exit(1);
+  fprintf (stderr, _("usage: %s infile\n"), cmdname);
+  fprintf (stderr, _("\t%s [-abkCLNTM][-Dname[=value]] [-i size] \
+[-I [-K seconds]] [-Y path] infile\n"), cmdname);
+  fprintf (stderr, _("\t%s [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] \
+[-o outfile] [infile]\n"), cmdname);
+  fprintf (stderr, _("\t%s [-s nettype]* [-o outfile] [infile]\n"), cmdname);
+  fprintf (stderr, _("\t%s [-n netid]* [-o outfile] [infile]\n"), cmdname);
+  options_usage ();
+  exit (1);
 }
 
 static void
-options_usage(void)
+options_usage (void)
 {
-       f_print(stderr, "options:\n");
-       f_print(stderr, "-a\t\tgenerate all files, including samples\n");
-       f_print(stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
-       f_print(stderr, "-c\t\tgenerate XDR routines\n");
-       f_print(stderr, "-C\t\tANSI C mode\n");
-       f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
-       f_print(stderr, "-h\t\tgenerate header file\n");
-       f_print(stderr, "-i size\t\tsize at which to start generating inline code\n");
-       f_print(stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
-       f_print(stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
-       f_print(stderr, "-l\t\tgenerate client side stubs\n");
-       f_print(stderr, "-L\t\tserver errors will be printed to syslog\n");
-       f_print(stderr, "-m\t\tgenerate server side stubs\n");
-       f_print(stderr, "-n netid\tgenerate server code that supports named netid\n");
-       f_print(stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
-       f_print(stderr, "-o outfile\tname of the output file\n");
-       f_print(stderr, "-s nettype\tgenerate server code that supports named nettype\n");
-       f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
-       f_print(stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
-       f_print(stderr, "-t\t\tgenerate RPC dispatch table\n");
-       f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
-       f_print(stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
-
-       exit(1);
+  f_print (stderr, "options:\n");
+  f_print (stderr, "-a\t\tgenerate all files, including samples\n");
+  f_print (stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
+  f_print (stderr, "-c\t\tgenerate XDR routines\n");
+  f_print (stderr, "-C\t\tANSI C mode\n");
+  f_print (stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
+  f_print (stderr, "-h\t\tgenerate header file\n");
+  f_print (stderr, "-i size\t\tsize at which to start generating inline code\n");
+  f_print (stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
+  f_print (stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
+  f_print (stderr, "-l\t\tgenerate client side stubs\n");
+  f_print (stderr, "-L\t\tserver errors will be printed to syslog\n");
+  f_print (stderr, "-m\t\tgenerate server side stubs\n");
+  f_print (stderr, "-M\t\tgenerate MT-safe code\n");
+  f_print (stderr, "-n netid\tgenerate server code that supports named netid\n");
+  f_print (stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
+  f_print (stderr, "-o outfile\tname of the output file\n");
+  f_print (stderr, "-s nettype\tgenerate server code that supports named nettype\n");
+  f_print (stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
+  f_print (stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
+  f_print (stderr, "-Sm \t\tgenerate makefile template \n");
+  f_print (stderr, "-t\t\tgenerate RPC dispatch table\n");
+  f_print (stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
+  f_print (stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
+
+  exit (1);
 }