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