Eliminate warnings from code generated by rpcgen
[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 #if 0
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         print_generic_header(def->def_name,
159                 def->def_kind != DEF_TYPEDEF ||
160                 !isvectordef(def->def.ty.old_type, def->def.ty.rel));
161
162         /* Now add Inline support */
163
164
165         if (Inline == 0)
166                 return;
167 }
168
169 static void
170 print_prog_header(proc_list *plist)
171 {
172         print_generic_header(plist->args.argname, 1);
173 }
174
175 static void
176 print_trailer(void)
177 {
178         f_print(fout, "\treturn (TRUE);\n");
179         f_print(fout, "}\n");
180 }
181
182
183 static void
184 print_ifopen(int indent, char *name)
185 {
186         tabify(fout, indent);
187         f_print(fout, " if (!xdr_%s(xdrs", name);
188 }
189
190 static void
191 print_ifarg(char *arg)
192 {
193         f_print(fout, ", %s", arg);
194 }
195
196 static void
197 print_ifsizeof(char *prefix, char *type)
198 {
199         if (streq(type, "bool")) {
200                 f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool");
201         } else {
202                 f_print(fout, ", sizeof(");
203                 if (undefined(type) && prefix) {
204                         f_print(fout, "%s ", prefix);
205                 }
206                 f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
207         }
208 }
209
210 static void
211 print_ifclose(int indent)
212 {
213         f_print(fout, ")) {\n");
214         tabify(fout, indent);
215         f_print(fout, "\t return (FALSE);\n");
216         tabify(fout, indent);
217         f_print(fout, " }\n");
218 }
219
220 static void
221 print_ifstat(int indent, char *prefix, char *type, relation rel,
222                         char *amax, char *objname, char *name)
223 {
224         char *alt = NULL;
225
226         switch (rel) {
227         case REL_POINTER:
228                 print_ifopen(indent, "pointer");
229                 print_ifarg("(char **)");
230                 f_print(fout, "%s", objname);
231                 print_ifsizeof(prefix, type);
232                 break;
233         case REL_VECTOR:
234                 if (streq(type, "string")) {
235                         alt = "string";
236                 } else if (streq(type, "opaque")) {
237                         alt = "opaque";
238                 }
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(prefix, type);
250                 }
251                 break;
252         case REL_ARRAY:
253                 if (streq(type, "string")) {
254                         alt = "string";
255                 } else if (streq(type, "opaque")) {
256                         alt = "bytes";
257                 }
258                 if (streq(type, "string")) {
259                         print_ifopen(indent, alt);
260                         print_ifarg(objname);
261                 } else {
262                         if (alt) {
263                                 print_ifopen(indent, alt);
264                         } else {
265                                 print_ifopen(indent, "array");
266                         }
267                         /* The (void*) avoids a gcc-4.1 warning */
268                         print_ifarg("(char **)(void*)");
269                         if (*objname == '&') {
270                                 f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
271                                         objname, name, objname, name);
272                         } else {
273                                 f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
274                                         objname, name, objname, name);
275                         }
276                 }
277                 print_ifarg(amax);
278                 if (!alt) {
279                         print_ifsizeof(prefix, type);
280                 }
281                 break;
282         case REL_ALIAS:
283                 print_ifopen(indent, type);
284                 print_ifarg(objname);
285                 break;
286         }
287         print_ifclose(indent);
288 }
289
290 static void
291 emit_enum(definition *def)
292 {
293         print_ifopen(1, "enum");
294         print_ifarg("(enum_t *)objp");
295         print_ifclose(1);
296 }
297
298 static void
299 emit_program(definition *def)
300 {
301         decl_list      *dl;
302         version_list   *vlist;
303         proc_list      *plist;
304
305         for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
306                 for (plist = vlist->procs; plist != NULL; plist = plist->next) {
307                         if (!newstyle || plist->arg_num < 2)
308                                 continue;/* old style, or single argument */
309                         print_prog_header(plist);
310                         for (dl = plist->args.decls; dl != NULL; dl = dl->next)
311                                 print_stat(1, &dl->decl);
312                         print_trailer();
313                 }
314 }
315
316
317 static void
318 emit_union(definition *def)
319 {
320   declaration *dflt;
321   case_list *cl;
322   declaration *cs;
323   char *object;
324   char *vecformat = "objp->%s_u.%s";
325   char *format = "&objp->%s_u.%s";
326
327   print_stat(1,&def->def.un.enum_decl);
328   f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
329   for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
330
331     f_print(fout, "\tcase %s:\n", cl->case_name);
332     if(cl->contflag == 1)       /* a continued case statement */
333       continue;
334     cs = &cl->case_decl;
335     if (!streq(cs->type, "void")) {
336       object = alloc(strlen(def->def_name) + strlen(format) +
337                      strlen(cs->name) + 1);
338       if (isvectordef (cs->type, cs->rel)) {
339         s_print(object, vecformat, def->def_name, 
340                 cs->name);
341       } else {
342         s_print(object, format, def->def_name, 
343                 cs->name);
344       }
345       print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
346                    object, cs->name);
347       free(object);
348     }
349     f_print(fout, "\t\tbreak;\n");
350   }
351   dflt = def->def.un.default_decl;
352   if (dflt != NULL) {
353     if (!streq(dflt->type, "void")) {
354       f_print(fout, "\tdefault:\n");
355       object = alloc(strlen(def->def_name) + strlen(format) +
356                      strlen(dflt->name) + 1);
357       if (isvectordef (dflt->type, dflt->rel)) {
358         s_print(object, vecformat, def->def_name, 
359                 dflt->name);
360       } else {
361         s_print(object, format, def->def_name, 
362                 dflt->name);
363       }
364
365       print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
366                    dflt->array_max, object, dflt->name);
367       free(object);
368       f_print(fout, "\t\tbreak;\n");
369     } else {
370       /* Avoid gcc warnings about `value not handled in switch' */
371       f_print(fout, "\tdefault:\n");
372       f_print(fout, "\t\tbreak;\n");
373     }
374   } else {
375     f_print(fout, "\tdefault:\n");
376     f_print(fout, "\t\treturn (FALSE);\n");
377   }
378
379   f_print(fout, "\t}\n");
380 }
381
382 static void
383 emit_struct(definition *def)
384 {
385         decl_list      *dl;
386         int             i, j, size, flag;
387         decl_list      *cur = NULL, *psav;
388         bas_type       *ptr;
389         char           *sizestr, *plus;
390         char            ptemp[256];
391         int             can_inline;
392         const char      *buf_declaration;
393
394
395         if (Inline == 0) {
396                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
397                         print_stat(1, &dl->decl);
398         } else {
399                 size = 0;
400                 can_inline = 0;
401                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
402                         if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
403
404                                 if (dl->decl.rel == REL_ALIAS)
405                                         size += ptr->length;
406                                 else {
407                                         can_inline = 1;
408                                         break;  /* can be inlined */
409                                 };
410                         } else {
411                                 if (size >= Inline) {
412                                         can_inline = 1;
413                                         break;  /* can be inlined */
414                                 }
415                                 size = 0;
416                         }
417                 if (size > Inline)
418                         can_inline = 1;
419
420                 if (can_inline == 0) {  /* can not inline, drop back to old mode */
421                         for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
422                                 print_stat(1, &dl->decl);
423                         return;
424                 };
425
426
427
428
429                 flag = PUT;
430                 for (j = 0; j < 2; j++) {
431
432                         if (flag == PUT)
433                                 f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n");
434                         else
435                                 f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
436
437
438                         i = 0;
439                         size = 0;
440                         sizestr = NULL;
441                         buf_declaration = "int32_t *";
442                         for (dl = def->def.st.decls; dl != NULL; dl = dl->next) {       /* xxx */
443
444                                 /* now walk down the list and check for basic types */
445                                 if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
446                                         if (i == 0)
447                                                 cur = dl;
448                                         i++;
449
450                                         if (dl->decl.rel == REL_ALIAS)
451                                                 size += ptr->length;
452                                         else {
453                                                 /* this is required to handle arrays */
454
455                                                 if (sizestr == NULL)
456                                                         plus = " ";
457                                                 else
458                                                         plus = "+";
459
460                                                 if (ptr->length != 1)
461                                                         s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length);
462                                                 else
463                                                         s_print(ptemp, " %s %s ", plus, dl->decl.array_max);
464
465                                                 /*now concatenate to sizestr !!!! */
466                                                 if (sizestr == NULL)
467                                                         sizestr = strdup(ptemp);
468                                                 else {
469                                                         sizestr = realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1);
470                                                         if (sizestr == NULL) {
471
472                                                                 f_print(stderr, "Fatal error : no memory \n");
473                                                                 crash();
474                                                         };
475                                                         sizestr = strcat(sizestr, ptemp);       /*build up length of array */
476
477                                                 }
478                                         }
479
480                                 } else {
481                                         if (i > 0)
482                                             {
483                                                 if (sizestr == NULL && size < Inline) {
484                                                         /* don't expand into inline code if size < inline */
485                                                         while (cur != dl) {
486                                                                 print_stat(1, &cur->decl);
487                                                                 cur = cur->next;
488                                                         }
489                                                 } else {
490
491
492
493                                                         /* were already looking at a xdr_inlineable structure */
494                                                         if (sizestr == NULL)
495                                                                 f_print(fout, "\t %sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
496                                                                         buf_declaration, size);
497                                                         else if (size == 0)
498                                                                 f_print(fout,
499                                                                         "\t %sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
500                                                                         buf_declaration, sizestr);
501                                                         else
502                                                                 f_print(fout,
503                                                                         "\t %sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
504                                                                         buf_declaration, size, sizestr);
505                                                         buf_declaration = "";
506
507                                                         f_print(fout, "\n\t   if (buf == NULL) {\n");
508
509                                                         psav = cur;
510                                                         while (cur != dl) {
511                                                                 print_stat(2, &cur->decl);
512                                                                 cur = cur->next;
513                                                         }
514
515                                                         f_print(fout, "\n\t  }\n\t  else {\n");
516
517                                                         cur = psav;
518                                                         while (cur != dl) {
519                                                                 emit_inline(&cur->decl, flag);
520                                                                 cur = cur->next;
521                                                         }
522
523                                                         f_print(fout, "\t  }\n");
524                                                 }
525                                             }
526                                         size = 0;
527                                         i = 0;
528                                         sizestr = NULL;
529                                         print_stat(1, &dl->decl);
530                                 }
531
532                         }
533                         if (i > 0)
534                             {
535                                 if (sizestr == NULL && size < Inline) {
536                                         /* don't expand into inline code if size < inline */
537                                         while (cur != dl) {
538                                                 print_stat(1, &cur->decl);
539                                                 cur = cur->next;
540                                         }
541                                 } else {
542
543                                         /* were already looking at a xdr_inlineable structure */
544                                         if (sizestr == NULL)
545                                                 f_print(fout, "\t\t%sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
546                                                         buf_declaration, size);
547                                         else if (size == 0)
548                                                 f_print(fout,
549                                                         "\t\t%sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
550                                                         buf_declaration, sizestr);
551                                         else
552                                                 f_print(fout,
553                                                         "\t\t%sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
554                                                         buf_declaration, size, sizestr);
555                                         buf_declaration = "";
556
557                                         f_print(fout, "\n\t\tif (buf == NULL) {\n");
558
559                                         psav = cur;
560                                         while (cur != NULL) {
561                                                 print_stat(2, &cur->decl);
562                                                 cur = cur->next;
563                                         }
564                                         f_print(fout, "\n\t  }\n\t  else {\n");
565
566                                         cur = psav;
567                                         while (cur != dl) {
568                                                 emit_inline(&cur->decl, flag);
569                                                 cur = cur->next;
570                                         }
571
572                                         f_print(fout, "\t  }\n");
573
574                                 }
575                             }
576                         flag = GET;
577                 }
578                 f_print(fout, "\t return(TRUE);\n\t}\n\n");
579
580                 /* now take care of XDR_FREE case */
581
582                 for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
583                         print_stat(1, &dl->decl);
584         }
585 }
586  
587
588
589
590 static void
591 emit_typedef(definition *def)
592 {
593         char *prefix = def->def.ty.old_prefix;
594         char *type = def->def.ty.old_type;
595         char *amax = def->def.ty.array_max;
596         relation rel = def->def.ty.rel;
597
598
599           print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
600 }
601
602 static void
603 print_stat(int indent, declaration *dec)
604 {
605         char *prefix = dec->prefix;
606         char *type = dec->type;
607         char *amax = dec->array_max;
608         relation rel = dec->rel;
609         char name[256];
610
611         if (isvectordef(type, rel)) {
612                 s_print(name, "objp->%s", dec->name);
613         } else {
614                 s_print(name, "&objp->%s", dec->name);
615         }
616         print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
617 }
618
619
620 static void
621 emit_inline(declaration *decl, int flag)
622 {
623
624         /*check whether an array or not */
625
626         switch (decl->rel) {
627         case REL_ALIAS:
628                 emit_single_in_line(decl, flag, REL_ALIAS);
629                 break;
630         case REL_VECTOR:
631                 f_print(fout, "\t\t{ register %s *genp; \n", decl->type);
632                 f_print(fout, "\t\t  int i;\n");
633                 f_print(fout, "\t\t  for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t",
634                         decl->name, decl->array_max);
635                 emit_single_in_line(decl, flag, REL_VECTOR);
636                 f_print(fout, "\t\t   }\n\t\t };\n");
637                 break;
638         default:
639                 break;
640         }
641 }
642
643 static void
644 emit_single_in_line(declaration *decl, int flag, relation rel)
645 {
646         char *upp_case;
647         int freed=0;
648
649         if(flag == PUT)
650                 f_print(fout,"\t\t (void) IXDR_PUT_");
651         else    
652                 if(rel== REL_ALIAS)
653                         f_print(fout,"\t\t objp->%s = IXDR_GET_",decl->name);
654                 else
655                         f_print(fout,"\t\t *genp++ = IXDR_GET_");
656
657         upp_case=upcase(decl->type);
658
659         /* hack  - XX */
660         if(strcmp(upp_case,"INT") == 0)
661         {
662                 free(upp_case);
663                 freed=1;
664                 upp_case="INT32";
665         }
666
667         if(strcmp(upp_case,"U_INT") == 0)
668         {
669                 free(upp_case);
670                 freed=1;
671                 upp_case="U_INT32";
672         }
673
674
675         if(flag == PUT) 
676                 if(rel== REL_ALIAS)
677                         f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name);
678                 else
679                         f_print(fout,"%s(buf,*genp++);\n",upp_case);
680
681         else
682                 f_print(fout,"%s(buf);\n",upp_case);
683         if(!freed)
684                 free(upp_case);
685
686 }
687
688
689 static char *
690 upcase(char *str)
691 {
692         char           *ptr, *hptr;
693
694
695         ptr = (char *) malloc(strlen(str));
696         if (ptr == (char *) NULL) {
697                 f_print(stderr, "malloc failed \n");
698                 exit(1);
699         };
700
701         hptr = ptr;
702         while (*str != '\0')
703                 *ptr++ = toupper(*str++);
704
705         *ptr = '\0';
706         return (hptr);
707
708 }