about summary refs log tree commit diff
path: root/sunrpc/rpc_main.c
diff options
context:
space:
mode:
Diffstat (limited to 'sunrpc/rpc_main.c')
-rw-r--r--sunrpc/rpc_main.c1861
1 files changed, 1064 insertions, 797 deletions
diff --git a/sunrpc/rpc_main.c b/sunrpc/rpc_main.c
index a7e18070d0..0b30d6f505 100644
--- a/sunrpc/rpc_main.c
+++ b/sunrpc/rpc_main.c
@@ -31,7 +31,7 @@
 /*
  * From @(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI;
  */
-char main_rcsid[] =
+const char main_rcsid[] =
   "$Id$";
 
 /*
@@ -52,85 +52,89 @@ char main_rcsid[] =
 #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 int cppDefined = 0;	/* explicit path for C preprocessor */
+static const char *CPP = SUNOS_CPP;
 static char CPPFLAGS[] = "-C";
 static char *pathbuf;
-static const char *allv[] = {
-	"rpcgen", "-s", "udp", "-s", "tcp",
+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);
+static void options_usage (void);
+static void c_initialize (void);
+static char *generate_guard (const char *pathname);
 
 
 #define ARGLISTLEN	20
@@ -140,235 +144,240 @@ 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 = 0;			/* ANSI C/C++ syntax */
 #endif
-static int allfiles;   /* generate all files */
+int CCflag = 0;			/* C++ files */
+static int allfiles;		/* generate all files */
 #ifdef __GNU_LIBRARY__
-int tirpcflag = 0;       /* generating code for tirpc, by default */
+int tirpcflag = 0;		/* 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 = NULL;	/* xdr function list */
+xdrfunc *xdrfunc_tail = NULL;	/* 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");
 	}
-	exit(nonfatalerrors);
-	/* NOTREACHED */
+      if (allfiles || (cmd.makefileflag == 1))
+	{
+	  reinitialize ();
+	  mkfile_output (&cmd);
+	}
+    }
+  exit (nonfatalerrors);
+  /* NOTREACHED */
 }
 
 /*
  * 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);
-}
-
-static void
-add_warning(void)
-{
-	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 (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 "), cmdname);
+      perror (outfile);
+      crash ();
+    }
+  record_open (outfile);
 }
 
 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];
-
-	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();
-	}
+  int pd[2];
+
+  infilename = (infile == NULL) ? "<stdin>" : infile;
+  pipe (pd);
+  switch (fork ())
+    {
+    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 ();
+    }
 }
 
 /* valid tirpc nettypes */
@@ -384,7 +393,7 @@ static const char *valid_ti_nettypes[] =
   "tcp",
   "raw",
   NULL
-  };
+};
 
 /* valid inetd nettypes */
 static const char *valid_i_nettypes[] =
@@ -394,14 +403,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 +423,49 @@ 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);
 }
 
 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 +478,26 @@ 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 = strdup (filename);
+  /* convert to upper case */
+  tmp = guard;
+  while (*tmp)
+    {
+      if (islower (*tmp))
+	*tmp = toupper (*tmp);
+      tmp++;
+    }
 
-	guard = extendfile(guard, "_H_RPCGEN");
-	return guard;
+  guard = extendfile (guard, "_H_RPCGEN");
+  return guard;
 }
 
 /*
@@ -490,256 +506,354 @@ 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;
 
-	/* 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);
+  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");
+    }
+
+  /* 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);
 }
 
 /*
  * 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");
+  if (Cflag)
+    {
+      fprintf (fout, "#include <rpc/pmap_clnt.h>\n");
+      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 ();
+    }
 }
 
 /*
  * 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 ();
 }
 
 /*
  * 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 ();
 }
 
 /* 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);
+    }
 }
 
 
 /* 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 +861,204 @@ 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);
+    }
+}
+
+static char *
+file_name (const char *file, const char *ext)
+{
+  char *temp;
+  temp = extendfile (file, ext);
+
+  if (access (temp, F_OK) != -1)
+    return (temp);
+  else
+    return ((char *) " ");
+}
+
+static void
+mkfile_output (struct commandline *cmd)
+{
+  char *mkfilename;
+  const char *clientname, *clntname, *xdrname, *hdrname;
+  const char *servername, *svcname, *servprogname, *clntprogname;
+  char *temp;
+
+  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 = " ";
+      clientname = " ";
+    }
+  servprogname = extendfile (cmd->infile, "_server");
+  clntprogname = extendfile (cmd->infile, "_client");
+
+  if (allfiles)
+    {
+      mkfilename = alloc (strlen ("Makefile.") +
+			  strlen (cmd->infile) + 1);
+      temp = (char *) rindex (cmd->infile, '.');
+      strcat (mkfilename, "Makefile.");
+      strncat (mkfilename, 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");
 }
 
 /*
  * 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 +1068,328 @@ 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,
+		   _("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'];
+
+  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);
 }