rpc_cout.c revision 12798
1116743Ssam/* 2186904Ssam * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 3116743Ssam * unrestricted use provided that this legend is included on all tape 4116743Ssam * media and as a part of the software program in whole or part. Users 5116743Ssam * may copy or modify Sun RPC without charge, but are not authorized 6116743Ssam * to license or distribute it to anyone else except as part of a product or 7116743Ssam * program developed by the user. 8116743Ssam * 9116743Ssam * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 10116743Ssam * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 11116743Ssam * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 12116743Ssam * 13116743Ssam * Sun RPC is provided with no support and without any obligation on the 14116743Ssam * part of Sun Microsystems, Inc. to assist in its use, correction, 15116743Ssam * modification or enhancement. 16116743Ssam * 17116743Ssam * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 18116743Ssam * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 19116743Ssam * OR ANY PART THEREOF. 20116743Ssam * 21116743Ssam * In no event will Sun Microsystems, Inc. be liable for any lost revenue 22116743Ssam * or profits or other special, indirect and consequential damages, even if 23116743Ssam * Sun has been advised of the possibility of such damages. 24116743Ssam * 25116743Ssam * Sun Microsystems, Inc. 26116743Ssam * 2550 Garcia Avenue 27116743Ssam * Mountain View, California 94043 28116743Ssam */ 29116743Ssam 30116743Ssam#ident "@(#)rpc_cout.c 1.14 93/07/05 SMI" 31116743Ssam 32116743Ssam#ifndef lint 33116743Ssamstatic char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI"; 34116743Ssam#endif 35116743Ssam 36116743Ssam/* 37116743Ssam * rpc_cout.c, XDR routine outputter for the RPC protocol compiler 38185522Ssam * Copyright (C) 1987, Sun Microsystems, Inc. 39185522Ssam */ 40119783Ssam#include <stdio.h> 41116743Ssam#include <string.h> 42138570Ssam#include "rpc_parse.h" 43116743Ssam#include "rpc_util.h" 44116743Ssam 45116743Ssamstatic int print_header __P(( definition * )); 46220033Sadrianstatic int print_trailer __P(( void )); 47220033Sadrianstatic int print_stat __P(( int , declaration * )); 48220033Sadrianstatic int emit_enum __P(( definition * )); 49220053Sadrianstatic int emit_program __P(( definition * )); 50234323Sadrianstatic int emit_union __P(( definition * )); 51220033Sadrianstatic int emit_struct __P(( definition * )); 52220033Sadrianstatic int emit_typedef __P(( definition * )); 53220033Sadrian 54155481Ssam/* 55116743Ssam * Emit the C-routine for the given definition 56155481Ssam */ 57155481Ssamvoid 58170530Ssamemit(def) 59155481Ssam definition *def; 60178354Ssam{ 61178354Ssam if (def->def_kind == DEF_CONST) { 62140438Ssam return; 63138570Ssam } 64155480Ssam if (def->def_kind == DEF_PROGRAM) { 65138570Ssam emit_program(def); 66116743Ssam return; 67225818Sadrian } 68147067Ssam if (def->def_kind == DEF_TYPEDEF) { 69147067Ssam /* 70147067Ssam * now we need to handle declarations like 71147057Ssam * struct typedef foo foo; 72147057Ssam * since we dont want this to be expanded into 2 calls to xdr_foo 73147057Ssam */ 74147057Ssam 75147057Ssam if (strcmp(def->def.ty.old_type, def->def_name) == 0) 76147057Ssam return; 77147057Ssam }; 78147057Ssam print_header(def); 79147057Ssam switch (def->def_kind) { 80147057Ssam case DEF_UNION: 81147057Ssam emit_union(def); 82170530Ssam break; 83170530Ssam case DEF_ENUM: 84170530Ssam emit_enum(def); 85170530Ssam break; 86227328Sadrian case DEF_STRUCT: 87227328Sadrian emit_struct(def); 88227328Sadrian break; 89227328Sadrian case DEF_TYPEDEF: 90227328Sadrian emit_typedef(def); 91227328Sadrian break; 92227328Sadrian } 93227328Sadrian print_trailer(); 94227328Sadrian} 95227328Sadrian 96227328Sadrianstatic 97227328Sadrianfindtype(def, type) 98227328Sadrian definition *def; 99227328Sadrian char *type; 100227328Sadrian{ 101227328Sadrian 102227328Sadrian if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) { 103227328Sadrian return (0); 104227328Sadrian } else { 105227328Sadrian return (streq(def->def_name, type)); 106227328Sadrian } 107227328Sadrian} 108227328Sadrian 109233908Sadrianstatic 110233908Sadrianundefined(type) 111227328Sadrian char *type; 112227328Sadrian{ 113227328Sadrian definition *def; 114227328Sadrian 115227328Sadrian def = (definition *) FINDVAL(defined, type, findtype); 116227328Sadrian return (def == NULL); 117227328Sadrian} 118227328Sadrian 119227328Sadrian 120227328Sadrianstatic 121227328Sadrianprint_generic_header(procname, pointerp) 122227328Sadrian char* procname; 123227328Sadrian int pointerp; 124227328Sadrian{ 125227328Sadrian f_print(fout, "\n"); 126227328Sadrian f_print(fout, "bool_t\n"); 127227328Sadrian if (Cflag) { 128227328Sadrian f_print(fout, "xdr_%s(", procname); 129227328Sadrian f_print(fout, "register XDR *xdrs, "); 130227328Sadrian f_print(fout, "%s ", procname); 131227328Sadrian if (pointerp) 132227328Sadrian f_print(fout, "*"); 133227328Sadrian f_print(fout, "objp)\n{\n\n"); 134227328Sadrian } else { 135227328Sadrian f_print(fout, "xdr_%s(xdrs, objp)\n", procname); 136227328Sadrian f_print(fout, "\tregister XDR *xdrs;\n"); 137227328Sadrian f_print(fout, "\t%s ", procname); 138227328Sadrian if (pointerp) 139227328Sadrian f_print(fout, "*"); 140227328Sadrian f_print(fout, "objp;\n{\n\n"); 141227328Sadrian } 142227328Sadrian} 143227328Sadrian 144227328Sadrianstatic 145227328Sadrianprint_header(def) 146138570Ssam definition *def; 147116743Ssam{ 148119150Ssam 149178354Ssam decl_list *dl; 150178354Ssam bas_type *ptr; 151170530Ssam int i; 152227328Sadrian 153227328Sadrian print_generic_header(def->def_name, 154227328Sadrian def->def_kind != DEF_TYPEDEF || 155138570Ssam !isvectordef(def->def.ty.old_type, 156116743Ssam def->def.ty.rel)); 157138570Ssam /* Now add Inline support */ 158138570Ssam 159116743Ssam if (inline == 0) 160138570Ssam return; 161138570Ssam /* May cause lint to complain. but ... */ 162138570Ssam f_print(fout, "\tregister long *buf;\n\n"); 163138570Ssam} 164138570Ssam 165138570Ssamstatic 166138570Ssamprint_prog_header(plist) 167138570Ssam proc_list *plist; 168138570Ssam{ 169138570Ssam print_generic_header(plist->args.argname, 1); 170184358Ssam} 171184358Ssam 172184358Ssamstatic 173138570Ssamprint_trailer() 174116743Ssam{ 175227344Sadrian f_print(fout, "\treturn (TRUE);\n"); 176227328Sadrian f_print(fout, "}\n"); 177116743Ssam} 178186904Ssam 179116743Ssam 180165185Ssamstatic 181116743Ssamprint_ifopen(indent, name) 182138570Ssam int indent; 183116743Ssam char *name; 184116743Ssam{ 185227328Sadrian tabify(fout, indent); 186227328Sadrian f_print(fout, "if (!xdr_%s(xdrs", name); 187116743Ssam} 188140438Ssam 189116743Ssamstatic 190227328Sadrianprint_ifarg(arg) 191227328Sadrian char *arg; 192227328Sadrian{ 193227328Sadrian f_print(fout, ", %s", arg); 194227328Sadrian} 195227328Sadrian 196227328Sadrianstatic 197227328Sadrianprint_ifsizeof(indent, prefix, type) 198227328Sadrian int indent; 199227328Sadrian char *prefix; 200227328Sadrian char *type; 201227328Sadrian{ 202227328Sadrian if (indent) { 203227328Sadrian f_print(fout, ",\n"); 204227328Sadrian tabify(fout, indent); 205227328Sadrian } else { 206227328Sadrian f_print(fout, ", "); 207227328Sadrian } 208227328Sadrian if (streq(type, "bool")) { 209234109Sadrian f_print(fout, "sizeof (bool_t), (xdrproc_t) xdr_bool"); 210234109Sadrian } else { 211234109Sadrian f_print(fout, "sizeof ("); 212234109Sadrian if (undefined(type) && prefix) { 213234109Sadrian f_print(fout, "%s ", prefix); 214234109Sadrian } 215234109Sadrian f_print(fout, "%s), (xdrproc_t) xdr_%s", type, type); 216234109Sadrian } 217234109Sadrian} 218234109Sadrian 219234109Sadrianstatic 220234109Sadrianprint_ifclose(indent) 221234109Sadrian int indent; 222227328Sadrian{ 223227328Sadrian f_print(fout, "))\n"); 224227328Sadrian tabify(fout, indent); 225227328Sadrian f_print(fout, "\treturn (FALSE);\n"); 226227328Sadrian} 227227328Sadrian 228227328Sadrianstatic 229227328Sadrianprint_ifstat(indent, prefix, type, rel, amax, objname, name) 230227328Sadrian int indent; 231227328Sadrian char *prefix; 232233966Sadrian char *type; 233227328Sadrian relation rel; 234227328Sadrian char *amax; 235227328Sadrian char *objname; 236227328Sadrian char *name; 237227328Sadrian{ 238227328Sadrian char *alt = NULL; 239227328Sadrian 240227328Sadrian switch (rel) { 241227328Sadrian case REL_POINTER: 242227328Sadrian print_ifopen(indent, "pointer"); 243227328Sadrian print_ifarg("(char **)"); 244227328Sadrian f_print(fout, "%s", objname); 245116743Ssam print_ifsizeof(0, prefix, type); 246227344Sadrian break; 247116743Ssam case REL_VECTOR: 248186904Ssam if (streq(type, "string")) { 249186904Ssam alt = "string"; 250138570Ssam } else if (streq(type, "opaque")) { 251138570Ssam alt = "opaque"; 252138570Ssam } 253138570Ssam if (alt) { 254138570Ssam print_ifopen(indent, alt); 255138570Ssam print_ifarg(objname); 256138570Ssam } else { 257158298Ssam print_ifopen(indent, "vector"); 258138570Ssam print_ifarg("(char *)"); 259138570Ssam f_print(fout, "%s", objname); 260138570Ssam } 261138570Ssam print_ifarg(amax); 262138570Ssam if (!alt) { 263138570Ssam print_ifsizeof(indent + 1, prefix, type); 264138570Ssam } 265138570Ssam break; 266138570Ssam case REL_ARRAY: 267138570Ssam if (streq(type, "string")) { 268138570Ssam alt = "string"; 269138570Ssam } else if (streq(type, "opaque")) { 270138570Ssam alt = "bytes"; 271138570Ssam } 272138570Ssam if (streq(type, "string")) { 273138570Ssam print_ifopen(indent, alt); 274227328Sadrian print_ifarg(objname); 275138570Ssam } else { 276178354Ssam if (alt) { 277190579Ssam print_ifopen(indent, alt); 278186904Ssam } else { 279186904Ssam print_ifopen(indent, "array"); 280156073Ssam } 281227328Sadrian print_ifarg("(char **)"); 282138570Ssam if (*objname == '&') { 283138570Ssam f_print(fout, "%s.%s_val, (u_int *) %s.%s_len", 284227344Sadrian objname, name, objname, name); 285138570Ssam } else { 286155482Ssam f_print(fout, 287227344Sadrian "&%s->%s_val, (u_int *) &%s->%s_len", 288227328Sadrian objname, name, objname, name); 289227328Sadrian } 290138570Ssam } 291138570Ssam print_ifarg(amax); 292227328Sadrian if (!alt) { 293227328Sadrian print_ifsizeof(indent + 1, prefix, type); 294227328Sadrian } 295227328Sadrian break; 296155482Ssam case REL_ALIAS: 297155482Ssam print_ifopen(indent, type); 298155482Ssam print_ifarg(objname); 299167252Ssam break; 300161425Simp } 301138570Ssam print_ifclose(indent); 302138570Ssam} 303138570Ssam 304138570Ssam/* ARGSUSED */ 305227328Sadrianstatic 306138570Ssamemit_enum(def) 307227344Sadrian definition *def; 308227344Sadrian{ 309227344Sadrian print_ifopen(1, "enum"); 310227344Sadrian print_ifarg("(enum_t *)objp"); 311138570Ssam print_ifclose(1); 312227344Sadrian} 313138570Ssam 314138570Ssamstatic 315227344Sadrianemit_program(def) 316227344Sadrian definition *def; 317138570Ssam{ 318138570Ssam decl_list *dl; 319227344Sadrian version_list *vlist; 320138570Ssam proc_list *plist; 321178354Ssam 322178354Ssam for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next) 323178354Ssam for (plist = vlist->procs; plist != NULL; plist = plist->next) { 324178354Ssam if (!newstyle || plist->arg_num < 2) 325178354Ssam continue; /* old style, or single argument */ 326178354Ssam print_prog_header(plist); 327178354Ssam for (dl = plist->args.decls; dl != NULL; 328178354Ssam dl = dl->next) 329192468Ssam print_stat(1, &dl->decl); 330178354Ssam print_trailer(); 331178354Ssam } 332178354Ssam} 333178354Ssam 334178354Ssam 335178354Ssamstatic 336155491Ssamemit_union(def) 337155486Ssam definition *def; 338155486Ssam{ 339227328Sadrian declaration *dflt; 340227328Sadrian case_list *cl; 341227328Sadrian declaration *cs; 342227328Sadrian char *object; 343227328Sadrian char *vecformat = "objp->%s_u.%s"; 344227328Sadrian char *format = "&objp->%s_u.%s"; 345227328Sadrian 346227328Sadrian print_stat(1, &def->def.un.enum_decl); 347227328Sadrian f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name); 348227328Sadrian for (cl = def->def.un.cases; cl != NULL; cl = cl->next) { 349116743Ssam 350147256Sbrooks f_print(fout, "\tcase %s:\n", cl->case_name); 351138570Ssam if (cl->contflag == 1) /* a continued case statement */ 352227328Sadrian continue; 353234090Sadrian cs = &cl->case_decl; 354138570Ssam if (!streq(cs->type, "void")) { 355178354Ssam object = alloc(strlen(def->def_name) + strlen(format) + 356178354Ssam strlen(cs->name) + 1); 357195807Ssam if (isvectordef (cs->type, cs->rel)) { 358178354Ssam s_print(object, vecformat, def->def_name, 359178354Ssam cs->name); 360178354Ssam } else { 361178354Ssam s_print(object, format, def->def_name, 362227328Sadrian cs->name); 363138570Ssam } 364116743Ssam print_ifstat(2, cs->prefix, cs->type, cs->rel, 365159290Ssam cs->array_max, object, cs->name); 366159290Ssam free(object); 367116743Ssam } 368116743Ssam f_print(fout, "\t\tbreak;\n"); 369227328Sadrian } 370227328Sadrian dflt = def->def.un.default_decl; 371155491Ssam if (dflt != NULL) { 372116743Ssam if (!streq(dflt->type, "void")) { 373138570Ssam f_print(fout, "\tdefault:\n"); 374155486Ssam object = alloc(strlen(def->def_name) + strlen(format) + 375138570Ssamstrlen(dflt->name) + 1); 376178354Ssam if (isvectordef (dflt->type, dflt->rel)) { 377178354Ssam s_print(object, vecformat, def->def_name, 378178354Ssam dflt->name); 379228891Sadrian } else { 380178354Ssam s_print(object, format, def->def_name, 381178354Ssam dflt->name); 382178354Ssam } 383178354Ssam 384178354Ssam print_ifstat(2, dflt->prefix, dflt->type, dflt->rel, 385178354Ssam dflt->array_max, object, dflt->name); 386178354Ssam free(object); 387178354Ssam f_print(fout, "\t\tbreak;\n"); 388155496Ssam } 389178354Ssam } else { 390165571Ssam f_print(fout, "\tdefault:\n"); 391170530Ssam f_print(fout, "\t\treturn (FALSE);\n"); 392178354Ssam } 393178354Ssam 394195618Srpaulo f_print(fout, "\t}\n"); 395178354Ssam} 396178354Ssam 397178354Ssamstatic void 398178354Ssaminline_struct(def, flag) 399179401Ssamdefinition *def; 400185744Ssamint flag; 401186904Ssam{ 402189380Ssam decl_list *dl; 403220324Sadrian int i, size; 404224588Sadrian decl_list *cur, *psav; 405225444Sadrian bas_type *ptr; 406178751Ssam char *sizestr, *plus; 407178751Ssam char ptemp[256]; 408116743Ssam int indent = 1; 409188783Ssam 410116743Ssam if (flag == PUT) 411116743Ssam f_print(fout, "\n\tif (xdrs->x_op == XDR_ENCODE) {\n"); 412155490Ssam else 413138570Ssam f_print(fout, "\t\treturn (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n"); 414170530Ssam 415187831Ssam i = 0; 416170530Ssam size = 0; 417116743Ssam sizestr = NULL; 418140432Ssam for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */ 419140432Ssam /* now walk down the list and check for basic types */ 420140761Ssam if ((dl->decl.prefix == NULL) && 421140761Ssam ((ptr = find_type(dl->decl.type)) != NULL) && 422140432Ssam ((dl->decl.rel == REL_ALIAS) || 423140432Ssam (dl->decl.rel == REL_VECTOR))){ 424140432Ssam if (i == 0) 425138570Ssam cur = dl; 426170530Ssam i++; 427155483Ssam 428170530Ssam if (dl->decl.rel == REL_ALIAS) 429170530Ssam size += ptr->length; 430138570Ssam else { 431227346Sadrian /* this code is required to handle arrays */ 432116743Ssam if (sizestr == NULL) 433227651Sadrian plus = ""; 434227346Sadrian else 435227346Sadrian plus = " + "; 436227346Sadrian 437227346Sadrian if (ptr->length != 1) 438227346Sadrian s_print(ptemp, "%s%s * %d", 439227346Sadrian plus, dl->decl.array_max, 440227346Sadrian ptr->length); 441227346Sadrian else 442227346Sadrian s_print(ptemp, "%s%s", plus, 443227346Sadrian dl->decl.array_max); 444227651Sadrian 445227651Sadrian /* now concatenate to sizestr !!!! */ 446227651Sadrian if (sizestr == NULL) 447227651Sadrian sizestr = strdup(ptemp); 448227651Sadrian else{ 449227651Sadrian sizestr = realloc(sizestr, 450227346Sadrian strlen(sizestr) 451138570Ssam +strlen(ptemp)+1); 452147057Ssam if (sizestr == NULL){ 453116743Ssam f_print(stderr, 454228891Sadrian "Fatal error : no memory\n"); 455228891Sadrian crash(); 456228891Sadrian }; 457140432Ssam sizestr = strcat(sizestr, ptemp); 458140432Ssam /* build up length of array */ 459140432Ssam } 460140432Ssam } 461184368Ssam } else { 462140432Ssam if (i > 0) 463140432Ssam if (sizestr == NULL && size < inline){ 464138570Ssam /* 465228891Sadrian * don't expand into inline code 466228891Sadrian * if size < inline 467228891Sadrian */ 468228891Sadrian while (cur != dl){ 469228891Sadrian print_stat(indent + 1, &cur->decl); 470228891Sadrian cur = cur->next; 471155515Ssam } 472155515Ssam } else { 473155515Ssam /* were already looking at a xdr_inlineable structure */ 474178354Ssam tabify(fout, indent + 1); 475138570Ssam if (sizestr == NULL) 476170530Ssam f_print(fout, "buf = XDR_INLINE(xdrs, %d * BYTES_PER_XDR_UNIT);", 477116743Ssam size); 478116743Ssam else 479138570Ssam if (size == 0) 480138570Ssam f_print(fout, 481155492Ssam "buf = XDR_INLINE(xdrs, (%s) * BYTES_PER_XDR_UNIT);", 482192468Ssam sizestr); 483192468Ssam else 484192468Ssam f_print(fout, 485192468Ssam "buf = XDR_INLINE(xdrs, (%d + (%s)) * BYTES_PER_XDR_UNIT);", 486116743Ssam size, sizestr); 487138570Ssam 488138570Ssam f_print(fout, "\n"); 489138570Ssam tabify(fout, indent + 1); 490155482Ssam f_print(fout, 491138570Ssam "if (buf == NULL) {\n"); 492138570Ssam 493138570Ssam psav = cur; 494138570Ssam while (cur != dl){ 495116743Ssam print_stat(indent + 2, &cur->decl); 496233673Sadrian cur = cur->next; 497189605Ssam } 498189605Ssam 499192468Ssam f_print(fout, "\n\t\t} else {\n"); 500192468Ssam 501116743Ssam cur = psav; 502138570Ssam while (cur != dl){ 503138570Ssam emit_inline(indent + 2, &cur->decl, flag); 504116743Ssam cur = cur->next; 505138570Ssam } 506138570Ssam 507138570Ssam tabify(fout, indent + 1); 508116743Ssam f_print(fout, "}\n"); 509138570Ssam } 510232163Sadrian size = 0; 511138570Ssam i = 0; 512138570Ssam sizestr = NULL; 513138570Ssam print_stat(indent + 1, &dl->decl); 514138570Ssam } 515138570Ssam } 516178354Ssam 517178354Ssam if (i > 0) 518178354Ssam if (sizestr == NULL && size < inline){ 519116743Ssam /* don't expand into inline code if size < inline */ 520116743Ssam while (cur != dl){ 521185744Ssam print_stat(indent + 1, &cur->decl); 522185744Ssam cur = cur->next; 523217684Sadrian } 524217684Sadrian } else { 525217684Sadrian /* were already looking at a xdr_inlineable structure */ 526155485Ssam if (sizestr == NULL) 527186904Ssam f_print(fout, "\t\tbuf = XDR_INLINE(xdrs, %d * BYTES_PER_XDR_UNIT);", 528186904Ssam size); 529186904Ssam else 530186904Ssam if (size == 0) 531186904Ssam f_print(fout, 532186904Ssam "\t\tbuf = XDR_INLINE(xdrs, (%s) * BYTES_PER_XDR_UNIT);", 533186904Ssam sizestr); 534186904Ssam else 535217624Sadrian f_print(fout, 536218151Sadrian "\t\tbuf = XDR_INLINE(xdrs, (%d + (%s)) * BYTES_PER_XDR_UNIT);", 537218151Sadrian size, sizestr); 538233967Sadrian 539222585Sadrian f_print(fout, "\n\t\tif (buf == NULL) {\n"); 540232764Sadrian psav = cur; 541232764Sadrian while (cur != NULL){ 542227328Sadrian print_stat(indent + 2, &cur->decl); 543232764Sadrian cur = cur->next; 544232764Sadrian } 545232764Sadrian f_print(fout, "\t\t} else {\n"); 546232764Sadrian 547232764Sadrian cur = psav; 548232764Sadrian while (cur != dl){ 549232764Sadrian emit_inline(indent + 2, &cur->decl, flag); 550232764Sadrian cur = cur->next; 551232764Sadrian } 552232764Sadrian f_print(fout, "\t\t}\n"); 553232764Sadrian } 554232764Sadrian} 555232764Sadrian 556232764Sadrianstatic 557232794Sadrianemit_struct(def) 558232764Sadrian definition *def; 559232764Sadrian{ 560232764Sadrian decl_list *dl; 561232764Sadrian int i, j, size, flag; 562232764Sadrian bas_type *ptr; 563227328Sadrian int can_inline; 564227328Sadrian 565227328Sadrian if (inline == 0) { 566227328Sadrian /* No xdr_inlining at all */ 567227328Sadrian for (dl = def->def.st.decls; dl != NULL; dl = dl->next) 568227328Sadrian print_stat(1, &dl->decl); 569227328Sadrian return; 570227328Sadrian } 571227328Sadrian 572227328Sadrian for (dl = def->def.st.decls; dl != NULL; dl = dl->next) 573227328Sadrian if (dl->decl.rel == REL_VECTOR){ 574227328Sadrian f_print(fout, "\tint i;\n"); 575227328Sadrian break; 576222585Sadrian } 577222585Sadrian 578222668Sadrian size = 0; 579222585Sadrian can_inline = 0; 580227328Sadrian /* 581227328Sadrian * Make a first pass and see if inling is possible. 582227328Sadrian */ 583227328Sadrian for (dl = def->def.st.decls; dl != NULL; dl = dl->next) 584227328Sadrian if ((dl->decl.prefix == NULL) && 585227328Sadrian ((ptr = find_type(dl->decl.type)) != NULL) && 586227328Sadrian ((dl->decl.rel == REL_ALIAS)|| 587227328Sadrian (dl->decl.rel == REL_VECTOR))){ 588227328Sadrian if (dl->decl.rel == REL_ALIAS) 589227328Sadrian size += ptr->length; 590227328Sadrian else { 591227328Sadrian can_inline = 1; 592227328Sadrian break; /* can be inlined */ 593227328Sadrian } 594116743Ssam } else { 595116743Ssam if (size >= inline){ 596121100Ssam can_inline = 1; 597121100Ssam break; /* can be inlined */ 598167252Ssam } 599121100Ssam size = 0; 600121100Ssam } 601121100Ssam if (size >= inline) 602121100Ssam can_inline = 1; 603227651Sadrian 604121100Ssam if (can_inline == 0){ /* can not inline, drop back to old mode */ 605227328Sadrian for (dl = def->def.st.decls; dl != NULL; dl = dl->next) 606227328Sadrian print_stat(1, &dl->decl); 607227328Sadrian return; 608227328Sadrian } 609227328Sadrian 610227328Sadrian flag = PUT; 611227328Sadrian for (j = 0; j < 2; j++){ 612227328Sadrian inline_struct(def, flag); 613227328Sadrian if (flag == PUT) 614227328Sadrian flag = GET; 615227328Sadrian } 616227328Sadrian 617227328Sadrian f_print(fout, "\t\treturn (TRUE);\n\t}\n\n"); 618227328Sadrian 619227328Sadrian /* now take care of XDR_FREE case */ 620227328Sadrian 621227328Sadrian for (dl = def->def.st.decls; dl != NULL; dl = dl->next) 622227328Sadrian print_stat(1, &dl->decl); 623227328Sadrian 624227328Sadrian} 625227328Sadrian 626227328Sadrianstatic 627227328Sadrianemit_typedef(def) 628227328Sadrian definition *def; 629227328Sadrian{ 630227328Sadrian char *prefix = def->def.ty.old_prefix; 631227328Sadrian char *type = def->def.ty.old_type; 632227328Sadrian char *amax = def->def.ty.array_max; 633227328Sadrian relation rel = def->def.ty.rel; 634227328Sadrian 635227651Sadrian print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name); 636227651Sadrian} 637227328Sadrian 638138570Ssamstatic 639138570Ssamprint_stat(indent, dec) 640155482Ssam int indent; 641155482Ssam declaration *dec; 642155482Ssam{ 643167252Ssam char *prefix = dec->prefix; 644155482Ssam char *type = dec->type; 645121100Ssam char *amax = dec->array_max; 646121100Ssam relation rel = dec->rel; 647121100Ssam char name[256]; 648121100Ssam 649121100Ssam if (isvectordef(type, rel)) { 650121100Ssam s_print(name, "objp->%s", dec->name); 651116743Ssam } else { 652116743Ssam s_print(name, "&objp->%s", dec->name); 653116743Ssam } 654116743Ssam print_ifstat(indent, prefix, type, rel, amax, name, dec->name); 655116743Ssam} 656116743Ssam 657116743Ssam 658116743Ssamchar *upcase (); 659116743Ssam 660116743Ssamemit_inline(indent, decl, flag) 661138570Ssamint indent; 662138570Ssamdeclaration *decl; 663116743Ssamint flag; 664116743Ssam{ 665186904Ssam switch (decl->rel) { 666186904Ssam case REL_ALIAS : 667116743Ssam emit_single_in_line(indent, decl, flag, REL_ALIAS); 668116743Ssam break; 669116743Ssam case REL_VECTOR : 670116743Ssam tabify(fout, indent); 671138570Ssam f_print(fout, "{\n"); 672138570Ssam tabify(fout, indent + 1); 673178354Ssam f_print(fout, "register %s *genp;\n\n", decl->type); 674178354Ssam tabify(fout, indent + 1); 675178354Ssam f_print(fout, 676178354Ssam "for (i = 0, genp = objp->%s;\n", decl->name); 677116743Ssam tabify(fout, indent + 2); 678116743Ssam f_print(fout, "i < %s; i++) {\n", decl->array_max); 679116743Ssam emit_single_in_line(indent + 2, decl, flag, REL_VECTOR); 680116743Ssam tabify(fout, indent + 1); 681116743Ssam f_print(fout, "}\n"); 682116743Ssam tabify(fout, indent); 683116743Ssam f_print(fout, "}\n"); 684116743Ssam } 685116743Ssam} 686116743Ssam 687155515Ssamemit_single_in_line(indent, decl, flag, rel) 688155515Ssamint indent; 689138570Ssamdeclaration *decl; 690138570Ssamint flag; 691116743Ssamrelation rel; 692116743Ssam{ 693138570Ssam char *upp_case; 694138570Ssam int freed = 0; 695116743Ssam 696116743Ssam tabify(fout, indent); 697116743Ssam if (flag == PUT) 698116743Ssam f_print(fout, "IXDR_PUT_"); 699116743Ssam else 700116743Ssam if (rel == REL_ALIAS) 701116743Ssam f_print(fout, "objp->%s = IXDR_GET_", decl->name); 702116743Ssam else 703116743Ssam f_print(fout, "*genp++ = IXDR_GET_"); 704116743Ssam 705116743Ssam upp_case = upcase(decl->type); 706116743Ssam 707116743Ssam /* hack - XX */ 708116743Ssam if (strcmp(upp_case, "INT") == 0) 709186904Ssam { 710186904Ssam free(upp_case); 711116743Ssam freed = 1; 712186904Ssam upp_case = "LONG"; 713116743Ssam } 714116743Ssam 715116743Ssam if (strcmp(upp_case, "U_INT") == 0) 716116743Ssam { 717116743Ssam free(upp_case); 718116743Ssam freed = 1; 719116743Ssam upp_case = "U_LONG"; 720116743Ssam } 721116743Ssam if (flag == PUT) 722116743Ssam if (rel == REL_ALIAS) 723138570Ssam f_print(fout, 724138570Ssam "%s(buf, objp->%s);\n", upp_case, decl->name); 725116743Ssam else 726116743Ssam f_print(fout, "%s(buf, *genp++);\n", upp_case); 727116743Ssam 728116743Ssam else 729116743Ssam f_print(fout, "%s(buf);\n", upp_case); 730116743Ssam if (!freed) 731155515Ssam free(upp_case); 732155515Ssam} 733185744Ssam 734185744Ssamchar *upcase(str) 735185744Ssamchar *str; 736185744Ssam{ 737116743Ssam char *ptr, *hptr; 738116743Ssam 739138570Ssam ptr = (char *)malloc(strlen(str)+1); 740138570Ssam if (ptr == (char *) NULL) 741116743Ssam { 742116743Ssam f_print(stderr, "malloc failed\n"); 743186904Ssam exit(1); 744186904Ssam }; 745138570Ssam 746138570Ssam hptr = ptr; 747225444Sadrian while (*str != '\0') 748225444Sadrian *ptr++ = toupper(*str++); 749116743Ssam 750138570Ssam *ptr = '\0'; 751138570Ssam return (hptr); 752138570Ssam} 753138570Ssam