5f4c3e787026f5414f25e78bcd2a3644b2f2a132
[nfs-utils.git] / tools / rpcgen / rpc_cout.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 or with the express written consent of
8  * Sun Microsystems, Inc.
9  *
10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
13  *
14  * Sun RPC is provided with no support and without any obligation on the
15  * part of Sun Microsystems, Inc. to assist in its use, correction,
16  * modification or enhancement.
17  *
18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20  * OR ANY PART THEREOF.
21  *
22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23  * or profits or other special, indirect and consequential damages, even if
24  * Sun has been advised of the possibility of such damages.
25  *
26  * Sun Microsystems, Inc.
27  * 2550 Garcia Avenue
28  * Mountain View, California  94043
29  */
30
31 #ifndef lint
32 static char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI";
33 #endif
34
35 /*
36  * rpc_cout.c, XDR routine outputter for the RPC protocol compiler 
37  */
38 #include <stdio.h>
39 #include <string.h>
40 #include <stdlib.h>
41 #include <malloc.h>
42 #include <ctype.h>
43 #include "rpc_parse.h"
44 #include "rpc_util.h"
45
46 static int      findtype(definition *def, char *type);
47 static int      undefined(char *type);
48 static void     print_generic_header(char *procname, int pointerp);
49 static void     print_header(definition *def);
50 static void     print_prog_header(proc_list *plist);
51 static void     print_trailer(void);
52 static void     print_ifopen(int indent, char *name);
53 static void     print_ifarg(char *arg);
54 static void     print_ifsizeof(char *prefix, char *type);
55 static void     print_ifclose(int indent);
56 static void     print_ifstat(int indent, char *prefix, char *type, relation rel,
57                         char *amax, char *objname, char *name);
58 static void     emit_enum(definition *def);
59 static void     emit_program(definition *def);
60 static void     emit_union(definition *def);
61 static void     emit_struct(definition *def);
62 static void     emit_typedef(definition *def);
63 static void     print_stat(int indent, declaration *dec);
64 static void     emit_inline(declaration *decl, int flag);
65 static void     emit_single_in_line(declaration *decl, int flag, relation rel);
66 static char *   upcase(char *str);
67
68 /*
69  * Emit the C-routine for the given definition 
70  */
71 void
72 emit(definition *def)
73 {
74         if (def->def_kind == DEF_CONST) {
75                 return;
76         }
77         if (def->def_kind == DEF_PROGRAM) {
78                 emit_program(def);
79                 return;
80         }
81         if (def->def_kind == DEF_TYPEDEF) {
82                 /* now we need to handle declarations like
83                  * struct typedef foo foo;
84                  * since we dont want this to be expanded into 2 calls
85                  * to xdr_foo */
86
87                 if (strcmp(def->def.ty.old_type, def->def_name) == 0)
88                         return;
89         };
90
91         print_header(def);
92         switch (def->def_kind) {
93         case DEF_UNION:
94                 emit_union(def);
95                 break;
96         case DEF_ENUM:
97                 emit_enum(def);
98                 break;
99         case DEF_STRUCT:
100                 emit_struct(def);
101                 break;
102         case DEF_TYPEDEF:
103                 emit_typedef(def);
104                 break;
105         default:
106                 break;
107         }
108         print_trailer();
109 }
110
111 static int
112 findtype(definition *def, char *type)
113 {
114
115         if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
116                 return (0);
117         } else {
118                 return (streq(def->def_name, type));
119         }
120 }
121
122 static int
123 undefined(char *type)
124 {
125         definition     *def;
126
127         def = (definition *) FINDVAL(defined, type, findtype);
128
129         return (def == NULL);
130 }
131
132
133 static void
134 print_generic_header(char *procname, int pointerp)
135 {
136         f_print(fout, "\n");
137         f_print(fout, "bool_t\n");
138         if (Cflag) {
139                 f_print(fout, "xdr_%s(", procname);
140                 f_print(fout, "XDR *xdrs, ");
141                 f_print(fout, "%s ", procname);
142                 if (pointerp)
143                         f_print(fout, "*");
144                 f_print(fout, "objp)\n{\n\n");
145         } else {
146                 f_print(fout, "xdr_%s(xdrs, objp)\n", procname);
147                 f_print(fout, "\tXDR *xdrs;\n");
148                 f_print(fout, "\t%s ", procname);
149                 if (pointerp)
150                         f_print(fout, "*");
151                 f_print(fout, "objp;\n{\n\n");
152         }
153 }
154
155 static void
156 print_header(definition *def)
157 {
158         decl_list      *dl;
159         bas_type       *ptr;
160         int             i;
161
162
163         print_generic_header(def->def_name,
164                 def->def_kind != DEF_TYPEDEF ||
165                 !isvectordef(def->def.ty.old_type, def->def.ty.rel));
166
167         /* Now add Inline support */
168
169
170         if (Inline == 0)
171                 return;
172         /* May cause lint to complain. but  ... */
173         f_print(fout, "\t register int32_t *buf;\n\n");
174 }
175
176 static void
177 print_prog_header(proc_list *plist)
178 {
179         print_generic_header(plist->args.argname, 1);
180 }
181
182 static void
183 print_trailer(void)
184 {
185         f_print(fout, "\treturn (TRUE);\n");
186         f_print(fout, "}\n");
187 }
188
189
190 static void
191 print_ifopen(int indent, char *name)
192 {
193         tabify(fout, indent);
194         f_print(fout, " if (!xdr_%s(xdrs", name);
195 }
196
197 static void
198 print_ifarg(char *arg)
199 {
200         f_print(fout, ", %s", arg);
201 }
202
203 static void
204 print_ifsizeof(char *prefix, char *type)
205 {
206         if (streq(type, "bool")) {
207                 f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool");
208         } else {
209                 f_print(fout, ", sizeof(");
210                 if (undefined(type) && prefix) {
211                         f_print(fout, "%s ", prefix);
212                 }
213                 f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
214         }
215 }
216
217 static void
218 print_ifclose(int indent)
219 {
220         f_print(fout, ")) {\n");
221         tabify(fout, indent);
222         f_print(fout, "\t return (FALSE);\n");
223         tabify(fout, indent);
224         f_print(fout, " }\n");
225 }
226
227 static void
228 print_ifstat(int indent, char *prefix, char *type, relation rel,
229                         char *amax, char *objname, char *name)
230 {
231         char *alt = NULL;
232
233         switch (rel) {
234         case REL_POINTER:
235                 print_ifopen(indent, "pointer");
236                 print_ifarg("(char **)");
237                 f_print(fout, "%s", objname);
238                 print_ifsizeof(prefix, type);
239                 break;
240         case REL_VECTOR:
241                 if (streq(type, "string")) {
242                         alt = "string";
243                 } else if (streq(type, "opaque")) {
244                         alt = "opaque";
245                 }
246                 if (alt) {
247                         print_ifopen(indent, alt);
248                         print_ifarg(objname);
249                 } else {
250                         print_ifopen(indent, "vector");
251                         print_ifarg("(char *)");
252                         f_print(fout, "%s", objname);
253                 }
254                 print_ifarg(amax);
255                 if (!alt) {
256                         print_ifsizeof(prefix, type);
257                 }
258                 break;
259         case REL_ARRAY:
260                 if (streq(type, "string")) {
261                         alt = "string";
262                 } else if (streq(type, "opaque")) {
263                         alt = "bytes";
264                 }
265                 if (streq(type, "string")) {
266                         print_ifopen(indent, alt);
267                         print_ifarg(objname);
268                 } else {
269                         if (alt) {
270                                 print_ifopen(indent, alt);
271                         } else {
272                                 print_ifopen(indent, "array");
273                         }
274                         print_ifarg("(char **)");
275                         if (*objname == '&') {
276                                 f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
277                                         objname, name, objname, name);
278                         } else {
279                                 f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
280                                         objname, name, objname, name);
281                         }
282                 }
283                 print_ifarg(amax);
284                 if (!alt) {
285                         print_ifsizeof(prefix, type);
286                 }
287                 break;
288         case REL_ALIAS:
289                 print_ifopen(indent, type);
290                 print_ifarg(objname);
291                 break;
292         }
293         print_ifclose(indent);
294 }
295
296 static void
297 emit_enum(definition *def)
298 {
299         print_ifopen(1, "enum");
300         print_ifarg("(enum_t *)objp");
301         print_ifclose(1);
302 }
303
304 static void
305 emit_program(definition *def)
306 {
307         decl_list      *dl;
308         version_list   *vlist;
309         proc_list      *plist;
310
311         for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
312                 for (plist = vlist->procs; plist != NULL; plist = plist->next) {
313                         if (!newstyle || plist->arg_num < 2)
314                                 continue;/* old style, or single argument */
315                         print_prog_header(plist);
316                         for (dl = plist->args.decls; dl != NULL; dl = dl->next)
317                                 print_stat(1, &dl->decl);
318                         print_trailer();
319                 }
320 }
321
322
323 static void
324 emit_union(definition *def)
325 {
326   declaration *dflt;
327   case_list *cl;
328   declaration *cs;
329   char *object;
330   char *vecformat = "objp->%s_u.%s";
331   char *format = "&objp->%s_u.%s";
332
333   print_stat(1,&def->def.un.enum_decl);
334   f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
335   for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
336
337     f_print(fout, "\tcase %s:\n", cl->case_name);
338     if(cl->contflag == 1)       /* a continued case statement */
339       continue;
340     cs = &cl->case_decl;
341     if (!streq(cs->type, "void")) {
342       object = alloc(strlen(def->def_name) + strlen(format) +
343                      strlen(cs->name) + 1);
344       if (isvectordef (cs->type, cs->rel)) {
345         s_print(object, vecformat, def->def_name, 
346                 cs->name);
347       } else {
348         s_print(object, format, def->def_name, 
349                 cs->name);
350       }
351       print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
352                    object, cs->name);
353       free(object);
354     }
355     f_print(fout, "\t\tbreak;\n");
356   }
357   dflt = def->def.un.default_decl;
358   if (dflt != NULL) {
359     if (!streq(dflt->type, "void")) {
360       f_print(fout, "\tdefault:\n");
361       object = alloc(strlen(def->def_name) + strlen(format) +
362                      strlen(dflt->name) + 1);
363       if (isvectordef (dflt->type, dflt->rel)) {
364         s_print(object, vecformat, def->def_name, 
365                 dflt->name);
366       } else {
367         s_print(object, format, def->def_name, 
368                 dflt->name);
369       }
370
371       print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
372                    dflt->array_max, object, dflt->name);
373       free(object);
374       f_print(fout, "\t\tbreak;\n");
375     } else {
376       /* Avoid gcc warnings about `value not handled in switch' */
377       f_print(fout, "\tdefault:\n");
378       f_print(fout, "\t\tbreak;\n");
379     }
380   } else {
381     f_print(fout, "\tdefault:\n");
382     f_print(fout, "\t\treturn (FALSE);\n");
383   }
384
385   f_print(fout, "\t}\n");
386 }
387
388 static void
389 emit_struct(definition *def)
390 {
391         decl_list      *dl;
392         int             i, j, size, flag;
393         decl_list      *cur = NULL, *psav;
394         bas_type       *ptr;
395         char           *sizestr, *plus;
396         char            ptemp[256];
397         int             can_inline;
398
399
400         if (Inline == 0) {
401                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
402                         print_stat(1, &dl->decl);
403         } else {
404
405                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
406                         if (dl->decl.rel == REL_VECTOR) {
407                                 f_print(fout, "\t int i;\n");
408                                 break;
409                         }
410                 size = 0;
411                 can_inline = 0;
412                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
413                         if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
414
415                                 if (dl->decl.rel == REL_ALIAS)
416                                         size += ptr->length;
417                                 else {
418                                         can_inline = 1;
419                                         break;  /* can be inlined */
420                                 };
421                         } else {
422                                 if (size >= Inline) {
423                                         can_inline = 1;
424                                         break;  /* can be inlined */
425                                 }
426                                 size = 0;
427                         }
428                 if (size > Inline)
429                         can_inline = 1;
430
431                 if (can_inline == 0) {  /* can not inline, drop back to old mode */
432                         for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
433                                 print_stat(1, &dl->decl);
434                         return;
435                 };
436
437
438
439
440                 flag = PUT;
441                 for (j = 0; j < 2; j++) {
442
443                         if (flag == PUT)
444                                 f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n");
445                         else
446                                 f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
447
448
449                         i = 0;
450                         size = 0;
451                         sizestr = NULL;
452                         for (dl = def->def.st.decls; dl != NULL; dl = dl->next) {       /* xxx */
453
454                                 /* now walk down the list and check for basic types */
455                                 if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
456                                         if (i == 0)
457                                                 cur = dl;
458                                         i++;
459
460                                         if (dl->decl.rel == REL_ALIAS)
461                                                 size += ptr->length;
462                                         else {
463                                                 /* this is required to handle arrays */
464
465                                                 if (sizestr == NULL)
466                                                         plus = " ";
467                                                 else
468                                                         plus = "+";
469
470                                                 if (ptr->length != 1)
471                                                         s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length);
472                                                 else
473                                                         s_print(ptemp, " %s %s ", plus, dl->decl.array_max);
474
475                                                 /*now concatenate to sizestr !!!! */
476                                                 if (sizestr == NULL)
477                                                         sizestr = strdup(ptemp);
478                                                 else {
479                                                         sizestr = realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1);
480                                                         if (sizestr == NULL) {
481
482                                                                 f_print(stderr, "Fatal error : no memory \n");
483                                                                 crash();
484                                                         };
485                                                         sizestr = strcat(sizestr, ptemp);       /*build up length of array */
486
487                                                 }
488                                         }
489
490                                 } else {
491                                         if (i > 0)
492                                             {
493                                                 if (sizestr == NULL && size < Inline) {
494                                                         /* don't expand into inline code if size < inline */
495                                                         while (cur != dl) {
496                                                                 print_stat(1, &cur->decl);
497                                                                 cur = cur->next;
498                                                         }
499                                                 } else {
500
501
502
503                                                         /* were already looking at a xdr_inlineable structure */
504                                                         if (sizestr == NULL)
505                                                                 f_print(fout, "\t buf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
506                                                                         size);
507                                                         else if (size == 0)
508                                                                 f_print(fout,
509                                                                         "\t buf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
510                                                                         sizestr);
511                                                         else
512                                                                 f_print(fout,
513                                                                         "\t buf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
514                                                                         size, sizestr);
515
516                                                         f_print(fout, "\n\t   if (buf == NULL) {\n");
517
518                                                         psav = cur;
519                                                         while (cur != dl) {
520                                                                 print_stat(2, &cur->decl);
521                                                                 cur = cur->next;
522                                                         }
523
524                                                         f_print(fout, "\n\t  }\n\t  else {\n");
525
526                                                         cur = psav;
527                                                         while (cur != dl) {
528                                                                 emit_inline(&cur->decl, flag);
529                                                                 cur = cur->next;
530                                                         }
531
532                                                         f_print(fout, "\t  }\n");
533                                                 }
534                                             }
535                                         size = 0;
536                                         i = 0;
537                                         sizestr = NULL;
538                                         print_stat(1, &dl->decl);
539                                 }
540
541                         }
542                         if (i > 0)
543                             {
544                                 if (sizestr == NULL && size < Inline) {
545                                         /* don't expand into inline code if size < inline */
546                                         while (cur != dl) {
547                                                 print_stat(1, &cur->decl);
548                                                 cur = cur->next;
549                                         }
550                                 } else {
551
552                                         /* were already looking at a xdr_inlineable structure */
553                                         if (sizestr == NULL)
554                                                 f_print(fout, "\t\tbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
555                                                         size);
556                                         else if (size == 0)
557                                                 f_print(fout,
558                                                         "\t\tbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
559                                                         sizestr);
560                                         else
561                                                 f_print(fout,
562                                                         "\t\tbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
563                                                         size, sizestr);
564
565                                         f_print(fout, "\n\t\tif (buf == NULL) {\n");
566
567                                         psav = cur;
568                                         while (cur != NULL) {
569                                                 print_stat(2, &cur->decl);
570                                                 cur = cur->next;
571                                         }
572                                         f_print(fout, "\n\t  }\n\t  else {\n");
573
574                                         cur = psav;
575                                         while (cur != dl) {
576                                                 emit_inline(&cur->decl, flag);
577                                                 cur = cur->next;
578                                         }
579
580                                         f_print(fout, "\t  }\n");
581
582                                 }
583                             }
584                         flag = GET;
585                 }
586                 f_print(fout, "\t return(TRUE);\n\t}\n\n");
587
588                 /* now take care of XDR_FREE case */
589
590                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
591                         print_stat(1, &dl->decl);
592         }
593 }
594  
595
596
597
598 static void
599 emit_typedef(definition *def)
600 {
601         char *prefix = def->def.ty.old_prefix;
602         char *type = def->def.ty.old_type;
603         char *amax = def->def.ty.array_max;
604         relation rel = def->def.ty.rel;
605
606
607           print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
608 }
609
610 static void
611 print_stat(int indent, declaration *dec)
612 {
613         char *prefix = dec->prefix;
614         char *type = dec->type;
615         char *amax = dec->array_max;
616         relation rel = dec->rel;
617         char name[256];
618
619         if (isvectordef(type, rel)) {
620                 s_print(name, "objp->%s", dec->name);
621         } else {
622                 s_print(name, "&objp->%s", dec->name);
623         }
624         print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
625 }
626
627
628 static void
629 emit_inline(declaration *decl, int flag)
630 {
631
632         /*check whether an array or not */
633
634         switch (decl->rel) {
635         case REL_ALIAS:
636                 emit_single_in_line(decl, flag, REL_ALIAS);
637                 break;
638         case REL_VECTOR:
639                 f_print(fout, "\t\t{ register %s *genp; \n", decl->type);
640                 f_print(fout, "\t\t  for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t",
641                         decl->name, decl->array_max);
642                 emit_single_in_line(decl, flag, REL_VECTOR);
643                 f_print(fout, "\t\t   }\n\t\t };\n");
644                 break;
645         default:
646                 break;
647         }
648 }
649
650 static void
651 emit_single_in_line(declaration *decl, int flag, relation rel)
652 {
653         char *upp_case;
654         int freed=0;
655
656         if(flag == PUT)
657                 f_print(fout,"\t\t IXDR_PUT_");
658         else    
659                 if(rel== REL_ALIAS)
660                         f_print(fout,"\t\t objp->%s = IXDR_GET_",decl->name);
661                 else
662                         f_print(fout,"\t\t *genp++ = IXDR_GET_");
663
664         upp_case=upcase(decl->type);
665
666         /* hack  - XX */
667         if(strcmp(upp_case,"INT") == 0)
668         {
669                 free(upp_case);
670                 freed=1;
671                 upp_case="INT32";
672         }
673
674         if(strcmp(upp_case,"U_INT") == 0)
675         {
676                 free(upp_case);
677                 freed=1;
678                 upp_case="U_INT32";
679         }
680
681
682         if(flag == PUT) 
683                 if(rel== REL_ALIAS)
684                         f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name);
685                 else
686                         f_print(fout,"%s(buf,*genp++);\n",upp_case);
687
688         else
689                 f_print(fout,"%s(buf);\n",upp_case);
690         if(!freed)
691                 free(upp_case);
692
693 }
694
695
696 static char *
697 upcase(char *str)
698 {
699         char           *ptr, *hptr;
700
701
702         ptr = (char *) malloc(strlen(str));
703         if (ptr == (char *) NULL) {
704                 f_print(stderr, "malloc failed \n");
705                 exit(1);
706         };
707
708         hptr = ptr;
709         while (*str != '\0')
710                 *ptr++ = toupper(*str++);
711
712         *ptr = '\0';
713         return (hptr);
714
715 }