Initial revision
[nfs-utils.git] / tools / rpcgen / rpc_util.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_util.c 1.11 89/02/22 (C) 1987 SMI";
33 #endif
34
35 /*
36  * rpc_util.c, Utility routines for the RPC protocol compiler 
37  */
38 #include <stdio.h>
39 #include <memory.h>
40 #include <ctype.h>
41 #include <unistd.h>
42 #include "rpc_scan.h"
43 #include "rpc_parse.h"
44 #include "rpc_util.h"
45
46 static void     printwhere(void);
47
48
49 #define ARGEXT "argument"
50
51 char curline[MAXLINESIZE];      /* current read line */
52 char *where = curline;          /* current point in line */
53 int linenum = 0;                /* current line number */
54
55 char *infilename;               /* input filename */
56
57 #define NFILES 7
58 char *outfiles[NFILES];         /* output file names */
59 int nfiles;
60
61 FILE *fout;                     /* file pointer of current output */
62 FILE *fin;                      /* file pointer of current input */
63
64 list *defined;                  /* list of defined things */
65
66 /*
67  * Reinitialize the world 
68  */
69 void
70 reinitialize(void)
71 {
72         memset(curline, 0, MAXLINESIZE);
73         where = curline;
74         linenum = 0;
75         defined = NULL;
76 }
77
78 /*
79  * string equality 
80  */
81 int
82 streq(char *a, char *b)
83 {
84         return (strcmp(a, b) == 0);
85 }
86
87 /*
88  * find a value in a list 
89  */
90 definition *
91 findval(list *lst, char *val, int (*cmp)(definition *, char *))
92 {
93          
94         for (; lst != NULL; lst = lst->next) {
95                 if ((*cmp) (lst->val, val)) {
96                         return (lst->val);
97                 }
98         }
99         return (NULL);
100 }
101
102 /*
103  * store a value in a list 
104  */
105 void
106 storeval(lstp, val)
107         list **lstp;
108         definition *val;
109 {
110         list **l;
111         list *lst;
112
113         
114         for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
115         lst = ALLOC(list);
116         lst->val = val;
117         lst->next = NULL;
118         *l = lst;
119 }
120
121 static int
122 findit(definition *def, char *type)
123 {
124         return (streq(def->def_name, type));
125 }
126
127 static char *
128 fixit(char *type, char *orig)
129 {
130         definition *def;
131
132         def = (definition *) FINDVAL(defined, type, findit);
133         if (def == NULL || def->def_kind != DEF_TYPEDEF) {
134                 return (orig);
135         }
136         switch (def->def.ty.rel) {
137         case REL_VECTOR:
138                 return (def->def.ty.old_type);
139         case REL_ALIAS:
140                 return (fixit(def->def.ty.old_type, orig));
141         default:
142                 return (orig);
143         }
144 }
145
146 char *
147 fixtype(char *type)
148 {
149         return (fixit(type, type));
150 }
151
152 char *
153 stringfix(char *type)
154 {
155         if (streq(type, "string")) {
156                 return ("wrapstring");
157         } else {
158                 return (type);
159         }
160 }
161
162 void
163 ptype(char *prefix, char *type, int follow)
164 {
165         if (prefix != NULL) {
166                 if (streq(prefix, "enum")) {
167                         f_print(fout, "enum ");
168                 } else {
169                         f_print(fout, "struct ");
170                 }
171         }
172         if (streq(type, "bool")) {
173                 f_print(fout, "bool_t ");
174         } else if (streq(type, "string")) {
175                 f_print(fout, "char *");
176         } else {
177                 f_print(fout, "%s ", follow ? fixtype(type) : type);
178         }
179 }
180
181 static int
182 typedefed(definition *def, char *type)
183 {
184         if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) {
185                 return (0);
186         } else {
187                 return (streq(def->def_name, type));
188         }
189 }
190
191 int
192 isvectordef(char *type, relation rel)
193 {
194         definition *def;
195
196         for (;;) {
197                 switch (rel) {
198                 case REL_VECTOR:
199                         return (!streq(type, "string"));
200                 case REL_ARRAY:
201                         return (0);
202                 case REL_POINTER:
203                         return (0);
204                 case REL_ALIAS:
205                         def = (definition *) FINDVAL(defined, type, typedefed);
206                         if (def == NULL) {
207                                 return (0);
208                         }
209                         type = def->def.ty.old_type;
210                         rel = def->def.ty.rel;
211                 }
212         }
213 }
214
215 char *
216 locase(char *str)
217 {
218         char c;
219         static char buf[100];
220         char *p = buf;
221
222         while ((c = *str++) != '\0') {
223                 *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
224         }
225         *p = 0;
226         return (buf);
227 }
228
229 void
230 pvname_svc(char *pname, char *vnum)
231 {
232         f_print(fout, "%s_%s_svc", locase(pname), vnum);
233 }
234
235 void
236 pvname(char *pname, char *vnum)
237 {
238         f_print(fout, "%s_%s", locase(pname), vnum);
239 }
240
241 /*
242  * print a useful (?) error message, and then die 
243  */
244 void
245 error(char *msg)
246 {
247         printwhere();
248         f_print(stderr, "%s, line %d: ", infilename, linenum);
249         f_print(stderr, "%s\n", msg);
250         crash();
251 }
252
253 /*
254  * Something went wrong, unlink any files that we may have created and then
255  * die. 
256  */
257 void
258 crash(void)
259 {
260         int i;
261
262         for (i = 0; i < nfiles; i++) {
263                 (void) unlink(outfiles[i]);
264         }
265         exit(1);
266 }
267
268 void
269 record_open(char *file)
270 {
271         if (nfiles < NFILES) {
272                 outfiles[nfiles++] = file;
273         } else {
274                 f_print(stderr, "too many files!\n");
275                 crash();
276         }
277 }
278
279 static char expectbuf[100];
280 static char *toktostr();
281
282 /*
283  * error, token encountered was not the expected one 
284  */
285 void
286 expected1(exp1)
287         tok_kind exp1;
288 {
289         s_print(expectbuf, "expected '%s'",
290                 toktostr(exp1));
291         error(expectbuf);
292 }
293
294 /*
295  * error, token encountered was not one of two expected ones 
296  */
297 void
298 expected2(exp1, exp2)
299         tok_kind exp1, exp2;
300 {
301         s_print(expectbuf, "expected '%s' or '%s'",
302                 toktostr(exp1),
303                 toktostr(exp2));
304         error(expectbuf);
305 }
306
307 /*
308  * error, token encountered was not one of 3 expected ones 
309  */
310 void
311 expected3(exp1, exp2, exp3)
312         tok_kind exp1, exp2, exp3;
313 {
314         s_print(expectbuf, "expected '%s', '%s' or '%s'",
315                 toktostr(exp1),
316                 toktostr(exp2),
317                 toktostr(exp3));
318         error(expectbuf);
319 }
320
321 void
322 tabify(f, tab)
323         FILE *f;
324         int tab;
325 {
326         while (tab--) {
327                 (void) fputc('\t', f);
328         }
329 }
330
331
332 static token tokstrings[] = {
333                              {TOK_IDENT, "identifier"},
334                              {TOK_CONST, "const"},
335                              {TOK_RPAREN, ")"},
336                              {TOK_LPAREN, "("},
337                              {TOK_RBRACE, "}"},
338                              {TOK_LBRACE, "{"},
339                              {TOK_LBRACKET, "["},
340                              {TOK_RBRACKET, "]"},
341                              {TOK_STAR, "*"},
342                              {TOK_COMMA, ","},
343                              {TOK_EQUAL, "="},
344                              {TOK_COLON, ":"},
345                              {TOK_SEMICOLON, ";"},
346                              {TOK_UNION, "union"},
347                              {TOK_STRUCT, "struct"},
348                              {TOK_SWITCH, "switch"},
349                              {TOK_CASE, "case"},
350                              {TOK_DEFAULT, "default"},
351                              {TOK_ENUM, "enum"},
352                              {TOK_TYPEDEF, "typedef"},
353                              {TOK_INT, "int"},
354                              {TOK_SHORT, "short"},
355                              {TOK_LONG, "long"},
356                              {TOK_UNSIGNED, "unsigned"},
357                              {TOK_DOUBLE, "double"},
358                              {TOK_FLOAT, "float"},
359                              {TOK_CHAR, "char"},
360                              {TOK_STRING, "string"},
361                              {TOK_OPAQUE, "opaque"},
362                              {TOK_BOOL, "bool"},
363                              {TOK_VOID, "void"},
364                              {TOK_PROGRAM, "program"},
365                              {TOK_VERSION, "version"},
366                              {TOK_EOF, "??????"}
367 };
368
369 static char *
370 toktostr(kind)
371         tok_kind kind;
372 {
373         token *sp;
374
375         for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
376         return (sp->str);
377 }
378
379 static void
380 printbuf(void)
381 {
382         char c;
383         int i;
384         int cnt;
385
386 #       define TABSIZE 4
387
388         for (i = 0; (c = curline[i]) != '\0'; i++) {
389                 if (c == '\t') {
390                         cnt = 8 - (i % TABSIZE);
391                         c = ' ';
392                 } else {
393                         cnt = 1;
394                 }
395                 while (cnt--) {
396                         (void) fputc(c, stderr);
397                 }
398         }
399 }
400
401 static void
402 printwhere(void)
403 {
404         int i;
405         char c;
406         int cnt;
407
408         printbuf();
409         for (i = 0; i < where - curline; i++) {
410                 c = curline[i];
411                 if (c == '\t') {
412                         cnt = 8 - (i % TABSIZE);
413                 } else {
414                         cnt = 1;
415                 }
416                 while (cnt--) {
417                         (void) fputc('^', stderr);
418                 }
419         }
420         (void) fputc('\n', stderr);
421 }
422
423 char * 
424 make_argname(char *pname, char *vname) 
425 {
426         char *name;
427         
428         name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3);
429         if (!name) {
430                 fprintf(stderr, "failed in malloc");
431                 exit(1);
432         }
433         sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT);
434         return(name);
435 }
436
437 bas_type *typ_list_h;
438 bas_type *typ_list_t;
439
440 void
441 add_type(int len, char *type)
442 {
443         bas_type       *ptr;
444
445
446         if ((ptr = (bas_type *) malloc(sizeof(bas_type))) == (bas_type *) NULL) {
447                 fprintf(stderr, "failed in malloc");
448                 exit(1);
449         }
450         ptr->name = type;
451         ptr->length = len;
452         ptr->next = NULL;
453         if (typ_list_t == NULL) {
454
455                 typ_list_t = ptr;
456                 typ_list_h = ptr;
457         } else {
458
459                 typ_list_t->next = ptr;
460                 typ_list_t = ptr;
461         }
462 }
463
464
465 bas_type *
466 find_type(char *type)
467 {
468         bas_type       *ptr;
469
470         ptr = typ_list_h;
471
472
473         while (ptr != NULL) {
474                 if (strcmp(ptr->name, type) == 0)
475                         return (ptr);
476                 else
477                         ptr = ptr->next;
478         };
479         return (NULL);
480 }
481