From 0d204b0a522b9fef2168e1808a0566c9209d0893 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Thu, 17 Oct 1996 01:51:38 +0000 Subject: update from main archive 961016 Thu Oct 17 01:55:34 1996 Ulrich Drepper * sunrpc/Makefile ($(objpfx)rpcsvc/%.h, $(objpfx)x%.c): Write output to $@T and move to $@ later since the new rpcgen will not overwrite existing files. * po/Makefile (libc.pot): Fix typo. Sun Oct 13 20:52:07 1996 Thorsten Kukuk Update rpcgen program to TI-rpc code. * sunrpc/Makefile (rpcgen-objs): Add rpc_tblout.o and rpc_sample.o. (distribute): Add proto.h. * sunrpc/proto.h: New file. Prototypes for all the RPC functions. * sunrpc/rpc_clntout.c: Change to allow generation of ISO C code. * sunrpc/rpc_cout.c: Likewise. * sunrpc/rpc_hout.c: Likewise. * sunrpc/rpc_main.c: Likewise. * sunrpc/rpc_parse.c: Likewise. * sunrpc/rpc_parse.h: Likewise. * sunrpc/rpc_scan.c: Likewise. * sunrpc/rpc_scan.h: Likewise. * sunrpc/rpc_svcout.c: Likewise. * sunrpc/rpc_util.c: Likewise. * sunrpc/rpc_util.h: Likewise. * sunrpc/rpc_tblout.c: New file. * sunrpc/rpc_sample.c: Likewise. Thu Oct 17 00:26:20 1996 NIIBE Yutaka * sysdeps/unix/opendir.c: Add semicolon for consistency. Wed Oct 16 12:26:53 1996 Sven Verdoolaege * locale/progams/localedef.c (main): Test with -1 to find out whether read failed. Wed Oct 16 14:54:59 1996 Ulrich Drepper * sysdeps/unix/sysv/linux/i386/clone.S: Use JUMPTARGET and PSEUDO_END macro. Tue Oct 15 21:27:42 1996 Andreas Schwab * sysdeps/unix/sysv/linux/m68k/sigcontext.h: Removed. Tue Oct 15 15:52:29 1996 Andreas Schwab * sysdeps/unix/sysv/linux/m68k/clone.S: Add CALL_MCOUNT. * sysdeps/unix/sysv/linux/m68k/mmap.S: Likewise. * sysdeps/unix/sysv/linux/m68k/sigreturn.S: Likewise. * sysdeps/unix/sysv/linux/m68k/socket.S: Likewise. * sysdeps/unix/sysv/linux/m68k/sysdep.S (__errno_location): Likewise. * sysdeps/unix/sysv/linux/m68k/syscall.S: Likewise. Correct generation of system call. Tue Oct 15 15:13:16 1996 Andreas Schwab * Makerules (sysd-Makefile): Fix command so that it works in the subdirectories. (BUILD_CFLAGS): Change back using $(..) instead of $(common-objpfx), the latter fails in the toplevel directory when $(objdir) is relative. (common-objdir-compile): Run compiler in $(objdir). * sysdeps/posix/Makefile (mk-stdiolim): Likewise. Tue Oct 15 23:39:48 1996 Ulrich Drepper * string/string.h [__USE_SVID]: Add prototype for swab. * time/sys/time.h [__USE_BSD]: Add prototype for ualarm. Reported by Andreas Jaeger. The available nlist implementation is not generally usable. Especially on the currently supported ELF systems the nlist function comes with the libelf. * misc/Makefile (headers): Remove nlist.h. (routines): Remove nlist. * Makefile ($(objpfx)version-info.h): Include information about system the libc is built on in version-info.h file. * po/Makefile (distribute): Add header.pot. Tue Oct 15 16:34:15 1996 Andreas Jaeger * sysdeps/unix/sysv/linux/sleep.c: Include file with prototype. * sysdeps/unix/sysv/linux/reboot.c: Likewise. * misc/error.c: Likewise. Tue Oct 15 22:41:27 1996 Ulrich Drepper * sysdeps/unix/sysv/linux/syscalls.list: Add {get,set}resuid. Tue Oct 15 08:06:02 1996 Andreas Jaeger * crypt/Makefiel (rpath-link): Extend search path to current directory. Fri Oct 11 09:18:06 1996 Sven Verdoolaege * sysdeps/i386/i586/strlen.S: Correct handling of prolog for aligning pointer. Tue Oct 15 02:13:21 1996 Ulrich Drepper * stdio-common/vfprintf.c: Don't declare __flockfile as weak. * crypt/md5-crypt.c (md5_crypt_r): Add cast to prevent warning. Sun Oct 13 19:16:10 1996 Andreas Schwab * sysdeps/unix/sysv/linux/m68k/sysdep.h (POUND): Macro removed, replaced by `&'. (PSEUDO_END): Provide definition to use .size directive. (PSEUDO): Don't interpret negative return values less than -128 as syscall error. * sysdeps/unix/sysv/linux/m68k/syscall.S (syscall): Likewise. * sysdeps/m68k/bsd-_setjmp.S: Use PSEUDO_END macro to provide .size directive. * sysdeps/m68k/bsd-setjmp.S: Likewise. * sysdeps/unix/sysv/linux/m68k/clone.S: Likewise. * sysdeps/unix/sysv/linux/m68k/mmap.S: Likewise. * sysdeps/unix/sysv/linux/m68k/sigreturn.S: Likewise. * sysdeps/unix/sysv/linux/m68k/socket.S: Likewise. * sysdeps/unix/sysv/linux/m68k/syscall.S: Likewise. * sysdeps/unix/sysv/linux/m68k/sysdep.S: Use PSEUDO_END instead of explicit .size directive. * libio/iogets.c: Warn when gets is used. cd * time/strptime.c: Recognize %s, %u, %g, and %G format. --- sunrpc/rpc_cout.c | 660 ++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 512 insertions(+), 148 deletions(-) (limited to 'sunrpc/rpc_cout.c') diff --git a/sunrpc/rpc_cout.c b/sunrpc/rpc_cout.c index 86d38652f5..378a686fa7 100644 --- a/sunrpc/rpc_cout.c +++ b/sunrpc/rpc_cout.c @@ -1,55 +1,92 @@ -/* @(#)rpc_cout.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_cout.c 1.8 87/06/24 (C) 1987 SMI"; -#endif /* - * rpc_cout.c, XDR routine outputter for the RPC protocol compiler - * Copyright (C) 1987, Sun Microsystems, Inc. + * From: @(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI + */ +char cout_rcsid[] = + "$Id$"; + +/* + * rpc_cout.c, XDR routine outputter for the RPC protocol compiler */ +#include #include -#include -#include "rpc_util.h" +#include #include "rpc_parse.h" +#include "rpc_util.h" +#include "proto.h" + +static void emit_enum(definition *def); +static void emit_program(definition *def); +static void emit_union(definition *def); +static void emit_struct(definition *def); +static void emit_typedef(definition *def); +static int findtype(const definition *def, const char *type); +static int undefined(const char *type); +static void print_generic_header(const char *procname, int pointerp); +static void print_ifopen(int indent, const char *name); +static void print_ifarg(const char *arg); +static void print_ifsizeof(const char *prefix, const char *type); +static void print_ifclose(int indent); +static void print_ifstat(int indent, const char *prefix, const char *type, + relation rel, const char *amax, + const char *objname, const char *name); +static void print_stat(int indent, declaration *dec); +static void print_header(definition *def); +static void print_trailer(void); +static char *upcase(const char *str); /* - * Emit the C-routine for the given definition + * Emit the C-routine for the given definition */ void -emit(def) - definition *def; +emit(definition *def) { - if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) { + if (def->def_kind == DEF_CONST) { return; } + if (def->def_kind == DEF_PROGRAM) { + emit_program(def); + return; + } + if(def->def_kind == DEF_TYPEDEF) + { + /* now we need to handle declarations like + struct typedef foo foo; + since we dont want this to be expanded into 2 calls to xdr_foo */ + + if(strcmp(def->def.ty.old_type,def->def_name)==0) + return; + }; + print_header(def); switch (def->def_kind) { case DEF_UNION: @@ -64,15 +101,16 @@ emit(def) case DEF_TYPEDEF: emit_typedef(def); break; + default: + /* can't happen */ } print_trailer(); } -static -findtype(def, type) - definition *def; - char *type; +static int +findtype(const definition *def, const char *type) { + if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) { return (0); } else { @@ -80,105 +118,121 @@ findtype(def, type) } } -static -undefined(type) - char *type; +static int +undefined(const char *type) { definition *def; def = (definition *) FINDVAL(defined, type, findtype); + + return (def == NULL); } -static -print_header(def) - definition *def; +static void +print_generic_header(const char *procname, int pointerp) { - space(); + f_print(fout, "\n"); f_print(fout, "bool_t\n"); - f_print(fout, "xdr_%s(xdrs, objp)\n", def->def_name); - f_print(fout, "\tXDR *xdrs;\n"); - f_print(fout, "\t%s ", def->def_name); - if (def->def_kind != DEF_TYPEDEF || - !isvectordef(def->def.ty.old_type, def->def.ty.rel)) { - f_print(fout, "*"); + if (Cflag) { + f_print(fout, "xdr_%s(", procname); + f_print(fout, "XDR *xdrs, "); + f_print(fout, "%s ", procname); + if( pointerp ) + f_print(fout, "*"); + f_print(fout, "objp)\n{\n\n"); + } else { + f_print(fout, "xdr_%s(xdrs, objp)\n", procname); + f_print(fout, "\tXDR *xdrs;\n"); + f_print(fout, "\t%s ", procname); + if( pointerp ) + f_print(fout, "*"); + f_print(fout, "objp;\n{\n\n"); } - f_print(fout, "objp;\n"); - f_print(fout, "{\n"); } -static -print_trailer() +static void +print_header(definition *def) +{ + +/* + decl_list *dl; + bas_type *ptr; + int i; + */ + + print_generic_header( def->def_name, + def->def_kind != DEF_TYPEDEF || + !isvectordef(def->def.ty.old_type, def->def.ty.rel)); + + /* Now add Inline support */ + + + if(inlineflag == 0 ) + return; + /*May cause lint to complain. but ... */ +f_print(fout, "\t register long *buf;\n\n"); + +} + +static void +print_prog_header(proc_list *plist) +{ + print_generic_header( plist->args.argname, 1 ); +} + +static void +print_trailer(void) { f_print(fout, "\treturn (TRUE);\n"); f_print(fout, "}\n"); - space(); } -static -print_ifopen(indent, name) - int indent; - char *name; +static void +print_ifopen(int indent, const char *name) { tabify(fout, indent); - f_print(fout, "if (!xdr_%s(xdrs", name); + f_print(fout, " if (!xdr_%s(xdrs", name); } - -static -print_ifarg(arg) - char *arg; +static void +print_ifarg(const char *arg) { f_print(fout, ", %s", arg); } - -static -print_ifsizeof(prefix, type) - char *prefix; - char *type; +static void +print_ifsizeof(const char *prefix, const char *type) { if (streq(type, "bool")) { - f_print(fout, ", sizeof(bool_t), xdr_bool"); - } else { + f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool"); + } + else { f_print(fout, ", sizeof("); if (undefined(type) && prefix) { f_print(fout, "%s ", prefix); } - f_print(fout, "%s), xdr_%s", type, type); + f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type); } } -static -print_ifclose(indent) - int indent; +static void +print_ifclose(int indent) { f_print(fout, ")) {\n"); tabify(fout, indent); - f_print(fout, "\treturn (FALSE);\n"); + f_print(fout, "\t return (FALSE);\n"); tabify(fout, indent); - f_print(fout, "}\n"); -} - -static -space() -{ - f_print(fout, "\n\n"); + f_print(fout, " }\n"); } -static -print_ifstat(indent, prefix, type, rel, amax, objname, name) - int indent; - char *prefix; - char *type; - relation rel; - char *amax; - char *objname; - char *name; +static void +print_ifstat(int indent, const char *prefix, const char *type, relation rel, + const char *amax, const char *objname, const char *name) { - char *alt = NULL; + const char *alt = NULL; switch (rel) { case REL_POINTER: @@ -243,101 +297,331 @@ print_ifstat(indent, prefix, type, rel, amax, objname, name) print_ifclose(indent); } - -/* ARGSUSED */ -static -emit_enum(def) - definition *def; +static void +emit_enum(definition *def) { + (void)def; + print_ifopen(1, "enum"); print_ifarg("(enum_t *)objp"); print_ifclose(1); } - -static -emit_union(def) - definition *def; +static void +emit_program(definition *def) { - declaration *dflt; - case_list *cl; - declaration *cs; - char *object; - char *format = "&objp->%s_u.%s"; - - print_stat(&def->def.un.enum_decl); - f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name); - for (cl = def->def.un.cases; cl != NULL; cl = cl->next) { - cs = &cl->case_decl; - f_print(fout, "\tcase %s:\n", cl->case_name); - if (!streq(cs->type, "void")) { - object = alloc(strlen(def->def_name) + strlen(format) + - strlen(cs->name) + 1); - s_print(object, format, def->def_name, cs->name); - print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max, - object, cs->name); - free(object); - } - f_print(fout, "\t\tbreak;\n"); - } - dflt = def->def.un.default_decl; - if (dflt != NULL) { - if (!streq(dflt->type, "void")) { - f_print(fout, "\tdefault:\n"); - object = alloc(strlen(def->def_name) + strlen(format) + - strlen(dflt->name) + 1); - s_print(object, format, def->def_name, dflt->name); - print_ifstat(2, dflt->prefix, dflt->type, dflt->rel, - dflt->array_max, object, dflt->name); - free(object); - f_print(fout, "\t\tbreak;\n"); - } - } else { - f_print(fout, "\tdefault:\n"); - f_print(fout, "\t\treturn (FALSE);\n"); - } - f_print(fout, "\t}\n"); + decl_list *dl; + version_list *vlist; + proc_list *plist; + + for (vlist = def->def.pr.versions; vlist != NULL;vlist = vlist->next) + for(plist = vlist->procs; plist != NULL; plist = plist->next) { + if (!newstyle || plist->arg_num < 2) + continue; /* old style, or single argument */ + print_prog_header(plist); + for (dl = plist->args.decls; dl != NULL; + dl = dl->next) + print_stat(1,&dl->decl); + print_trailer(); + } } +static void +emit_union(definition *def) +{ + declaration *dflt; + case_list *cl; + declaration *cs; + char *object; + const char *vecformat = "objp->%s_u.%s"; + const char *format = "&objp->%s_u.%s"; + + print_stat(1,&def->def.un.enum_decl); + f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name); + for (cl = def->def.un.cases; cl != NULL; cl = cl->next) { + + f_print(fout, "\tcase %s:\n", cl->case_name); + if(cl->contflag == 1) /* a continued case statement */ + continue; + cs = &cl->case_decl; + if (!streq(cs->type, "void")) { + object = alloc(strlen(def->def_name) + strlen(format) + + strlen(cs->name) + 1); + if (isvectordef(cs->type, cs->rel)) { + s_print(object, vecformat, def->def_name, + cs->name); + } else { + s_print(object, format, def->def_name, + cs->name); + } + print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max, + object, cs->name); + free(object); + } + f_print(fout, "\t\tbreak;\n"); + } + dflt = def->def.un.default_decl; + if (dflt != NULL) { + if (!streq(dflt->type, "void")) { + f_print(fout, "\tdefault:\n"); + object = alloc(strlen(def->def_name) + strlen(format) + + strlen(dflt->name) + 1); + if (isvectordef(dflt->type, dflt->rel)) { + s_print(object, vecformat, def->def_name, + dflt->name); + } else { + s_print(object, format, def->def_name, + dflt->name); + } + + print_ifstat(2, dflt->prefix, dflt->type, dflt->rel, + dflt->array_max, object, dflt->name); + free(object); + f_print(fout, "\t\tbreak;\n"); + } +#ifdef __GNU_LIBRARY__ + else { + f_print(fout, "\tdefault:\n"); + f_print(fout, "\t\tbreak;\n"); + } +#endif + } else { + f_print(fout, "\tdefault:\n"); + f_print(fout, "\t\treturn (FALSE);\n"); + } + f_print(fout, "\t}\n"); +} -static -emit_struct(def) - definition *def; +static void +emit_struct(definition *def) { decl_list *dl; - - for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { - print_stat(&dl->decl); + int i,j,size,flag; + decl_list *cur = NULL,*psav; + bas_type *ptr; + char *sizestr; + const char *plus; + char ptemp[256]; + int can_inline; + + + if(inlineflag == 0) { + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) + print_stat(1,&dl->decl); } -} + else { + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) + if(dl->decl.rel == REL_VECTOR){ + f_print(fout,"\t int i;\n"); + break; + } + size=0;can_inline=0; + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) + if((dl->decl.prefix == NULL) && ((ptr=find_type(dl->decl.type))!= NULL) && ((dl->decl.rel == REL_ALIAS)||(dl->decl.rel == REL_VECTOR))){ -static -emit_typedef(def) - definition *def; -{ - char *prefix = def->def.ty.old_prefix; - char *type = def->def.ty.old_type; - char *amax = def->def.ty.array_max; - relation rel = def->def.ty.rel; + if(dl->decl.rel == REL_ALIAS) + size+=ptr->length; + else { + can_inline=1; + break; /* can be inlined */ + }; + } + else { + if(size >= inlineflag){ + can_inline=1; + break; /* can be inlined */ + } + size=0; + } + if(size > inlineflag) + can_inline=1; + + if(can_inline == 0){ /* can not inline, drop back to old mode */ + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) + print_stat(1,&dl->decl); + return; + }; + + + + + flag=PUT; + for(j=0; j<2; j++){ + + if(flag == PUT) + f_print(fout,"\n\t if (xdrs->x_op == XDR_ENCODE) {\n"); + else + f_print(fout,"\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n"); + + + i=0; + size=0; + sizestr=NULL; + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */ + + /* now walk down the list and check for basic types */ + if((dl->decl.prefix == NULL) && ((ptr=find_type(dl->decl.type))!= NULL) && ((dl->decl.rel == REL_ALIAS)||(dl->decl.rel == REL_VECTOR))){ + if(i ==0 ) + cur=dl; + i++; + + if(dl->decl.rel == REL_ALIAS) + size+=ptr->length; + else { + /* this is required to handle arrays */ + + if(sizestr == NULL) + plus = " "; + else + plus = "+"; + + if(ptr->length != 1) + s_print(ptemp," %s %s * %d",plus,dl->decl.array_max,ptr->length); + else + s_print(ptemp," %s %s ",plus,dl->decl.array_max); + + /*now concatenate to sizestr !!!! */ + if (sizestr == NULL) + sizestr=strdup(ptemp); + else{ + sizestr=realloc(sizestr,strlen(sizestr)+strlen(ptemp)+1); + if(sizestr == NULL){ + + f_print(stderr, "Fatal error : no memory \n"); + crash(); + }; + sizestr=strcat(sizestr,ptemp); /*build up length of array */ + + } + } + + } + else{ + if(i > 0 ) + if(sizestr == NULL && size < inlineflag){ + /* don't expand into inline code if size < inlineflag */ + while(cur != dl){ + print_stat(1,&cur->decl); + cur=cur->next; + } + } + else{ + + + + /* were already looking at a xdr_inlineable structure */ + if(sizestr == NULL) + f_print(fout,"\t buf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);", + size); + else + if(size == 0) + f_print(fout, + "\t buf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);", + sizestr); + else + f_print(fout, + "\t buf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);", + size,sizestr); + + f_print(fout,"\n\t if (buf == NULL) {\n"); + + psav=cur; + while(cur != dl){ + print_stat(2,&cur->decl); + cur=cur->next; + } + + f_print(fout,"\n\t }\n\t else {\n"); + + cur=psav; + while(cur != dl){ + emit_inline(&cur->decl,flag); + cur=cur->next; + } + + f_print(fout,"\t }\n"); + } + size=0;i=0;sizestr=NULL; + print_stat(1,&dl->decl); + } - print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name); + } + if(i > 0 ) + if(sizestr == NULL && size < inlineflag){ + /* don't expand into inline code if size < inlineflag */ + while(cur != dl){ + print_stat(1,&cur->decl); + cur=cur->next; + } + } + else{ + + /* were already looking at a xdr_inlineable structure */ + if(sizestr == NULL) + f_print(fout,"\t\tbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);", + size); + else + if(size == 0) + f_print(fout, + "\t\tbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);", + sizestr); + else + f_print(fout, + "\t\tbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);", + size,sizestr); + + f_print(fout,"\n\t\tif (buf == NULL) {\n"); + + psav=cur; + while(cur != NULL){ + print_stat(2,&cur->decl); + cur=cur->next; + } + f_print(fout,"\n\t }\n\t else {\n"); + + cur=psav; + while(cur != dl){ + emit_inline(&cur->decl,flag); + cur=cur->next; + } + + f_print(fout,"\t }\n"); + + } + flag=GET; + } + f_print(fout,"\t return(TRUE);\n\t}\n\n"); + + /* now take care of XDR_FREE case */ + + for (dl = def->def.st.decls; dl != NULL; dl = dl->next) + print_stat(1,&dl->decl); + } } +static void +emit_typedef(definition *def) +{ + const char *prefix = def->def.ty.old_prefix; + const char *type = def->def.ty.old_type; + const char *amax = def->def.ty.array_max; + relation rel = def->def.ty.rel; + print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name); +} -static -print_stat(dec) - declaration *dec; +static void +print_stat(int indent, declaration *dec) { - char *prefix = dec->prefix; - char *type = dec->type; - char *amax = dec->array_max; + const char *prefix = dec->prefix; + const char *type = dec->type; + const char *amax = dec->array_max; relation rel = dec->rel; char name[256]; @@ -346,5 +630,85 @@ print_stat(dec) } else { s_print(name, "&objp->%s", dec->name); } - print_ifstat(1, prefix, type, rel, amax, name, dec->name); + print_ifstat(indent, prefix, type, rel, amax, name, dec->name); +} + + +void +emit_inline(declaration *decl, int flag) +{ + +/*check whether an array or not */ + +switch(decl->rel) + { + case REL_ALIAS : + emit_single_in_line(decl,flag,REL_ALIAS); + break; + case REL_VECTOR : + f_print(fout,"\t\t{ register %s *genp; \n",decl->type); + f_print(fout,"\t\t for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t", + decl->name,decl->array_max); + emit_single_in_line(decl,flag,REL_VECTOR); + f_print(fout,"\t\t }\n\t\t };\n"); + + default: + /* ?... do nothing I guess */ + } +} + +void +emit_single_in_line(declaration *decl, int flag, relation rel) +{ + char *upp_case1; + const char *upp_case; + + if (flag == PUT) { + f_print(fout,"\t\t IXDR_PUT_"); + } + else { + if(rel== REL_ALIAS) { + f_print(fout, "\t\t objp->%s = IXDR_GET_", decl->name); + } + else { + f_print(fout,"\t\t *genp++ = IXDR_GET_"); + } + } + + upp_case1 = upcase(decl->type); + upp_case = upp_case1; + + /* hack - XX */ + if (!strcmp(upp_case, "INT")) upp_case="LONG"; + if (!strcmp(upp_case, "U_INT")) upp_case="U_LONG"; + + if (flag == PUT) { + if (rel==REL_ALIAS) { + f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name); + } + else { + f_print(fout,"%s(buf,*genp++);\n",upp_case); + } + } + else { + f_print(fout,"%s(buf);\n",upp_case); + } + + free(upp_case1); +} + + +static char *upcase(const char *str) { + char *ptr, *hptr; + ptr = malloc(strlen(str)); + if (ptr == NULL) { + f_print(stderr,"malloc failed\n"); + exit(1); + } + hptr=ptr; + while (*str != 0) { + *ptr++ = toupper(*str++); + } + *ptr=0; + return hptr; } -- cgit v1.2.3