#ifndef lint
static char sccsid[] = "@(#)rpc_clntout.c 1.1 90/10/29 (C) 1987 SMI";
#endif

/*
 * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler
 * Copyright (C) 1987, Sun Microsytsems, Inc.
 */
#include <stdio.h>
#include <strings.h>
#include "rpc_parse.h"
#include "rpc_util.h"

void
write_stubs(svcName)
     char *svcName;
{
    list *l;
    definition *def;
    
    for (l = CurrentContext->defined; l != NULL; l = l->next) {
	def = (definition *) l->val;
	if (def->def_kind == DEF_PROGRAM) {
	    write_program(svcName, def);
	}
    }
}

static
EmitProcSignature(vp, proc, pvName, defStruct, o, res, recoverySuffix)
     version_list *vp;
     proc_list *proc;
     char *pvName;
     definition *defStruct;
     char *o, *res;
     char *recoverySuffix;
{
    decl_list *dl;

    f_print(fout, "\n");
    if (BadProgNameFlag[CurrentProgNameFlag]) {
        f_print(fout,
	    "%s%s: PROC[%s: %s.%s%s",
	    locase(proc->proc_name), vp->vers_num,
	    o, svcName, svcName, pvName);
    }
    else {
        f_print(fout,
	    "%s%s: PROC[%s: %s.%s",
	    locase(proc->proc_name), vp->vers_num,
	    o, svcName, pvName);
    }
    if (ExpandProcArgs && defStruct != NULL &&
	defStruct->def_kind == DEF_STRUCT) {
	f_print(fout, ",\n");
	for (dl = defStruct->def.st.decls;
	     dl != NULL;
	     dl = dl->next) {
	    pdeclaration(defStruct->def_name, &(dl->decl), 16, FALSE);
	    if (dl->next == NULL)
		f_print(fout, "]");
	    else
		f_print(fout, ",\n");
	}
    }
    else {
	if (!streq(proc->arg_type, "void")) {
	    f_print(fout, ", in: %s]",
		    MapToCedarType(proc->arg_type, FALSE));
	}
	else {
	    f_print(fout, "]");
	}
    }
    if (!streq(proc->res_type, "void"))
	f_print(fout,
		"\n\t\tRETURNS [%s: %s] = {\n", res,
		MapToCedarType(proc->res_type, FALSE));
    else
	f_print(fout, " = {\n");
}

static
write_program(svcName, def)
     char *svcName;
     definition *def;
{
    version_list *vp;
    proc_list *proc;
    char pvName[256];
    int inArg, outArg;
    char *srcMethod;
    definition *defStruct;
    decl_list *dl;
    int expandFlag;
    extern definition *FindStructDefn();
    char *o, *res;
    char rpcHandle[256];
    char *recoverySuffix = "";
    char *mName;
    char *sp;

    CurrentProgNameFlag++;
    
    for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
	strcpy(pvName, def->def_name);
	strcat(pvName, vp->vers_num);
	
	if (PCedar) {
	    f_print(fout,
		    "\nImportByName%s: PUBLIC PROC[name: ROPE]\n",
		    pvName);
	    f_print(fout, "\t\tRETURNS [h: %s.%s] = {\n",
		    svcName, pvName);
	    f_print(fout, "  };\n\n");

	    if (PCedarUDP) {
		f_print(fout,
			"Import%s: PUBLIC PROC[b: %s.Address _ %s.nullAddress]\n",
			pvName, SunRPC, SunRPC);
	    }
	    else {		/* PCedarTCP */
		f_print(fout,
			"ImportStream%s: PUBLIC PROC[b: %s.Address _ %s.nullAddress]\n",
			pvName, SunRPC, SunRPC);
	    }

	    f_print(fout, "\t\tRETURNS [h: %s.%s] = {\n",
		    svcName, pvName);
	    f_print(fout, "  rh: %s.Handle;\n", SunRPC);
	    f_print(fout,
		    "  rhPM: SunRPC.Handle _ SunRPC.Create[b, Basics.HFromCard16[SunPMap.udpPort]];\n");
	    f_print(fout,
		    "  c: SunRPCAuth.Conversation _ SunRPCAuth.Initiate[];\n");
	    f_print(fout,
		    "  port: CARDINAL _ SunPMapClient.GetPort[rhPM, c,\n");
	    if (PCedarUDP) {
		f_print(fout,
			"\t\t%s.%s, %s, SunPMap.ipProtocolUDP];\n\n",
			svcName, def->def_name, vp->vers_num);
	    }
	    else {		/* PCedarTCP */
		f_print(fout,
			"\t\t%s.%s, %s, SunPMap.ipProtocolTCP];\n\n",
			svcName, def->def_name, vp->vers_num);
		f_print(fout,
			"remoteAddress: ROPE _ Rope.Cat[Convert.RopeFromArpaAddress[b], \":\", Convert.RopeFromCard[port]];\n");
	    }
	    f_print(fout, "  IF port = 0 THEN ERROR;\n");

	    if (PCedarUDP) {
		f_print(fout, "  rh _ %s.SetRemote[rhPM, b, Basics.HFromCard16[Basics.LowHalf[port]]];\n",
			SunRPC);
	    }
	    else {		/* PCedarTCP */
		f_print(fout,
			"  rh _ %s.Create[$ARPA, remoteAddress];\n",
			SunRPC, SunRPC);
	    }
	    f_print(fout, "  h _ NEW[%s.%sObject];\n",
		    svcName, pvName);
	    f_print(fout, "  h.rpcHandle _ rh;\n");
	    f_print(fout, "  h.rpcConversation _ c;\n");
	    for (proc = vp->procs; proc != NULL; proc = proc->next) {
		f_print(fout, "  h.%s _ %s%s;\n",
			locase(proc->proc_name),
			locase(proc->proc_name), vp->vers_num);
	    }
	    f_print(fout, "  };\n\n");
	}
	else {
	    if (BadProgNameFlag[CurrentProgNameFlag]) {
	        f_print(fout,
		    "Make%s%sClient: PUBLIC PROC [h: %s.Handle,\n",
		    svcName, pvName, SunRPC);
	        f_print(fout,
		    "\tc: SunRPCAuth.Conversation] RETURNS [%s.%s%s] ~ {\n",
		    svcName, svcName, pvName);
	        f_print(fout,
		    "  RETURN [NEW[%s.%s%sObject _ [\n",
		    svcName, svcName, pvName);
	    }
	    else {
	        f_print(fout,
		    "Make%sClient: PUBLIC PROC [h: %s.Handle,\n",
		    pvName, SunRPC);
    	        f_print(fout,
		    "\tc: SunRPCAuth.Conversation] RETURNS [%s.%s] ~ {\n",
		    svcName, pvName);
	        f_print(fout,
		    "  RETURN [NEW[%s.%sObject _ [\n",
		    svcName, pvName);
	    }
	    for (proc = vp->procs; proc != NULL; proc = proc->next) {
		f_print(fout, "\t%s%s",
			locase(proc->proc_name), vp->vers_num);
		f_print(fout, ",\n");
	    }
	    f_print(fout, "\th, c, NIL]]];\n");
	    f_print(fout, "  };\n\n");
	}
	
	for (proc = vp->procs; proc != NULL; proc = proc->next) {
	    expandFlag = FALSE;
	    o  = "o";
	    res = "res";
	    if (ExpandProcArgs) {
		defStruct = FindStructDefn(proc->arg_type);
		if (defStruct != NULL) {
		    o = FindUniqueName("o", defStruct->def.st.decls);
		    sprintf(rpcHandle, "%s.rpcHandle", o);
		    res = FindUniqueName("res", defStruct->def.st.decls);
		}
	    }
	    if (ExpandProcArgs && defStruct != NULL &&
		defStruct->def_kind == DEF_STRUCT) {
		inArg = TRUE;
		expandFlag = TRUE;
	    }
	    else {
		if (!streq(proc->arg_type, "void"))
		    inArg = TRUE;
		else
		    inArg = FALSE;
	    }
	    if (!streq(proc->res_type, "void")) {
		outArg = TRUE;
	    }
	    else {
		outArg = FALSE;
	    }

	    EmitProcSignature(vp, proc, pvName, defStruct, o, res, "");

	    f_print(fout, "    %s.StartCall[%s.rpcHandle, %s.rpcConversation,\n",
		    SunRPC, o, o);
	    if (BadProgNameFlag[CurrentProgNameFlag]) {
	        f_print(fout, "                   %s.%sPrognum, %s, %s];\n",
		    svcName, svcName, vp->vers_num,
		    proc->proc_num);
	    }
	    else {
	        f_print(fout, "                   %s.%s, %s, %s];\n",
		    svcName, def->def_name, vp->vers_num,
		    proc->proc_num);
	    }
	    if (inArg) {
		if (expandFlag) {
		    for (dl = defStruct->def.st.decls;
			 dl != NULL;
			 dl = dl->next) {
			emit_put_stat(&(dl->decl), "", "", FALSE, rpcHandle);
		    }
		}
		else {
		    srcMethod = rpcgenBaseType(proc->arg_type);
		    if (srcMethod != NULL)
			f_print(fout,
				"    %s.Put%s[%s.rpcHandle,in];\n",
				SunRPC, srcMethod, o);
		    else {
			mName = ModuleName(proc->arg_type);
			f_print(fout,
				"    %sGetPut.Put%s[%s.rpcHandle, in];\n",
				mName, StripPrefix(mName, proc->arg_type), o);
		    }
		}
	    }
	    if (PCedarTCP) {
		f_print(fout,
			"    [] _ %s.SendCallAndReceiveReply[%s.rpcHandle];\n",
			SunRPC, o);
	    }
	    else {		/* Either PCedarUDP or Cedar10 case. */
		f_print(fout,
			"    [] _ %s.SendCallAndReceiveReply[%s.rpcHandle, defaultTimeout, defaultRetries];\n",
			SunRPC, o);
	    }
	    if (outArg) {
		srcMethod = rpcgenBaseType(proc->res_type);
		if (srcMethod != NULL)
		    f_print(fout,
			    "    %s _ %s.Get%s[%s.rpcHandle];\n",
			    res, SunRPC, srcMethod, o);
		else {
		    mName = ModuleName(proc->res_type);
		    if (streq(mName, svcName))
		        sp = proc->res_type;
		    else
		        sp = StripPrefix(mName, proc->res_type);
		    f_print(fout,
			    "    %s _ %sGetPut.Get%s[%s.rpcHandle];\n",
			    res, mName, sp, o);
		}
	    }
	    f_print(fout, "    %s.ReleaseReply[%s.rpcHandle];\n", SunRPC, o);
	    f_print(fout, "  };\n");
	}
    }
}