usr/src/cmd/rpcgen/rpc_cout.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  27 /* All Rights Reserved */
  28 /*
  29  * University Copyright- Copyright (c) 1982, 1986, 1988
  30  * The Regents of the University of California
  31  * All Rights Reserved
  32  *
  33  * University Acknowledgment- Portions of this document are derived from
  34  * software developed by the University of California, Berkeley, and its
  35  * contributors.
  36  */
  37
  38 /*
  39  * rpc_cout.c, XDR routine outputter for the RPC protocol compiler
  40  */
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include "rpc_parse.h"
  46 #include "rpc_util.h"
  47
  48 extern void crash(void);
  49
  50 static void print_header(definition *);
  51 static void print_trailer(void);
  52 static void emit_enum(definition *);
  53 static void emit_program(definition *);
  54 static void emit_union(definition *);
  55 static void emit_struct(definition *);
  56 static void emit_typedef(definition *);
  57 static void print_stat(int, declaration *);
  58 static void emit_inline(int, declaration *, int);
  59 static void emit_inline64(int, declaration *, int);
  60 static void emit_single_in_line(int, declaration *, int, relation);
  61 static void emit_single_in_line64(int, declaration *, int, relation);
  62 static char *upcase(char *);
  63
  64 /*
  65  * Emit the C-routine for the given definition
  66  */
  67 void
  68 emit(definition *def)
  69 {
  70         if (def->def_kind == DEF_CONST)
  71                 return;
  72         if (def->def_kind == DEF_PROGRAM) {
  73                 emit_program(def);
  74                 return;
  75         }
  76         if (def->def_kind == DEF_TYPEDEF) {
  77                 /*
  78                  * now we need to handle declarations like
  79                  * struct typedef foo foo;
  80                  * since we dont want this to be expanded into 2 calls
  81                  * to xdr_foo
  82                  */
  83
  84                 if (strcmp(def->def.ty.old_type, def->def_name) == 0)
  85                         return;
  86         };
  87         print_header(def);
  88         switch (def->def_kind) {
  89         case DEF_UNION:
  90                 emit_union(def);
  91                 break;
  92         case DEF_ENUM:
  93                 emit_enum(def);
  94                 break;
  95         case DEF_STRUCT:
  96                 emit_struct(def);
  97                 break;
  98         case DEF_TYPEDEF:
  99                 emit_typedef(def);
 100                 break;
 101         }
 102         print_trailer();
 103 }
 104
 105 static int
 106 findtype(definition *def, char *type)
 107 {
 108
 109         if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST)
 110                 return (0);
 111         return (streq(def->def_name, type));
 112 }
 113
 114 static int
 115 undefined(char *type)
 116 {
 117         definition *def;
 118
 119         def = (definition *)FINDVAL(defined, type, findtype);
 120         return (def == NULL);
 121 }
 122
 123
 124 static void
 125 print_generic_header(char *procname, int pointerp)
 126 {
 127         f_print(fout, "\n");
 128         f_print(fout, "bool_t\n");
 129         if (Cflag) {
 130                 f_print(fout, "xdr_%s(", procname);
 131                 f_print(fout, "XDR *xdrs, ");
 132                 f_print(fout, "%s ", procname);
 133                 if (pointerp)
 134                         f_print(fout, "*");
 135                 f_print(fout, "objp)\n{\n\n");
 136         } else {
 137                 f_print(fout, "xdr_%s(xdrs, objp)\n", procname);
 138                 f_print(fout, "\tXDR *xdrs;\n");
 139                 f_print(fout, "\t%s ", procname);
 140                 if (pointerp)
 141                         f_print(fout, "*");
 142                 f_print(fout, "objp;\n{\n\n");
 143         }
 144 }
 145
 146 static void
 147 print_header(definition *def)
 148 {
 149         print_generic_header(def->def_name,
 150             def->def_kind != DEF_TYPEDEF ||
 151             !isvectordef(def->def.ty.old_type, def->def.ty.rel));
 152         /* Now add Inline support */
 153
 154         if (inlinelen == 0)
 155                 return;
 156         /* May cause lint to complain. but  ... */
 157         f_print(fout, "\trpc_inline_t *buf;\n\n");
 158 }
 159
 160 static void
 161 print_prog_header(proc_list *plist)
 162 {
 163         print_generic_header(plist->args.argname, 1);
 164 }
 165
 166 static void
 167 print_trailer(void)
 168 {
 169         f_print(fout, "\treturn (TRUE);\n");
 170         f_print(fout, "}\n");
 171 }
 172
 173
 174 static void
 175 print_ifopen(int indent, char *name)
 176 {
 177         tabify(fout, indent);
 178         if (streq(name, "rpcprog_t") ||
 179             streq(name, "rpcvers_t") ||
 180             streq(name, "rpcproc_t") ||
 181             streq(name, "rpcprot_t") ||
 182             streq(name, "rpcport_t"))
 183                 (void) strtok(name, "_");
 184         f_print(fout, "if (!xdr_%s(xdrs", name);
 185 }
 186
 187 static void
 188 print_ifarg(char *arg)
 189 {
 190         f_print(fout, ", %s", arg);
 191 }
 192
 193 static void
 194 print_ifsizeof(int indent, char *prefix, char *type)
 195 {
 196         if (indent) {
 197                 f_print(fout, ",\n");
 198                 tabify(fout, indent);
 199         } else {
 200                 f_print(fout, ", ");
 201         }
 202         if (streq(type, "bool")) {
 203                 f_print(fout, "sizeof (bool_t), (xdrproc_t)xdr_bool");
 204         } else {
 205                 f_print(fout, "sizeof (");
 206                 if (undefined(type) && prefix) {
 207                         f_print(fout, "%s ", prefix);
 208                 }
 209                 f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
 210         }
 211 }
 212
 213 static void
 214 print_ifclose(int indent)
 215 {
 216         f_print(fout, "))\n");
 217         tabify(fout, indent);
 218         f_print(fout, "\treturn (FALSE);\n");
 219 }
 220
 221 static void
 222 print_ifstat(int indent, char *prefix, char *type, relation rel,
 223                                         char *amax, char *objname, char *name)
 224 {
 225         char *alt = NULL;
 226
 227         switch (rel) {
 228         case REL_POINTER:
 229                 print_ifopen(indent, "pointer");
 230                 print_ifarg("(char **)");
 231                 f_print(fout, "%s", objname);
 232                 print_ifsizeof(0, prefix, type);
 233                 break;
 234         case REL_VECTOR:
 235                 if (streq(type, "string"))
 236                         alt = "string";
 237                 else if (streq(type, "opaque"))
 238                         alt = "opaque";
 239                 if (alt) {
 240                         print_ifopen(indent, alt);
 241                         print_ifarg(objname);
 242                 } else {
 243                         print_ifopen(indent, "vector");
 244                         print_ifarg("(char *)");
 245                         f_print(fout, "%s", objname);
 246                 }
 247                 print_ifarg(amax);
 248                 if (!alt)
 249                         print_ifsizeof(indent + 1, prefix, type);
 250                 break;
 251         case REL_ARRAY:
 252                 if (streq(type, "string"))
 253                         alt = "string";
 254                 else if (streq(type, "opaque"))
 255                         alt = "bytes";
 256                 if (streq(type, "string")) {
 257                         print_ifopen(indent, alt);
 258                         print_ifarg(objname);
 259                 } else {
 260                         if (alt)
 261                                 print_ifopen(indent, alt);
 262                         else
 263                                 print_ifopen(indent, "array");
 264                         print_ifarg("(char **)");
 265                         if (*objname == '&')
 266                                 f_print(fout, "%s.%s_val, (u_int *) %s.%s_len",
 267                                     objname, name, objname, name);
 268                         else
 269                                 f_print(fout,
 270                                     "&%s->%s_val, (u_int *) &%s->%s_len",
 271                                     objname, name, objname, name);
 272                 }
 273                 print_ifarg(amax);
 274                 if (!alt)
 275                         print_ifsizeof(indent + 1, prefix, type);
 276                 break;
 277         case REL_ALIAS:
 278                 print_ifopen(indent, type);
 279                 print_ifarg(objname);
 280                 break;
 281         }
 282         print_ifclose(indent);
 283 }
 284
 285 /* ARGSUSED */
 286 static void
 287 emit_enum(definition *def)
 288 {
 289         print_ifopen(1, "enum");
 290         print_ifarg("(enum_t *)objp");
 291         print_ifclose(1);
 292 }
 293
 294 static void
 295 emit_program(definition *def)
 296 {
 297         decl_list *dl;
 298         version_list *vlist;
 299         proc_list *plist;
 300
 301         for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
 302                 for (plist = vlist->procs; plist != NULL; plist = plist->next) {
 303                         if (!newstyle || plist->arg_num < 2)
 304                                 continue; /* old style, or single argument */
 305                         print_prog_header(plist);
 306                         for (dl = plist->args.decls; dl != NULL;
 307                             dl = dl->next)
 308                                 print_stat(1, &dl->decl);
 309                         print_trailer();
 310                 }
 311 }
 312
 313
 314 static void
 315 emit_union(definition *def)
 316 {
 317         declaration *dflt;
 318         case_list *cl;
 319         declaration *cs;
 320         char *object;
 321
 322         print_stat(1, &def->def.un.enum_decl);
 323         f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
 324         for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
 325
 326                 f_print(fout, "\tcase %s:\n", cl->case_name);
 327                 if (cl->contflag == 1) /* a continued case statement */
 328                         continue;
 329                 cs = &cl->case_decl;
 330                 if (!streq(cs->type, "void")) {
 331                         size_t len = strlen(def->def_name) +
 332                             strlen("&objp->%s_u.%s") +
 333                             strlen(cs->name) + 1;
 334                         object = malloc(len);
 335                         if (isvectordef(cs->type, cs->rel))
 336                                 (void) snprintf(object, len, "objp->%s_u.%s",
 337                                     def->def_name, cs->name);
 338                         else
 339                                 (void) snprintf(object, len, "&objp->%s_u.%s",
 340                                     def->def_name, cs->name);
 341                         print_ifstat(2, cs->prefix, cs->type, cs->rel,
 342                             cs->array_max, object, cs->name);
 343                         free(object);
 344                 }
 345                 f_print(fout, "\t\tbreak;\n");
 346         }
 347         dflt = def->def.un.default_decl;
 348         if (dflt != NULL) {
 349                 if (!streq(dflt->type, "void")) {
 350                         size_t len = strlen(def->def_name) +
 351                             strlen("&objp->%s_u.%s") +
 352                             strlen(dflt->name) + 1;
 353                         f_print(fout, "\tdefault:\n");
 354                         object = malloc(len);
 355                         if (isvectordef(dflt->type, dflt->rel))
 356                                 (void) snprintf(object, len, "objp->%s_u.%s",
 357                                     def->def_name, dflt->name);
 358                         else
 359                                 (void) snprintf(object, len, "&objp->%s_u.%s",
 360                                     def->def_name, dflt->name);
 361
 362                         print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
 363                             dflt->array_max, object, dflt->name);
 364                         free(object);
 365                         f_print(fout, "\t\tbreak;\n");
 366                 }
 367         } else {
 368                 f_print(fout, "\tdefault:\n");
 369                 f_print(fout, "\t\treturn (FALSE);\n");
 370         }
 371
 372         f_print(fout, "\t}\n");
 373 }
 374
 375 static void
 376 expand_inline(int indent, const char *sizestr,
 377     int size, int flag, decl_list *dl, decl_list *cur)
 378 {
 379         decl_list *psav;
 380
 381         /*
 382          * were already looking at a xdr_inlineable structure
 383          */
 384         tabify(fout, indent + 1);
 385         if (sizestr == NULL)
 386                 f_print(fout,
 387                     "buf = XDR_INLINE(xdrs, %d * BYTES_PER_XDR_UNIT);",
 388                     size);
 389         else if (size == 0)
 390                 f_print(fout,
 391                     "buf = XDR_INLINE(xdrs, (%s) * BYTES_PER_XDR_UNIT);",
 392                     sizestr);
 393         else
 394                 f_print(fout,
 395                     "buf = XDR_INLINE(xdrs, (%d + (%s)) "
 396                     "* BYTES_PER_XDR_UNIT);", size, sizestr);
 397
 398         f_print(fout, "\n");
 399         tabify(fout, indent + 1);
 400         f_print(fout, "if (buf == NULL) {\n");
 401
 402         psav = cur;
 403         while (cur != dl) {
 404                 print_stat(indent + 2,
 405                     &cur->decl);
 406                 cur = cur->next;
 407         }
 408
 409         tabify(fout, indent+1);
 410         f_print(fout, "} else {\n");
 411
 412         f_print(fout, "#if defined(_LP64) || defined(_KERNEL)\n");
 413         cur = psav;
 414         while (cur != dl) {
 415                 emit_inline64(indent + 2, &cur->decl, flag);
 416                 cur = cur->next;
 417         }
 418         f_print(fout, "#else\n");
 419         cur = psav;
 420         while (cur != dl) {
 421                 emit_inline(indent + 2, &cur->decl, flag);
 422                 cur = cur->next;
 423         }
 424         f_print(fout, "#endif\n");
 425
 426         tabify(fout, indent + 1);
 427         f_print(fout, "}\n");
 428 }
 429
 430 /*
 431  * An inline type is a base type (interger type) or a vector of base types.
 432  */
 433 static int
 434 inline_type(declaration *dc, int *size)
 435 {
 436         bas_type *ptr;
 437
 438         *size = 0;
 439
 440         if (dc->prefix == NULL &&
 441             (dc->rel == REL_ALIAS || dc->rel == REL_VECTOR)) {
 442                 ptr = find_type(dc->type);
 443                 if (ptr != NULL) {
 444                         *size = ptr->length;
 445                         return (1);
 446                 }
 447         }
 448
 449         return (0);
 450 }
 451
 452 static char *
 453 arraysize(char *sz, declaration *dc, int elsize)
 454 {
 455         int len;
 456         int elsz = elsize;
 457         int digits;
 458         int slen = 0;
 459         char *plus = "";
 460         char *tmp;
 461         size_t tlen;
 462
 463         /*
 464          * Calculate the size of a string to hold the size of all arrays
 465          * to be inlined.
 466          *
 467          * We have the string representation of the total size that has already
 468          * been seen. (Null if this is the first array).
 469          * We have the string representation of array max from the declaration,
 470          * optionally the plus string, " + ", if this is not the first array,
 471          * and the number of digits for the element size for this declaration.
 472          */
 473         if (sz != NULL) {
 474                 plus = " + ";
 475                 slen = strlen(sz);
 476         }
 477
 478         /* Calculate the number of digits to hold the element size */
 479         for (digits = 1; elsz >= 10; digits++)
 480                 elsz /= 10;
 481
 482         /*
 483          * If elsize != 1 the allocate 3 extra bytes for the times
 484          * string, " * ", the "()" below,  and the digits. One extra
 485          * for the trailing NULL
 486          */
 487         len = strlen(dc->array_max) +  (elsize == 1 ? 0 : digits + 5) + 1;
 488         tlen = slen + len + strlen(plus);
 489         tmp = realloc(sz, tlen);
 490         if (tmp == NULL) {
 491                 f_print(stderr, "Fatal error : no memory\n");
 492                 crash();
 493         }
 494
 495         if (elsize == 1)
 496                 (void) snprintf(tmp + slen, tlen - slen, "%s%s",
 497                     plus, dc->array_max);
 498         else
 499                 (void) snprintf(tmp + slen, tlen - slen, "%s(%s) * %d",
 500                     plus, dc->array_max, elsize);
 501
 502         return (tmp);
 503 }
 504
 505 static void
 506 inline_struct(decl_list *dl, decl_list *last, int flag, int indent)
 507 {
 508         int size, tsize;
 509         decl_list *cur;
 510         char *sizestr;
 511
 512         cur = NULL;
 513         tsize = 0;
 514         sizestr = NULL;
 515         for (; dl != last; dl = dl->next) {
 516                 if (inline_type(&dl->decl, &size)) {
 517                         if (cur == NULL)
 518                                 cur = dl;
 519
 520                         if (dl->decl.rel == REL_ALIAS)
 521                                 tsize += size;
 522                         else {
 523                                 /* this code is required to handle arrays */
 524                                 sizestr = arraysize(sizestr, &dl->decl, size);
 525                         }
 526                 } else {
 527                         if (cur != NULL)
 528                                 if (sizestr == NULL && tsize < inlinelen) {
 529                                         /*
 530                                          * don't expand into inline code
 531                                          * if tsize < inlinelen
 532                                          */
 533                                         while (cur != dl) {
 534                                                 print_stat(indent + 1,
 535                                                     &cur->decl);
 536                                                 cur = cur->next;
 537                                         }
 538                                 } else {
 539                                         expand_inline(indent, sizestr,
 540                                             tsize, flag, dl, cur);
 541                                 }
 542                         tsize = 0;
 543                         cur = NULL;
 544                         sizestr = NULL;
 545                         print_stat(indent + 1, &dl->decl);
 546                 }
 547         }
 548
 549         if (cur == NULL)
 550                 return;
 551         if (sizestr == NULL && tsize < inlinelen) {
 552                 /* don't expand into inline code if tsize < inlinelen */
 553                 while (cur != dl) {
 554                         print_stat(indent + 1, &cur->decl);
 555                         cur = cur->next;
 556                 }
 557         } else {
 558                 expand_inline(indent, sizestr, tsize, flag, dl, cur);
 559         }
 560 }
 561
 562 /*
 563  * Check if we can inline this structure. While we are at it check if the
 564  * declaration list has any vectors defined of "basic" types.
 565  */
 566 static int
 567 check_inline(decl_list *dl, int inlinelen, int *have_vector)
 568 {
 569         int tsize = 0;
 570         int size;
 571         int doinline = 0;
 572
 573         *have_vector = 0;
 574         if (inlinelen == 0)
 575                 return (0);
 576
 577         for (; dl != NULL; dl = dl->next) {
 578                 if (!inline_type(&dl->decl, &size)) {
 579                         tsize = 0;
 580                         continue;
 581                 }
 582                 if (dl->decl.rel == REL_VECTOR) {
 583                         *have_vector = 1;
 584                         return (1);
 585                 }
 586                 tsize += size;
 587                 if (tsize >= inlinelen)
 588                         doinline = 1;
 589         }
 590
 591         return (doinline);
 592 }
 593
 594
 595 static void
 596 emit_struct_tail_recursion(definition *defp, int can_inline)
 597 {
 598         int indent = 3;
 599         struct_def *sp = &defp->def.st;
 600         decl_list *dl;
 601
 602
 603         f_print(fout, "\t%s *tmp_%s;\n",
 604             defp->def_name, defp->def_name);
 605
 606         f_print(fout, "\tbool_t more_data = TRUE;\n");
 607         f_print(fout, "\tbool_t first_objp = TRUE;\n\n");
 608
 609         f_print(fout, "\n\tif (xdrs->x_op == XDR_DECODE) {\n");
 610         f_print(fout, "\n\t\twhile (more_data) {\n");
 611         f_print(fout, "\n\t\t\tvoid bzero();\n\n");
 612
 613         if (can_inline)
 614                 inline_struct(sp->decls, sp->tail, GET, indent);
 615         else
 616                 for (dl = sp->decls; dl != NULL && dl != sp->tail;
 617                     dl = dl->next)
 618                         print_stat(indent, &dl->decl);
 619
 620         f_print(fout, "\t\t\tif (!xdr_bool(xdrs, "
 621             "&more_data))\n\t\t\t\treturn (FALSE);\n");
 622
 623         f_print(fout, "\n\t\t\tif (!more_data) {\n");
 624         f_print(fout, "\t\t\t\tobjp->%s = NULL;\n", sp->tail->decl.name);
 625         f_print(fout, "\t\t\t\tbreak;\n");
 626         f_print(fout, "\t\t\t}\n\n");
 627         f_print(fout, "\t\t\tif (objp->%s == NULL) {\n", sp->tail->decl.name);
 628         f_print(fout, "\t\t\t\tobjp->%s = "
 629             "(%s *)\n\t\t\t\t\tmem_alloc(sizeof (%s));\n",
 630             sp->tail->decl.name, defp->def_name, defp->def_name);
 631
 632         f_print(fout, "\t\t\t\tif (objp->%s == NULL)\n"
 633             "\t\t\t\t\treturn (FALSE);\n", sp->tail->decl.name);
 634         f_print(fout, "\t\t\t\tbzero(objp->%s, sizeof (%s));\n",
 635             sp->tail->decl.name, defp->def_name);
 636         f_print(fout, "\t\t\t}\n");
 637         f_print(fout, "\t\t\tobjp = objp->%s;\n", sp->tail->decl.name);
 638         f_print(fout, "\t\t}\n");
 639
 640         f_print(fout, "\n\t} else if (xdrs->x_op == XDR_ENCODE) {\n");
 641         f_print(fout, "\n\t\twhile (more_data) {\n");
 642
 643         if (can_inline)
 644                 inline_struct(sp->decls, sp->tail, PUT, indent);
 645         else
 646                 for (dl = sp->decls; dl != NULL && dl != sp->tail;
 647                     dl = dl->next)
 648                         print_stat(indent, &dl->decl);
 649
 650         f_print(fout, "\t\t\tobjp = objp->%s;\n", sp->tail->decl.name);
 651         f_print(fout, "\t\t\tif (objp == NULL)\n");
 652         f_print(fout, "\t\t\t\tmore_data = FALSE;\n");
 653
 654         f_print(fout, "\t\t\tif (!xdr_bool(xdrs, &more_data))\n"
 655             "\t\t\t\treturn (FALSE);\n");
 656
 657         f_print(fout, "\t\t}\n");
 658
 659         f_print(fout, "\n\t} else {\n");
 660         f_print(fout, "\n\t\twhile (more_data) {\n");
 661
 662         for (dl = sp->decls; dl != NULL && dl != sp->tail; dl = dl->next)
 663                 print_stat(indent, &dl->decl);
 664
 665         f_print(fout, "\t\t\ttmp_%s = objp;\n", defp->def_name);
 666         f_print(fout, "\t\t\tobjp = objp->%s;\n", sp->tail->decl.name);
 667
 668         f_print(fout, "\t\t\tif (objp == NULL)\n");
 669         f_print(fout, "\t\t\t\tmore_data = FALSE;\n");
 670
 671         f_print(fout, "\t\t\tif (!first_objp)\n");
 672
 673         f_print(fout, "\t\t\t\tmem_free(tmp_%s, sizeof (%s));\n",
 674             defp->def_name, defp->def_name);
 675
 676         f_print(fout, "\t\t\telse\n\t\t\t\tfirst_objp = FALSE;\n\t\t}\n");
 677
 678         f_print(fout, "\n\t}\n");
 679 }
 680
 681 static void
 682 emit_struct(definition *def)
 683 {
 684         decl_list *dl = def->def.st.decls;
 685         int can_inline, have_vector;
 686
 687
 688         can_inline = check_inline(dl, inlinelen, &have_vector);
 689         if (have_vector)
 690                 f_print(fout, "\tint i;\n");
 691
 692
 693         if (rflag && def->def.st.self_pointer) {
 694                 /* Handle tail recursion elimination */
 695                 emit_struct_tail_recursion(def, can_inline);
 696                 return;
 697         }
 698
 699
 700         if (can_inline) {
 701                 f_print(fout, "\n\tif (xdrs->x_op == XDR_ENCODE) {\n");
 702                 inline_struct(dl, NULL, PUT, 1);
 703
 704                 f_print(fout, "\t\treturn (TRUE);\n\t}"
 705                     " else if (xdrs->x_op == XDR_DECODE) {\n");
 706
 707                 inline_struct(dl, NULL, GET, 1);
 708                 f_print(fout, "\t\treturn (TRUE);\n\t}\n\n");
 709         }
 710
 711         /* now take care of XDR_FREE inline  case or the non-inline cases */
 712
 713         for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
 714                 print_stat(1, &dl->decl);
 715
 716 }
 717
 718 static void
 719 emit_typedef(definition *def)
 720 {
 721         char *prefix = def->def.ty.old_prefix;
 722         char *type = def->def.ty.old_type;
 723         char *amax = def->def.ty.array_max;
 724         relation rel = def->def.ty.rel;
 725
 726         print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
 727 }
 728
 729 static void
 730 print_stat(int indent, declaration *dec)
 731 {
 732         char *prefix = dec->prefix;
 733         char *type = dec->type;
 734         char *amax = dec->array_max;
 735         relation rel = dec->rel;
 736         char name[256];
 737
 738         if (isvectordef(type, rel))
 739                 (void) snprintf(name, sizeof (name), "objp->%s", dec->name);
 740         else
 741                 (void) snprintf(name, sizeof (name), "&objp->%s", dec->name);
 742         print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
 743 }
 744
 745
 746 static void
 747 emit_inline(int indent, declaration *decl, int flag)
 748 {
 749         switch (decl->rel) {
 750         case  REL_ALIAS :
 751                 emit_single_in_line(indent, decl, flag, REL_ALIAS);
 752                 break;
 753         case REL_VECTOR :
 754                 tabify(fout, indent);
 755                 f_print(fout, "{\n");
 756                 tabify(fout, indent + 1);
 757                 f_print(fout, "%s *genp;\n\n", decl->type);
 758                 tabify(fout, indent + 1);
 759                 f_print(fout,
 760                     "for (i = 0, genp = objp->%s;\n", decl->name);
 761                 tabify(fout, indent + 2);
 762                 f_print(fout, "i < %s; i++) {\n", decl->array_max);
 763                 emit_single_in_line(indent + 2, decl, flag, REL_VECTOR);
 764                 tabify(fout, indent + 1);
 765                 f_print(fout, "}\n");
 766                 tabify(fout, indent);
 767                 f_print(fout, "}\n");
 768         }
 769 }
 770
 771 static void
 772 emit_inline64(int indent, declaration *decl, int flag)
 773 {
 774         switch (decl->rel) {
 775         case  REL_ALIAS :
 776                 emit_single_in_line64(indent, decl, flag, REL_ALIAS);
 777                 break;
 778         case REL_VECTOR :
 779                 tabify(fout, indent);
 780                 f_print(fout, "{\n");
 781                 tabify(fout, indent + 1);
 782                 f_print(fout, "%s *genp;\n\n", decl->type);
 783                 tabify(fout, indent + 1);
 784                 f_print(fout,
 785                     "for (i = 0, genp = objp->%s;\n", decl->name);
 786                 tabify(fout, indent + 2);
 787                 f_print(fout, "i < %s; i++) {\n", decl->array_max);
 788                 emit_single_in_line64(indent + 2, decl, flag, REL_VECTOR);
 789                 tabify(fout, indent + 1);
 790                 f_print(fout, "}\n");
 791                 tabify(fout, indent);
 792                 f_print(fout, "}\n");
 793         }
 794 }
 795
 796 static void
 797 emit_single_in_line(int indent, declaration *decl, int flag, relation rel)
 798 {
 799         char *upp_case;
 800         int freed = 0;
 801
 802         tabify(fout, indent);
 803         if (flag == PUT)
 804                 f_print(fout, "IXDR_PUT_");
 805         else
 806                 if (rel == REL_ALIAS)
 807                         f_print(fout, "objp->%s = IXDR_GET_", decl->name);
 808                 else
 809                         f_print(fout, "*genp++ = IXDR_GET_");
 810
 811         upp_case = upcase(decl->type);
 812
 813         /* hack  - XX */
 814         if (strcmp(upp_case, "INT") == 0) {
 815                 free(upp_case);
 816                 freed = 1;
 817                 upp_case = "LONG";
 818         }
 819         if ((strcmp(upp_case, "U_INT") == 0) ||
 820             (strcmp(upp_case, "RPCPROG") == 0) ||
 821             (strcmp(upp_case, "RPCVERS") == 0) ||
 822             (strcmp(upp_case, "RPCPROC") == 0) ||
 823             (strcmp(upp_case, "RPCPROT") == 0) ||
 824             (strcmp(upp_case, "RPCPORT") == 0)) {
 825                 free(upp_case);
 826                 freed = 1;
 827                 upp_case = "U_LONG";
 828         }
 829
 830         if (flag == PUT)
 831                 if (rel == REL_ALIAS)
 832                         f_print(fout,
 833                             "%s(buf, objp->%s);\n", upp_case, decl->name);
 834                 else
 835                         f_print(fout, "%s(buf, *genp++);\n", upp_case);
 836
 837         else
 838                 f_print(fout, "%s(buf);\n", upp_case);
 839         if (!freed)
 840                 free(upp_case);
 841 }
 842
 843 static void
 844 emit_single_in_line64(int indent, declaration *decl, int flag, relation rel)
 845 {
 846         char *upp_case;
 847         int freed = 0;
 848
 849         tabify(fout, indent);
 850         if (flag == PUT)
 851                 f_print(fout, "IXDR_PUT_");
 852         else
 853                 if (rel == REL_ALIAS)
 854                         f_print(fout, "objp->%s = IXDR_GET_", decl->name);
 855                 else
 856                         f_print(fout, "*genp++ = IXDR_GET_");
 857
 858         upp_case = upcase(decl->type);
 859
 860         /* hack  - XX */
 861         if ((strcmp(upp_case, "INT") == 0)||(strcmp(upp_case, "LONG") == 0)) {
 862                 free(upp_case);
 863                 freed = 1;
 864                 upp_case = "INT32";
 865         }
 866         if ((strcmp(upp_case, "U_INT") == 0) ||
 867             (strcmp(upp_case, "U_LONG") == 0) ||
 868             (strcmp(upp_case, "RPCPROG") == 0) ||
 869             (strcmp(upp_case, "RPCVERS") == 0) ||
 870             (strcmp(upp_case, "RPCPROC") == 0) ||
 871             (strcmp(upp_case, "RPCPROT") == 0) ||
 872             (strcmp(upp_case, "RPCPORT") == 0)) {
 873                 free(upp_case);
 874                 freed = 1;
 875                 upp_case = "U_INT32";
 876         }
 877
 878         if (flag == PUT)
 879                 if (rel == REL_ALIAS)
 880                         f_print(fout,
 881                             "%s(buf, objp->%s);\n", upp_case, decl->name);
 882                 else
 883                         f_print(fout, "%s(buf, *genp++);\n", upp_case);
 884
 885         else
 886                 f_print(fout, "%s(buf);\n", upp_case);
 887         if (!freed)
 888                 free(upp_case);
 889 }
 890
 891 static char *
 892 upcase(char *str)
 893 {
 894         char *ptr, *hptr;
 895
 896         ptr = malloc(strlen(str)+1);
 897         if (ptr == NULL) {
 898                 f_print(stderr, "malloc failed\n");
 899                 exit(1);
 900         };
 901
 902         hptr = ptr;
 903         while (*str != '\0')
 904                 *ptr++ = toupper(*str++);
 905
 906         *ptr = '\0';
 907         return (hptr);
 908 }