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