usr.bin/rpcgen/rpc_hout.c

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user.
   8  *
   9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12  *
  13  * Sun RPC is provided with no support and without any obligation on the
  14  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15  * modification or enhancement.
  16  *
  17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19  * OR ANY PART THEREOF.
  20  *
  21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22  * or profits or other special, indirect and consequential damages, even if
  23  * Sun has been advised of the possibility of such damages.
  24  *
  25  * Sun Microsystems, Inc.
  26  * 2550 Garcia Avenue
  27  * Mountain View, California  94043
  28  *
  29  * @(#)rpc_hout.c 1.12 89/02/22 (C) 1987 SMI
  30  * $DragonFly: src/usr.bin/rpcgen/rpc_hout.c,v 1.3 2003/11/03 19:14:35 eirikn Exp $
  31  */
  32
  33 #ident  "@(#)rpc_hout.c 1.16    94/04/25 SMI"
  34
  35 /*
  36  * rpc_hout.c, Header file outputter for the RPC protocol compiler
  37  * Copyright (C) 1987, Sun Microsystems, Inc.
  38  */
  39 #include <stdio.h>
  40 #include <ctype.h>
  41 #include "rpc_parse.h"
  42 #include "rpc_util.h"
  43
  44 void storexdrfuncdecl __P(( char *, int ));
  45 static void pconstdef __P(( definition * ));
  46 static void pstructdef __P(( definition * ));
  47 static void puniondef __P(( definition * ));
  48 static void pprogramdef __P(( definition * ));
  49 static void pstructdef __P(( definition * ));
  50 static void penumdef __P(( definition * ));
  51 static void ptypedef __P(( definition * ));
  52 static void pdefine __P(( char *, char * ));
  53 static int undefined2 __P(( char *, char * ));
  54 static void parglist __P(( proc_list *, char * ));
  55 static void pprocdef __P(( proc_list *, version_list *, char *, int, int ));
  56 void pdeclaration __P(( char *, declaration *, int, char * ));
  57
  58 static char RESULT[] = "clnt_res";
  59
  60
  61 /*
  62  * Print the C-version of an xdr definition
  63  */
  64 void
  65 print_datadef(def)
  66         definition *def;
  67 {
  68
  69         if (def->def_kind == DEF_PROGRAM)  /* handle data only */
  70                 return;
  71
  72         if (def->def_kind != DEF_CONST) {
  73                 f_print(fout, "\n");
  74         }
  75         switch (def->def_kind) {
  76         case DEF_STRUCT:
  77                 pstructdef(def);
  78                 break;
  79         case DEF_UNION:
  80                 puniondef(def);
  81                 break;
  82         case DEF_ENUM:
  83                 penumdef(def);
  84                 break;
  85         case DEF_TYPEDEF:
  86                 ptypedef(def);
  87                 break;
  88         case DEF_PROGRAM:
  89                 pprogramdef(def);
  90                 break;
  91         case DEF_CONST:
  92                 pconstdef(def);
  93                 break;
  94         }
  95         if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) {
  96             storexdrfuncdecl(def->def_name,
  97                              def->def_kind != DEF_TYPEDEF ||
  98                              !isvectordef(def->def.ty.old_type,
  99                                           def->def.ty.rel));
 100         }
 101 }
 102
 103
 104 void
 105 print_funcdef(def)
 106         definition *def;
 107 {
 108         switch (def->def_kind) {
 109         case DEF_PROGRAM:
 110                 f_print(fout, "\n");
 111                 pprogramdef(def);
 112                 break;
 113         default:
 114         }
 115 }
 116
 117 /* store away enough information to allow the XDR functions to be spat
 118     out at the end of the file */
 119
 120 void
 121 storexdrfuncdecl(name, pointerp)
 122 char *name;
 123 int pointerp;
 124 {
 125         xdrfunc * xdrptr;
 126
 127         xdrptr = (xdrfunc *) malloc(sizeof (struct xdrfunc));
 128
 129         xdrptr->name = name;
 130         xdrptr->pointerp = pointerp;
 131         xdrptr->next = NULL;
 132
 133         if (xdrfunc_tail == NULL){
 134                 xdrfunc_head = xdrptr;
 135                 xdrfunc_tail = xdrptr;
 136         } else {
 137                 xdrfunc_tail->next = xdrptr;
 138                 xdrfunc_tail = xdrptr;
 139         }
 140
 141
 142 }
 143
 144 void
 145 print_xdr_func_def(name, pointerp, i)
 146 char* name;
 147 int pointerp;
 148 int i;
 149 {
 150         if (i == 2) {
 151                 f_print(fout, "extern bool_t xdr_%s();\n", name);
 152                 return;
 153         }
 154         else
 155                 f_print(fout, "extern  bool_t xdr_%s(XDR *, %s%s);\n", name,
 156                         name, pointerp ? "*" : "");
 157
 158
 159 }
 160
 161
 162 static void
 163 pconstdef(def)
 164         definition *def;
 165 {
 166         pdefine(def->def_name, def->def.co);
 167 }
 168
 169 /* print out the definitions for the arguments of functions in the
 170     header file
 171 */
 172 static void
 173 pargdef(def)
 174         definition *def;
 175 {
 176         decl_list *l;
 177         version_list *vers;
 178         char *name;
 179         proc_list *plist;
 180
 181
 182         for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
 183                         for (plist = vers->procs; plist != NULL;
 184                             plist = plist->next) {
 185
 186                                 if (!newstyle || plist->arg_num < 2) {
 187                                         continue; /* old style or single args */
 188                                 }
 189                                 name = plist->args.argname;
 190                                 f_print(fout, "struct %s {\n", name);
 191                                 for (l = plist->args.decls;
 192                                     l != NULL; l = l->next) {
 193                                         pdeclaration(name, &l->decl, 1,
 194                                                      ";\n");
 195                                 }
 196                                 f_print(fout, "};\n");
 197                                 f_print(fout, "typedef struct %s %s;\n",
 198                                         name, name);
 199                                 storexdrfuncdecl(name, 1);
 200                                 f_print(fout, "\n");
 201                         }
 202                 }
 203 }
 204
 205
 206 static void
 207 pstructdef(def)
 208         definition *def;
 209 {
 210         decl_list *l;
 211         char *name = def->def_name;
 212
 213         f_print(fout, "struct %s {\n", name);
 214         for (l = def->def.st.decls; l != NULL; l = l->next) {
 215                 pdeclaration(name, &l->decl, 1, ";\n");
 216         }
 217         f_print(fout, "};\n");
 218         f_print(fout, "typedef struct %s %s;\n", name, name);
 219 }
 220
 221 static void
 222 puniondef(def)
 223         definition *def;
 224 {
 225         case_list *l;
 226         char *name = def->def_name;
 227         declaration *decl;
 228
 229         f_print(fout, "struct %s {\n", name);
 230         decl = &def->def.un.enum_decl;
 231         if (streq(decl->type, "bool")) {
 232                 f_print(fout, "\tbool_t %s;\n", decl->name);
 233         } else {
 234                 f_print(fout, "\t%s %s;\n", decl->type, decl->name);
 235         }
 236         f_print(fout, "\tunion {\n");
 237         for (l = def->def.un.cases; l != NULL; l = l->next) {
 238             if (l->contflag == 0)
 239                 pdeclaration(name, &l->case_decl, 2, ";\n");
 240         }
 241         decl = def->def.un.default_decl;
 242         if (decl && !streq(decl->type, "void")) {
 243                 pdeclaration(name, decl, 2, ";\n");
 244         }
 245         f_print(fout, "\t} %s_u;\n", name);
 246         f_print(fout, "};\n");
 247         f_print(fout, "typedef struct %s %s;\n", name, name);
 248 }
 249
 250 static void
 251 pdefine(name, num)
 252         char *name;
 253         char *num;
 254 {
 255         f_print(fout, "#define\t%s %s\n", name, num);
 256 }
 257
 258 static void
 259 puldefine(name, num)
 260         char *name;
 261         char *num;
 262 {
 263         f_print(fout, "#define\t%s ((unsigned long)(%s))\n", name, num);
 264 }
 265
 266 static int
 267 define_printed(stop, start)
 268         proc_list *stop;
 269         version_list *start;
 270 {
 271         version_list *vers;
 272         proc_list *proc;
 273
 274         for (vers = start; vers != NULL; vers = vers->next) {
 275                 for (proc = vers->procs; proc != NULL; proc = proc->next) {
 276                         if (proc == stop) {
 277                                 return (0);
 278                         } else if (streq(proc->proc_name, stop->proc_name)) {
 279                                 return (1);
 280                         }
 281                 }
 282         }
 283         abort();
 284         /* NOTREACHED */
 285 }
 286
 287 static void
 288 pfreeprocdef(char * name, char *vers, int mode)
 289 {
 290         f_print(fout, "extern int ");
 291         pvname(name, vers);
 292         if (mode == 1)
 293                 f_print(fout,"_freeresult(SVCXPRT *, xdrproc_t, caddr_t);\n");
 294         else
 295                 f_print(fout,"_freeresult();\n");
 296
 297
 298 }
 299
 300 static void
 301 pprogramdef(def)
 302         definition *def;
 303 {
 304         version_list *vers;
 305         proc_list *proc;
 306         int i;
 307         char *ext;
 308
 309         pargdef(def);
 310
 311         puldefine(def->def_name, def->def.pr.prog_num);
 312         for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
 313                 if (tblflag) {
 314                         f_print(fout,
 315                                 "extern struct rpcgen_table %s_%s_table[];\n",
 316                                 locase(def->def_name), vers->vers_num);
 317                         f_print(fout,
 318                                 "extern %s_%s_nproc;\n",
 319                                 locase(def->def_name), vers->vers_num);
 320                 }
 321                 puldefine(vers->vers_name, vers->vers_num);
 322
 323                 /*
 324                  * Print out 2 definitions, one for ANSI-C, another for
 325                  * old K & R C
 326                  */
 327
 328                 if(!Cflag){
 329                         ext = "extern  ";
 330                         for (proc = vers->procs; proc != NULL;
 331                              proc = proc->next) {
 332                                 if (!define_printed(proc,
 333                                                     def->def.pr.versions)) {
 334                                         puldefine(proc->proc_name,
 335                                                   proc->proc_num);
 336                                 }
 337                                 f_print(fout, "%s", ext);
 338                                 pprocdef(proc, vers, NULL, 0, 2);
 339
 340                                 if (mtflag) {
 341                                         f_print(fout, "%s", ext);
 342                                         pprocdef(proc, vers, NULL, 1, 2);
 343                                 }
 344                         }
 345                         pfreeprocdef(def->def_name, vers->vers_num, 2);
 346
 347                 } else {
 348                         for (i = 1; i < 3; i++){
 349                                 if (i == 1){
 350                                         f_print(fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");
 351                                         ext = "extern  ";
 352                                 }else{
 353                                         f_print(fout, "\n#else /* K&R C */\n");
 354                                         ext = "extern  ";
 355                                 }
 356
 357                                 for (proc = vers->procs; proc != NULL;
 358                                      proc = proc->next) {
 359                                         if (!define_printed(proc,
 360                                                             def->def.pr.versions)) {
 361                                                 puldefine(proc->proc_name,
 362                                                           proc->proc_num);
 363                                         }
 364                                         f_print(fout, "%s", ext);
 365                                         pprocdef(proc, vers, "CLIENT *", 0, i);
 366                                         f_print(fout, "%s", ext);
 367                                         pprocdef(proc, vers, "struct svc_req *", 1, i);
 368                                 }
 369                         pfreeprocdef(def->def_name, vers->vers_num, i);
 370                         }
 371                         f_print(fout, "#endif /* K&R C */\n");
 372                 }
 373         }
 374 }
 375
 376 static void
 377 pprocdef(proc, vp, addargtype, server_p, mode)
 378         proc_list *proc;
 379         version_list *vp;
 380         char* addargtype;
 381         int server_p;
 382         int mode;
 383 {
 384         if (mtflag) {/* Print MT style stubs */
 385                 if (server_p)
 386                         f_print(fout, "bool_t ");
 387                 else
 388                         f_print(fout, "enum clnt_stat ");
 389         } else {
 390                 ptype(proc->res_prefix, proc->res_type, 1);
 391                 f_print(fout, "* ");
 392         }
 393         if (server_p)
 394                 pvname_svc(proc->proc_name, vp->vers_num);
 395         else
 396                 pvname(proc->proc_name, vp->vers_num);
 397
 398         /*
 399          *  mode  1 = ANSI-C, mode 2 = K&R C
 400          */
 401         if ( mode == 1)
 402                 parglist(proc, addargtype);
 403         else
 404                 f_print(fout, "();\n");
 405 }
 406
 407
 408
 409 /* print out argument list of procedure */
 410 static void
 411 parglist(proc, addargtype)
 412         proc_list *proc;
 413     char* addargtype;
 414 {
 415         decl_list *dl;
 416
 417         f_print(fout, "(");
 418         if (proc->arg_num < 2 && newstyle &&
 419             streq(proc->args.decls->decl.type, "void")) {
 420                 /* 0 argument in new style:  do nothing*/
 421         }
 422         else {
 423                 for (dl = proc->args.decls; dl != NULL; dl = dl->next) {
 424                         ptype(dl->decl.prefix, dl->decl.type, 1);
 425                         if (!newstyle)
 426                                 f_print(fout, "*");
 427                         /* old style passes by reference */
 428                         f_print(fout, ", ");
 429                 }
 430         }
 431
 432         if (mtflag)  {
 433                 ptype(proc->res_prefix, proc->res_type, 1);
 434                 f_print(fout, "*, ");
 435         }
 436
 437         f_print(fout, "%s);\n", addargtype);
 438
 439 }
 440
 441 static void
 442 penumdef(def)
 443         definition *def;
 444 {
 445         char *name = def->def_name;
 446         enumval_list *l;
 447         char *last = NULL;
 448         int count = 0;
 449
 450         f_print(fout, "enum %s {\n", name);
 451         for (l = def->def.en.vals; l != NULL; l = l->next) {
 452                 f_print(fout, "\t%s", l->name);
 453                 if (l->assignment) {
 454                         f_print(fout, " = %s", l->assignment);
 455                         last = l->assignment;
 456                         count = 1;
 457                 } else {
 458                         if (last == NULL) {
 459                                 f_print(fout, " = %d", count++);
 460                         } else {
 461                                 f_print(fout, " = %s + %d", last, count++);
 462                         }
 463                 }
 464                 if (l->next)
 465                         f_print(fout, ",\n");
 466                 else
 467                         f_print(fout, "\n");
 468         }
 469         f_print(fout, "};\n");
 470         f_print(fout, "typedef enum %s %s;\n", name, name);
 471 }
 472
 473 static void
 474 ptypedef(def)
 475         definition *def;
 476 {
 477         char *name = def->def_name;
 478         char *old = def->def.ty.old_type;
 479         char prefix[8]; /* enough to contain "struct ", including NUL */
 480         relation rel = def->def.ty.rel;
 481
 482
 483         if (!streq(name, old)) {
 484                 if (streq(old, "string")) {
 485                         old = "char";
 486                         rel = REL_POINTER;
 487                 } else if (streq(old, "opaque")) {
 488                         old = "char";
 489                 } else if (streq(old, "bool")) {
 490                         old = "bool_t";
 491                 }
 492                 if (undefined2(old, name) && def->def.ty.old_prefix) {
 493                         s_print(prefix, "%s ", def->def.ty.old_prefix);
 494                 } else {
 495                         prefix[0] = 0;
 496                 }
 497                 f_print(fout, "typedef ");
 498                 switch (rel) {
 499                 case REL_ARRAY:
 500                         f_print(fout, "struct {\n");
 501                         f_print(fout, "\tu_int %s_len;\n", name);
 502                         f_print(fout, "\t%s%s *%s_val;\n", prefix, old, name);
 503                         f_print(fout, "} %s", name);
 504                         break;
 505                 case REL_POINTER:
 506                         f_print(fout, "%s%s *%s", prefix, old, name);
 507                         break;
 508                 case REL_VECTOR:
 509                         f_print(fout, "%s%s %s[%s]", prefix, old, name,
 510                                 def->def.ty.array_max);
 511                         break;
 512                 case REL_ALIAS:
 513                         f_print(fout, "%s%s %s", prefix, old, name);
 514                         break;
 515                 }
 516                 f_print(fout, ";\n");
 517         }
 518 }
 519
 520 void
 521 pdeclaration(name, dec, tab, separator)
 522         char *name;
 523         declaration *dec;
 524         int tab;
 525         char *separator;
 526 {
 527         char buf[8];    /* enough to hold "struct ", include NUL */
 528         char *prefix;
 529         char *type;
 530
 531         if (streq(dec->type, "void")) {
 532                 return;
 533         }
 534         tabify(fout, tab);
 535         if (streq(dec->type, name) && !dec->prefix) {
 536                 f_print(fout, "struct ");
 537         }
 538         if (streq(dec->type, "string")) {
 539                 f_print(fout, "char *%s", dec->name);
 540         } else {
 541                 prefix = "";
 542                 if (streq(dec->type, "bool")) {
 543                         type = "bool_t";
 544                 } else if (streq(dec->type, "opaque")) {
 545                         type = "char";
 546                 } else {
 547                         if (dec->prefix) {
 548                                 s_print(buf, "%s ", dec->prefix);
 549                                 prefix = buf;
 550                         }
 551                         type = dec->type;
 552                 }
 553                 switch (dec->rel) {
 554                 case REL_ALIAS:
 555                         f_print(fout, "%s%s %s", prefix, type, dec->name);
 556                         break;
 557                 case REL_VECTOR:
 558                         f_print(fout, "%s%s %s[%s]", prefix, type, dec->name,
 559                                 dec->array_max);
 560                         break;
 561                 case REL_POINTER:
 562                         f_print(fout, "%s%s *%s", prefix, type, dec->name);
 563                         break;
 564                 case REL_ARRAY:
 565                         f_print(fout, "struct {\n");
 566                         tabify(fout, tab);
 567                         f_print(fout, "\tu_int %s_len;\n", dec->name);
 568                         tabify(fout, tab);
 569                         f_print(fout,
 570                                 "\t%s%s *%s_val;\n", prefix, type, dec->name);
 571                         tabify(fout, tab);
 572                         f_print(fout, "} %s", dec->name);
 573                         break;
 574                 }
 575         }
 576         f_print(fout, separator);
 577 }
 578
 579 static int
 580 undefined2(type, stop)
 581         char *type;
 582         char *stop;
 583 {
 584         list *l;
 585         definition *def;
 586
 587         for (l = defined; l != NULL; l = l->next) {
 588                 def = (definition *) l->val;
 589                 if (def->def_kind != DEF_PROGRAM) {
 590                         if (streq(def->def_name, stop)) {
 591                                 return (1);
 592                         } else if (streq(def->def_name, type)) {
 593                                 return (0);
 594                         }
 595                 }
 596         }
 597         return (1);
 598 }