1 files changed, 224 insertions, 96 deletions

diff --git a/sunrpc/rpc_hout.c b/sunrpc/rpc_hout.c
index 1bf0097..beca276 100644
--- a/sunrpc/rpc_hout.c
+++ b/sunrpc/rpc_hout.c
@@ -1,53 +1,71 @@
-/* @(#)rpc_hout.c	2.1 88/08/01 4.0 RPCSRC */
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * media and as a part of the software program in whole or part.  Users
  * may copy or modify Sun RPC without charge, but are not authorized
  * to license or distribute it to anyone else except as part of a product or
- * program developed by the user.
- * 
+ * program developed by the user or with the express written consent of
+ * Sun Microsystems, Inc.
+ *
  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
- * 
+ *
  * Sun RPC is provided with no support and without any obligation on the
  * part of Sun Microsystems, Inc. to assist in its use, correction,
  * modification or enhancement.
- * 
+ *
  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  * OR ANY PART THEREOF.
- * 
+ *
  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  * or profits or other special, indirect and consequential damages, even if
  * Sun has been advised of the possibility of such damages.
- * 
+ *
  * Sun Microsystems, Inc.
  * 2550 Garcia Avenue
  * Mountain View, California  94043
  */
-#ifndef lint
-static char sccsid[] = "@(#)rpc_hout.c 1.6 87/07/28 (C) 1987 SMI";
-#endif
+
+/*
+ * From: @(#)rpc_hout.c 1.12 89/02/22 (C) 1987 SMI
+ */
+char hout_rcsid[] = 
+  "$Id$";
 
 /*
  * rpc_hout.c, Header file outputter for the RPC protocol compiler 
- * Copyright (C) 1987, Sun Microsystems, Inc. 
  */
 #include <stdio.h>
 #include <ctype.h>
-#include "rpc_util.h"
 #include "rpc_parse.h"
+#include "rpc_util.h"
+#include "proto.h"
 
+static void pconstdef(definition *def);
+static void pargdef(definition *def);
+static void pstructdef(definition *def);
+static void puniondef(definition *def);
+static void pdefine(const char *name, const char *num);
+static void puldefine(const char *name, const char *num);
+static int define_printed(proc_list *stop, version_list *start);
+static void pprogramdef(definition *def);
+static void parglist(proc_list *proc, const char *addargtype);
+static void penumdef(definition *def);
+static void ptypedef(definition *def);
+static int undefined2(const char *type, const char *stop);
 
 /*
  * Print the C-version of an xdr definition 
  */
 void
-print_datadef(def)
-	definition *def;
+print_datadef(definition *def)
 {
+
+	if (def->def_kind == DEF_PROGRAM )  /* handle data only */
+	        return;
+
 	if (def->def_kind != DEF_CONST) {
 		f_print(fout, "\n");
 	}
@@ -72,41 +90,101 @@ print_datadef(def)
 		break;
 	}
 	if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) {
-		f_print(fout, "bool_t xdr_%s();\n", def->def_name);
+	  pxdrfuncdecl( def->def_name,
+		       def->def_kind != DEF_TYPEDEF ||
+		       !isvectordef(def->def.ty.old_type, def->def.ty.rel));
+
 	}
-	if (def->def_kind != DEF_CONST) {
+}
+
+
+void
+print_funcdef(definition *def)
+{
+	switch (def->def_kind) {
+	  case DEF_PROGRAM:
 		f_print(fout, "\n");
+		pprogramdef(def);
+		break;
+	  default:
+	    /* ?... shouldn't happen I guess */
 	}
 }
 
-static
-pconstdef(def)
-	definition *def;
+void
+pxdrfuncdecl(const char *name, int pointerp)
+{
+
+  f_print(fout,"#ifdef __cplusplus \n");
+    f_print(fout, "extern \"C\" bool_t xdr_%s(XDR *, %s%s);\n", name, name, pointerp ? "*" : "");
+  f_print(fout,"#elif __STDC__ \n");
+    f_print(fout, "extern  bool_t xdr_%s(XDR *, %s%s);\n", name, name, pointerp ? "*" : "");
+  f_print(fout,"#else /* Old Style C */ \n");
+    f_print(fout, "bool_t xdr_%s();\n", name);
+  f_print(fout,"#endif /* Old Style C */ \n\n");
+}
+
+
+static void
+pconstdef(definition *def)
 {
 	pdefine(def->def_name, def->def.co);
 }
 
-static
-pstructdef(def)
-	definition *def;
+/* print out the definitions for the arguments of functions in the 
+   header file 
+*/
+static void
+pargdef(definition *def)
+{
+	decl_list *l;
+	version_list *vers;
+	const char *name;
+	proc_list *plist;
+
+	
+	for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
+			for(plist = vers->procs; plist != NULL; 
+			    plist = plist->next) {
+				
+				if (!newstyle || plist->arg_num < 2) {
+					continue; /* old style or single args */
+				}
+				name = plist->args.argname;
+				f_print(fout, "struct %s {\n", name);
+				for (l = plist->args.decls; 
+				     l != NULL; l = l->next) {
+					pdeclaration(name, &l->decl, 1, ";\n" );
+				}
+				f_print(fout, "};\n");
+				f_print(fout, "typedef struct %s %s;\n", name, name);
+				pxdrfuncdecl(name, 0);
+				f_print( fout, "\n" );
+			}
+		}
+
+}
+
+
+static void
+pstructdef(definition *def)
 {
 	decl_list *l;
-	char *name = def->def_name;
+	const char *name = def->def_name;
 
 	f_print(fout, "struct %s {\n", name);
 	for (l = def->def.st.decls; l != NULL; l = l->next) {
-		pdeclaration(name, &l->decl, 1);
+		pdeclaration(name, &l->decl, 1, ";\n");
 	}
 	f_print(fout, "};\n");
 	f_print(fout, "typedef struct %s %s;\n", name, name);
 }
 
-static
-puniondef(def)
-	definition *def;
+static void
+puniondef(definition *def)
 {
 	case_list *l;
-	char *name = def->def_name;
+	const char *name = def->def_name;
 	declaration *decl;
 
 	f_print(fout, "struct %s {\n", name);
@@ -118,39 +196,32 @@ puniondef(def)
 	}
 	f_print(fout, "\tunion {\n");
 	for (l = def->def.un.cases; l != NULL; l = l->next) {
-		pdeclaration(name, &l->case_decl, 2);
+	  if(l->contflag == 0)
+		pdeclaration(name, &l->case_decl, 2, ";\n" );
 	}
 	decl = def->def.un.default_decl;
 	if (decl && !streq(decl->type, "void")) {
-		pdeclaration(name, decl, 2);
+		pdeclaration(name, decl, 2, ";\n" );
 	}
 	f_print(fout, "\t} %s_u;\n", name);
 	f_print(fout, "};\n");
 	f_print(fout, "typedef struct %s %s;\n", name, name);
 }
 
-
-
-static
-pdefine(name, num)
-	char *name;
-	char *num;
+static void
+pdefine(const char *name, const char *num)
 {
 	f_print(fout, "#define %s %s\n", name, num);
 }
 
-static
-puldefine(name, num)
-	char *name;
-	char *num;
+static void
+puldefine(const char *name, const char *num)
 {
 	f_print(fout, "#define %s ((u_long)%s)\n", name, num);
 }
 
-static
-define_printed(stop, start)
-	proc_list *stop;
-	version_list *start;
+static int
+define_printed(proc_list *stop, version_list *start)
 {
 	version_list *vers;
 	proc_list *proc;
@@ -168,57 +239,122 @@ define_printed(stop, start)
 	/* NOTREACHED */
 }
 
-
-static
-pprogramdef(def)
-	definition *def;
+static void
+pprogramdef(definition *def)
 {
 	version_list *vers;
 	proc_list *proc;
+	int i;
+	const char *ext;
+	
+	pargdef(def);
 
 	puldefine(def->def_name, def->def.pr.prog_num);
 	for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
+		if (tblflag) {
+			f_print(fout, "extern struct rpcgen_table %s_%s_table[];\n",
+				locase(def->def_name), vers->vers_num);
+			f_print(fout, "extern %s_%s_nproc;\n",
+				locase(def->def_name), vers->vers_num);
+		}
 		puldefine(vers->vers_name, vers->vers_num);
-		for (proc = vers->procs; proc != NULL; proc = proc->next) {
-			if (!define_printed(proc, def->def.pr.versions)) {
-				puldefine(proc->proc_name, proc->proc_num);
+
+		/* 
+		 * Print out 3 definitions, one for ANSI-C, another for C++, 
+		 * a third for old style C 
+		 */
+		   
+		for (i=0;i<3;i++) {
+			if (i==0) {
+				f_print(fout,"\n#ifdef __cplusplus\n");
+				ext="extern \"C\" ";
+			} 
+			else if (i==1) {
+				f_print(fout,"\n#elif __STDC__\n");
+				ext="extern  "  ;
+			} 
+			else {
+				f_print(fout,"\n#else /* Old Style C */ \n");
+				ext="extern  ";
 			}
-			pprocdef(proc, vers);
+			
+			
+			for (proc = vers->procs; proc != NULL; proc = proc->next) {
+				if (!define_printed(proc, def->def.pr.versions)) {
+					puldefine(proc->proc_name, proc->proc_num);
+				}
+				f_print(fout,"%s",ext);
+				pprocdef(proc, vers, "CLIENT *", 0,i);
+				f_print(fout,"%s",ext);
+				pprocdef(proc, vers, "struct svc_req *", 1,i);
+				
+			}
+
 		}
+		f_print(fout,"#endif /* Old Style C */ \n");
 	}
 }
 
+void
+pprocdef(proc_list *proc, version_list *vp, 
+	 const char *addargtype, int server_p, int mode)
+{
 
-pprocdef(proc, vp)
-	proc_list *proc;
-	version_list *vp;
+
+
+
+		ptype( proc->res_prefix, proc->res_type, 1 );
+		f_print( fout, "* " );
+		if( server_p )
+			pvname_svc(proc->proc_name, vp->vers_num);
+		else
+			pvname(proc->proc_name, vp->vers_num);
+
+		/*
+		 * mode  0 == cplusplus, mode  1 = ANSI-C, mode 2 = old style C 
+		 */
+		if(mode == 0 || mode ==1) 
+			parglist(proc, addargtype);
+		else
+			f_print(fout, "();\n");
+
+
+
+}
+
+
+
+/* print out argument list of procedure */
+static void
+parglist(proc_list *proc, const char *addargtype)
 {
-	f_print(fout, "extern ");
-	if (proc->res_prefix) {
-		if (streq(proc->res_prefix, "enum")) {
-			f_print(fout, "enum ");
+	decl_list *dl;
+
+		f_print(fout,"(");
+
+		if( proc->arg_num < 2 && newstyle &&
+		   streq( proc->args.decls->decl.type, "void")) {
+			/* 0 argument in new style:  do nothing */
 		} else {
-			f_print(fout, "struct ");
+			for (dl = proc->args.decls; dl != NULL; dl = dl->next) {
+				ptype( dl->decl.prefix, dl->decl.type, 1 );
+				if( !newstyle )
+					f_print( fout, "*" ); /* old style passes by reference */
+	
+				f_print( fout, ", " );
+			}
 		}
-	}
-	if (streq(proc->res_type, "bool")) {
-		f_print(fout, "bool_t *");
-	} else if (streq(proc->res_type, "string")) {
-		f_print(fout, "char **");
-	} else {
-		f_print(fout, "%s *", fixtype(proc->res_type));
-	}
-	pvname(proc->proc_name, vp->vers_num);
-	f_print(fout, "();\n");
+    
+		f_print(fout, "%s);\n", addargtype);
+
 }
 
-static
-penumdef(def)
-	definition *def;
+static void
+penumdef(definition *def)
 {
-	char *name = def->def_name;
+	const char *name = def->def_name;
 	enumval_list *l;
-	char *last = NULL;
+	const char *last = NULL;
 	int count = 0;
 
 	f_print(fout, "enum %s {\n", name);
@@ -241,12 +377,11 @@ penumdef(def)
 	f_print(fout, "typedef enum %s %s;\n", name, name);
 }
 
-static
-ptypedef(def)
-	definition *def;
+static void
+ptypedef(definition *def)
 {
-	char *name = def->def_name;
-	char *old = def->def.ty.old_type;
+	const char *name = def->def_name;
+	const char *old = def->def.ty.old_type;
 	char prefix[8];	/* enough to contain "struct ", including NUL */
 	relation rel = def->def.ty.rel;
 
@@ -281,23 +416,20 @@ ptypedef(def)
 				def->def.ty.array_max);
 			break;
 		case REL_ALIAS:
- 			f_print(fout, "%s%s %s", prefix, old, name);
+			f_print(fout, "%s%s %s", prefix, old, name);
 			break;
 		}
 		f_print(fout, ";\n");
 	}
 }
 
-
-static
-pdeclaration(name, dec, tab)
-	char *name;
-	declaration *dec;
-	int tab;
+void
+pdeclaration(const char *name, declaration *dec, int tab, 
+	     const char *separator)
 {
 	char buf[8];	/* enough to hold "struct ", include NUL */
-	char *prefix;
-	char *type;
+	const char *prefix;
+	const char *type;
 
 	if (streq(dec->type, "void")) {
 		return;
@@ -343,15 +475,11 @@ pdeclaration(name, dec, tab)
 			break;
 		}
 	}
-	f_print(fout, ";\n");
+	f_print(fout, separator );
 }
 
-
-
-static
-undefined2(type, stop)
-	char *type;
-	char *stop;
+static int
+undefined2(const char *type, const char *stop)
 {
 	list *l;
 	definition *def;