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_PROGRAM, "program"},
 377     {TOK_VERSION, "version"},
 378     {TOK_PACKAGE, "package"},
 379     {TOK_PREFIX, "prefix"},
 380     {TOK_STATINDEX, "statindex"},
 381     {TOK_SPECIAL, "special"},
 382     {TOK_STARTINGOPCODE, "startingopcode"},
 383     {TOK_CUSTOMIZED, "customized"},
 384     {TOK_PROC, "proc"},
 385     {TOK_SPLITPREFIX, "splitprefix"},
 386     {TOK_SPLIT, "split"},
 387     {TOK_MULTI, "multi"},
 388     {TOK_IN, "IN"},
 389     {TOK_OUT, "OUT"},
 390     {TOK_INOUT, "INOUT"},
 391     {TOK_AFSUUID, "afsUUID"},
 392     {TOK_EOF, "??????"}
 393 };
 394
 395 static char *
 396 toktostr(tok_kind kind)
 397 {
 398     token *sp;
 399
 400     for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
 401     return (sp->str);
 402 }
 403
 404
 405
 406 static void
 407 printbuf(void)
 408 {
 409     char c;
 410     int i;
 411     int cnt;
 412
 413 #       define TABSIZE 4
 414
 415     for (i = 0; (c = curline[i]); i++) {
 416         if (c == '\t') {
 417             cnt = 8 - (i % TABSIZE);
 418             c = ' ';
 419         } else {
 420             cnt = 1;
 421         }
 422         while (cnt--) {
 423             fputc(c, stderr);
 424         }
 425     }
 426 }
 427
 428
 429 static void
 430 printwhere(void)
 431 {
 432     int i;
 433     char c;
 434     int cnt;
 435
 436     printbuf();
 437     for (i = 0; i < where - curline; i++) {
 438         c = curline[i];
 439         if (c == '\t') {
 440             cnt = 8 - (i % TABSIZE);
 441         } else {
 442             cnt = 1;
 443         }
 444         while (cnt--) {
 445             fputc('^', stderr);
 446         }
 447     }
 448     fputc('\n', stderr);
 449 }