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