Remove sunrpc compatibility
[openafs.git] / src / rxgen / rpc_util.c
1 /* @(#)rpc_util.c       1.2 87/11/24 3.9 RPCSRC */
2 /*
3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
4  * unrestricted use provided that this legend is included on all tape
5  * media and as a part of the software program in whole or part.  Users
6  * may copy or modify Sun RPC without charge, but are not authorized
7  * to license or distribute it to anyone else except as part of a product or
8  * program developed by the user.
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 /*
32  * rpc_util.c, Utility routines for the RPC protocol compiler
33  * Copyright (C) 1987, Sun Microsystems, Inc.
34  */
35 #include <afsconfig.h>
36 #include <afs/param.h>
37
38 #include <roken.h>
39
40 #include "rpc_scan.h"
41 #include "rpc_parse.h"
42 #include "rpc_util.h"
43
44 char curline[MAXLINESIZE];      /* current read line */
45 char *where = curline;          /* current point in line */
46 int linenum = 0;                /* current line number */
47
48 char *infilename;               /* input filename */
49
50 #define NFILES 6
51 char *outfiles[NFILES];         /* output file names */
52 int nfiles;
53
54 FILE *fout;                     /* file pointer of current output */
55 FILE *fin;                      /* file pointer of current input */
56
57 list *defined;                  /* list of defined things */
58
59 /* static prototypes */
60 static int findit(definition * def, char *type);
61 static char *fixit(char *type, char *orig);
62 static int typedefed(definition * def, char *type);
63 static char *locase(char *str);
64 static char *toktostr(tok_kind kind);
65 static void printbuf(void);
66 static void printwhere(void);
67
68
69 /*
70  * Reinitialize the world
71  */
72 void
73 reinitialize(void)
74 {
75     int i;
76     memset(curline, 0, MAXLINESIZE);
77     where = curline;
78     linenum = 0;
79     defined = NULL;
80     special_defined = typedef_defined = uniondef_defined = NULL;
81     PackageIndex = -1;
82     master_opcodenumber = 99999;
83     master_highest_opcode = 0;
84     no_of_stat_funcs = 0;
85     for (i = 0; i < MAX_PACKAGES; i++) {
86         no_of_stat_funcs_header[i] = 0;
87     }
88 }
89
90 /*
91  * string equality
92  */
93 int
94 streq(char *a, char *b)
95 {
96     return (strcmp(a, b) == 0);
97 }
98
99 /*
100  * find a value in a list
101  */
102 char *
103 findval(list * lst, char *val, int (*cmp) (definition * def, char *type))
104 {
105     for (; lst != NULL; lst = lst->next) {
106         if ((*cmp) ((definition *) lst->val, val)) {
107             return (lst->val);
108         }
109     }
110     return (NULL);
111 }
112
113 /*
114  * store a value in a list
115  */
116 void
117 storeval(list ** lstp, char *val)
118 {
119     list **l;
120     list *lst;
121
122     for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
123     lst = ALLOC(list);
124     lst->val = val;
125     lst->next = NULL;
126     *l = lst;
127 }
128
129
130 static int
131 findit(definition * def, char *type)
132 {
133     return (streq(def->def_name, type));
134 }
135
136
137 static char *
138 fixit(char *type, char *orig)
139 {
140     definition *def;
141
142     def = (definition *) FINDVAL(defined, type, findit);
143     if (def == NULL || def->def_kind != DEF_TYPEDEF) {
144         return (orig);
145     }
146     switch (def->def.ty.rel) {
147     case REL_VECTOR:
148         return (def->def.ty.old_type);
149     case REL_ALIAS:
150         return (fixit(def->def.ty.old_type, orig));
151     default:
152         return (orig);
153     }
154 }
155
156 char *
157 fixtype(char *type)
158 {
159     return (fixit(type, type));
160 }
161
162 char *
163 stringfix(char *type)
164 {
165     if (streq(type, "string")) {
166         return ("wrapstring");
167     } else {
168         return (type);
169     }
170 }
171
172 void
173 ptype(char *prefix, char *type, int follow)
174 {
175     if (prefix != NULL) {
176         if (streq(prefix, "enum")) {
177             f_print(fout, "enum ");
178         } else {
179             f_print(fout, "struct ");
180         }
181     }
182     if (streq(type, "bool")) {
183         f_print(fout, "bool_t ");
184     } else if (streq(type, "string")) {
185         f_print(fout, "char *");
186     } else {
187         f_print(fout, "%s ", follow ? fixtype(type) : type);
188     }
189 }
190
191
192 static int
193 typedefed(definition * def, char *type)
194 {
195     if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) {
196         return (0);
197     } else {
198         return (streq(def->def_name, type));
199     }
200 }
201
202 int
203 isvectordef(char *type, relation rel)
204 {
205     definition *def;
206
207     for (;;) {
208         switch (rel) {
209         case REL_VECTOR:
210             return (!streq(type, "string"));
211         case REL_ARRAY:
212             return (0);
213         case REL_POINTER:
214             return (0);
215         case REL_ALIAS:
216             def = (definition *) FINDVAL(defined, type, typedefed);
217             if (def == NULL) {
218                 return (0);
219             }
220             type = def->def.ty.old_type;
221             rel = def->def.ty.rel;
222         }
223     }
224 }
225
226
227 static char *
228 locase(char *str)
229 {
230     char c;
231     static char buf[100];
232     char *p = buf;
233
234     while ((c = *str++)) {
235         *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
236     }
237     *p = 0;
238     return (buf);
239 }
240
241
242 void
243 pvname(char *pname, char *vnum)
244 {
245     f_print(fout, "%s_%s", locase(pname), vnum);
246 }
247
248
249 /*
250  * print a useful (?) error message, and then die
251  */
252 void
253 error(char *msg)
254 {
255     printwhere();
256     f_print(stderr, "%s, line %d: ", infilename, linenum);
257     f_print(stderr, "%s\n", msg);
258     crash();
259 }
260
261 /*
262  * Something went wrong, unlink any files that we may have created and then
263  * die.
264  */
265 void
266 crash(void)
267 {
268     int i;
269
270     for (i = 0; i < nfiles; i++) {
271         (void)unlink(outfiles[i]);
272     }
273     exit(1);
274 }
275
276
277 void
278 record_open(char *file)
279 {
280     if (nfiles < NFILES) {
281         outfiles[nfiles++] = file;
282     } else {
283         f_print(stderr, "too many files!\n");
284         crash();
285     }
286 }
287
288 /* buffer shared for all of the expected* routines */
289 static char expectbuf[100];
290
291 /*
292  * error, token encountered was not the expected one
293  */
294 void
295 expected1(tok_kind exp1)
296 {
297     s_print(expectbuf, "expected '%s'", toktostr(exp1));
298     error(expectbuf);
299 }
300
301 /*
302  * error, token encountered was not one of two expected ones
303  */
304 void
305 expected2(tok_kind exp1, tok_kind exp2)
306 {
307     s_print(expectbuf, "expected '%s' or '%s'", toktostr(exp1),
308             toktostr(exp2));
309     error(expectbuf);
310 }
311
312 /*
313  * error, token encountered was not one of 3 expected ones
314  */
315 void
316 expected3(tok_kind exp1, tok_kind exp2, tok_kind exp3)
317 {
318     s_print(expectbuf, "expected '%s', '%s' or '%s'", toktostr(exp1),
319             toktostr(exp2), toktostr(exp3));
320     error(expectbuf);
321 }
322
323
324 /*
325  * error, token encountered was not one of 4 expected ones
326  */
327 void
328 expected4(tok_kind exp1, tok_kind exp2, tok_kind exp3, tok_kind exp4)
329 {
330     sprintf(expectbuf, "expected '%s', '%s', '%s', or '%s'", toktostr(exp1),
331             toktostr(exp2), toktostr(exp3), toktostr(exp4));
332     error(expectbuf);
333 }
334
335 void
336 tabify(FILE * f, int tab)
337 {
338     if (scan_print)
339         while (tab--) {
340             (void)fputc('\t', f);
341         }
342 }
343
344 static token tokstrings[] = {
345     {TOK_IDENT, "identifier"},
346     {TOK_CONST, "const"},
347     {TOK_RPAREN, ")"},
348     {TOK_LPAREN, "("},
349     {TOK_RBRACE, "}"},
350     {TOK_LBRACE, "{"},
351     {TOK_LBRACKET, "["},
352     {TOK_RBRACKET, "]"},
353     {TOK_STAR, "*"},
354     {TOK_COMMA, ","},
355     {TOK_EQUAL, "="},
356     {TOK_COLON, ":"},
357     {TOK_SEMICOLON, ";"},
358     {TOK_UNION, "union"},
359     {TOK_STRUCT, "struct"},
360     {TOK_SWITCH, "switch"},
361     {TOK_CASE, "case"},
362     {TOK_DEFAULT, "default"},
363     {TOK_ENUM, "enum"},
364     {TOK_TYPEDEF, "typedef"},
365     {TOK_INT, "int"},
366     {TOK_SHORT, "short"},
367     {TOK_INT32, "afs_int32"},   /* XXX */
368     {TOK_UNSIGNED, "unsigned"},
369     {TOK_DOUBLE, "double"},
370     {TOK_FLOAT, "float"},
371     {TOK_CHAR, "char"},
372     {TOK_STRING, "string"},
373     {TOK_OPAQUE, "opaque"},
374     {TOK_BOOL, "bool"},
375     {TOK_VOID, "void"},
376     {TOK_PACKAGE, "package"},
377     {TOK_PREFIX, "prefix"},
378     {TOK_STATINDEX, "statindex"},
379     {TOK_SPECIAL, "special"},
380     {TOK_STARTINGOPCODE, "startingopcode"},
381     {TOK_CUSTOMIZED, "customized"},
382     {TOK_PROC, "proc"},
383     {TOK_SPLITPREFIX, "splitprefix"},
384     {TOK_SPLIT, "split"},
385     {TOK_MULTI, "multi"},
386     {TOK_IN, "IN"},
387     {TOK_OUT, "OUT"},
388     {TOK_INOUT, "INOUT"},
389     {TOK_AFSUUID, "afsUUID"},
390     {TOK_EOF, "??????"}
391 };
392
393 static char *
394 toktostr(tok_kind kind)
395 {
396     token *sp;
397
398     for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
399     return (sp->str);
400 }
401
402
403
404 static void
405 printbuf(void)
406 {
407     char c;
408     int i;
409     int cnt;
410
411 #       define TABSIZE 4
412
413     for (i = 0; (c = curline[i]); i++) {
414         if (c == '\t') {
415             cnt = 8 - (i % TABSIZE);
416             c = ' ';
417         } else {
418             cnt = 1;
419         }
420         while (cnt--) {
421             fputc(c, stderr);
422         }
423     }
424 }
425
426
427 static void
428 printwhere(void)
429 {
430     int i;
431     char c;
432     int cnt;
433
434     printbuf();
435     for (i = 0; i < where - curline; i++) {
436         c = curline[i];
437         if (c == '\t') {
438             cnt = 8 - (i % TABSIZE);
439         } else {
440             cnt = 1;
441         }
442         while (cnt--) {
443             fputc('^', stderr);
444         }
445     }
446     fputc('\n', stderr);
447 }