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