usr.bin/rpcgen/rpc_scan.c

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user.
   8  *
   9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12  *
  13  * Sun RPC is provided with no support and without any obligation on the
  14  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15  * modification or enhancement.
  16  *
  17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19  * OR ANY PART THEREOF.
  20  *
  21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22  * or profits or other special, indirect and consequential damages, even if
  23  * Sun has been advised of the possibility of such damages.
  24  *
  25  * Sun Microsystems, Inc.
  26  * 2550 Garcia Avenue
  27  * Mountain View, California  94043
  28  *
  29  * @(#)rpc_scan.c       1.13    93/07/05 SMI; 1.11 89/02/22 (C) 1987 SMI
  30  * $FreeBSD: src/usr.bin/rpcgen/rpc_scan.c,v 1.10 2005/11/13 21:17:24 dwmalone Exp $
  31  * $DragonFly: src/usr.bin/rpcgen/rpc_scan.c,v 1.5 2008/10/16 01:52:33 swildner Exp $
  32  */
  33
  34 /*
  35  * rpc_scan.c, Scanner for the RPC protocol compiler
  36  * Copyright (C) 1987, Sun Microsystems, Inc.
  37  */
  38
  39 #include <sys/types.h>
  40
  41 #include <sys/wait.h>
  42 #include <stdio.h>
  43 #include <ctype.h>
  44 #include <string.h>
  45 #include "rpc_parse.h"
  46 #include "rpc_scan.h"
  47 #include "rpc_util.h"
  48
  49 #define startcomment(where) (where[0] == '/' && where[1] == '*')
  50 #define endcomment(where) (where[-1] == '*' && where[0] == '/')
  51
  52 static int pushed = 0;  /* is a token pushed */
  53 static token lasttok;   /* last token, if pushed */
  54
  55 static void     unget_token(token *);
  56 static void     findstrconst(char **, const char **);
  57 static void     findchrconst(char **, const char **);
  58 static void     findconst(char **, const char **);
  59 static void     findkind(char **, token *);
  60 static int      cppline(char *);
  61 static int      directive(char *);
  62 static void     printdirective(char *);
  63 static void     docppline(char *, int *, const char **);
  64
  65 /*
  66  * scan expecting 1 given token
  67  */
  68 void
  69 scan(tok_kind expect, token *tokp)
  70 {
  71         get_token(tokp);
  72         if (tokp->kind != expect)
  73                 expected1(expect);
  74 }
  75
  76 /*
  77  * scan expecting any of the 2 given tokens
  78  */
  79 void
  80 scan2(tok_kind expect1, tok_kind expect2, token *tokp)
  81 {
  82         get_token(tokp);
  83         if (tokp->kind != expect1 && tokp->kind != expect2)
  84                 expected2(expect1, expect2);
  85 }
  86
  87 /*
  88  * scan expecting any of the 3 given token
  89  */
  90 void
  91 scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp)
  92 {
  93         get_token(tokp);
  94         if (tokp->kind != expect1 && tokp->kind != expect2 &&
  95             tokp->kind != expect3)
  96                 expected3(expect1, expect2, expect3);
  97 }
  98
  99 /*
 100  * scan expecting a constant, possibly symbolic
 101  */
 102 void
 103 scan_num(token *tokp)
 104 {
 105         get_token(tokp);
 106         switch (tokp->kind) {
 107         case TOK_IDENT:
 108                 break;
 109         default:
 110                 error("constant or identifier expected");
 111         }
 112 }
 113
 114 /*
 115  * Peek at the next token
 116  */
 117 void
 118 peek(token *tokp)
 119 {
 120         get_token(tokp);
 121         unget_token(tokp);
 122 }
 123
 124 /*
 125  * Peek at the next token and scan it if it matches what you expect
 126  */
 127 int
 128 peekscan(tok_kind expect, token *tokp)
 129 {
 130         peek(tokp);
 131         if (tokp->kind == expect) {
 132                 get_token(tokp);
 133                 return(1);
 134         }
 135         return(0);
 136 }
 137
 138 /*
 139  * Get the next token, printing out any directive that are encountered.
 140  */
 141 void
 142 get_token(token *tokp)
 143 {
 144         int commenting;
 145         int stat = 0;
 146
 147         if (pushed) {
 148                 pushed = 0;
 149                 *tokp = lasttok;
 150                 return;
 151         }
 152         commenting = 0;
 153         for (;;) {
 154                 if (*where == 0) {
 155                         for (;;) {
 156                                 if (!fgets(curline, MAXLINESIZE, fin)) {
 157                                         tokp->kind = TOK_EOF;
 158                                         /*
 159                                          * now check if cpp returned
 160                                          * non NULL value
 161                                          */
 162                                         waitpid(childpid, &stat, WUNTRACED);
 163                                         if (stat > 0) {
 164                                                 /*
 165                                                  * Set return value from rpcgen
 166                                                  */
 167                                                 nonfatalerrors = stat >> 8;
 168                                         }
 169                                         *where = 0;
 170                                         return;
 171                                 }
 172                                 linenum++;
 173                                 if (commenting)
 174                                         break;
 175                                 else if (cppline(curline))
 176                                         docppline(curline, &linenum,
 177                                                   &infilename);
 178                                 else if (directive(curline))
 179                                         printdirective(curline);
 180                                 else
 181                                         break;
 182                         }
 183                         where = curline;
 184                 } else if (isspace(*where)) {
 185                         while (isspace(*where))
 186                                 where++;        /* eat */
 187                 } else if (commenting) {
 188                         for (where++; *where; where++) {
 189                                 if (endcomment(where)) {
 190                                         where++;
 191                                         commenting--;
 192                                         break;
 193                                 }
 194                         }
 195                 } else if (startcomment(where)) {
 196                         where += 2;
 197                         commenting++;
 198                 } else {
 199                         break;
 200                 }
 201         }
 202
 203         /*
 204          * 'where' is not whitespace, comment or directive Must be a token!
 205          */
 206         switch (*where) {
 207         case ':':
 208                 tokp->kind = TOK_COLON;
 209                 where++;
 210                 break;
 211         case ';':
 212                 tokp->kind = TOK_SEMICOLON;
 213                 where++;
 214                 break;
 215         case ',':
 216                 tokp->kind = TOK_COMMA;
 217                 where++;
 218                 break;
 219         case '=':
 220                 tokp->kind = TOK_EQUAL;
 221                 where++;
 222                 break;
 223         case '*':
 224                 tokp->kind = TOK_STAR;
 225                 where++;
 226                 break;
 227         case '[':
 228                 tokp->kind = TOK_LBRACKET;
 229                 where++;
 230                 break;
 231         case ']':
 232                 tokp->kind = TOK_RBRACKET;
 233                 where++;
 234                 break;
 235         case '{':
 236                 tokp->kind = TOK_LBRACE;
 237                 where++;
 238                 break;
 239         case '}':
 240                 tokp->kind = TOK_RBRACE;
 241                 where++;
 242                 break;
 243         case '(':
 244                 tokp->kind = TOK_LPAREN;
 245                 where++;
 246                 break;
 247         case ')':
 248                 tokp->kind = TOK_RPAREN;
 249                 where++;
 250                 break;
 251         case '<':
 252                 tokp->kind = TOK_LANGLE;
 253                 where++;
 254                 break;
 255         case '>':
 256                 tokp->kind = TOK_RANGLE;
 257                 where++;
 258                 break;
 259
 260         case '"':
 261                 tokp->kind = TOK_STRCONST;
 262                 findstrconst(&where, &tokp->str);
 263                 break;
 264         case '\'':
 265                 tokp->kind = TOK_CHARCONST;
 266                 findchrconst(&where, &tokp->str);
 267                 break;
 268
 269         case '-':
 270         case '0':
 271         case '1':
 272         case '2':
 273         case '3':
 274         case '4':
 275         case '5':
 276         case '6':
 277         case '7':
 278         case '8':
 279         case '9':
 280                 tokp->kind = TOK_IDENT;
 281                 findconst(&where, &tokp->str);
 282                 break;
 283
 284         default:
 285                 if (!(isalpha(*where) || *where == '_')) {
 286                         char buf[100];
 287                         char *p;
 288
 289                         s_print(buf, "illegal character in file: ");
 290                         p = buf + strlen(buf);
 291                         if (isprint(*where)) {
 292                                 s_print(p, "%c", *where);
 293                         } else {
 294                                 s_print(p, "%d", *where);
 295                         }
 296                         error(buf);
 297                 }
 298                 findkind(&where, tokp);
 299                 break;
 300         }
 301 }
 302
 303 static void
 304 unget_token(token *tokp)
 305 {
 306         lasttok = *tokp;
 307         pushed = 1;
 308 }
 309
 310 static void
 311 findstrconst(char **str, const char **val)
 312 {
 313         char *p;
 314         char *tmp;
 315         int size;
 316
 317         p = *str;
 318         do {
 319                 p++;
 320         } while (*p && *p != '"');
 321         if (*p == 0)
 322                 error("unterminated string constant");
 323         p++;
 324         size = p - *str;
 325         tmp = xmalloc(size + 1);
 326         strncpy(tmp, *str, size);
 327         tmp[size] = 0;
 328         *val = tmp;
 329         *str = p;
 330 }
 331
 332 static void
 333 findchrconst(char **str, const char **val)
 334 {
 335         char *p;
 336         char *tmp;
 337         int size;
 338
 339         p = *str;
 340         do {
 341                 p++;
 342         } while (*p && *p != '\'');
 343         if (*p == 0)
 344                 error("unterminated string constant");
 345         p++;
 346         size = p - *str;
 347         if (size != 3)
 348                 error("empty char string");
 349         tmp = xmalloc(size + 1);
 350         strncpy(tmp, *str, size);
 351         tmp[size] = 0;
 352         *val = tmp;
 353         *str = p;
 354 }
 355
 356 static void
 357 findconst(char **str, const char **val)
 358 {
 359         char *p;
 360         char *tmp;
 361         int size;
 362
 363         p = *str;
 364         if (*p == '0' && *(p + 1) == 'x') {
 365                 p++;
 366                 do {
 367                         p++;
 368                 } while (isxdigit(*p));
 369         } else {
 370                 do {
 371                         p++;
 372                 } while (isdigit(*p));
 373         }
 374         size = p - *str;
 375         tmp = xmalloc(size + 1);
 376         strncpy(tmp, *str, size);
 377         tmp[size] = 0;
 378         *val = tmp;
 379         *str = p;
 380 }
 381
 382 static token symbols[] = {
 383                           {TOK_CONST, "const"},
 384                           {TOK_UNION, "union"},
 385                           {TOK_SWITCH, "switch"},
 386                           {TOK_CASE, "case"},
 387                           {TOK_DEFAULT, "default"},
 388                           {TOK_STRUCT, "struct"},
 389                           {TOK_TYPEDEF, "typedef"},
 390                           {TOK_ENUM, "enum"},
 391                           {TOK_OPAQUE, "opaque"},
 392                           {TOK_BOOL, "bool"},
 393                           {TOK_VOID, "void"},
 394                           {TOK_CHAR, "char"},
 395                           {TOK_INT, "int"},
 396                           {TOK_UNSIGNED, "unsigned"},
 397                           {TOK_SHORT, "short"},
 398                           {TOK_LONG, "long"},
 399                           {TOK_HYPER, "hyper"},
 400                           {TOK_FLOAT, "float"},
 401                           {TOK_DOUBLE, "double"},
 402                           {TOK_QUAD, "quadruple"},
 403                           {TOK_STRING, "string"},
 404                           {TOK_PROGRAM, "program"},
 405                           {TOK_VERSION, "version"},
 406                           {TOK_EOF, "??????"},
 407 };
 408
 409 static void
 410 findkind(char **mark, token *tokp)
 411 {
 412         int len;
 413         token *s;
 414         char *str, *tmp;
 415
 416         str = *mark;
 417         for (s = symbols; s->kind != TOK_EOF; s++) {
 418                 len = strlen(s->str);
 419                 if (strncmp(str, s->str, len) == 0) {
 420                         if (!isalnum(str[len]) && str[len] != '_') {
 421                                 tokp->kind = s->kind;
 422                                 tokp->str = s->str;
 423                                 *mark = str + len;
 424                                 return;
 425                         }
 426                 }
 427         }
 428         tokp->kind = TOK_IDENT;
 429         for (len = 0; isalnum(str[len]) || str[len] == '_'; len++);
 430         tmp = xmalloc(len + 1);
 431         strncpy(tmp, str, len);
 432         tmp[len] = 0;
 433         tokp->str = tmp;
 434         *mark = str + len;
 435 }
 436
 437 static int
 438 cppline(char *line)
 439 {
 440         return(line == curline && *line == '#');
 441 }
 442
 443 static int
 444 directive(char *line)
 445 {
 446         return(line == curline && *line == '%');
 447 }
 448
 449 static void
 450 printdirective(char *line)
 451 {
 452         f_print(fout, "%s", line + 1);
 453 }
 454
 455 static void
 456 docppline(char *line, int *lineno, const char **fname)
 457 {
 458         char *file;
 459         int num;
 460         char *p;
 461
 462         line++;
 463         while (isspace(*line))
 464                 line++;
 465         num = atoi(line);
 466         while (isdigit(*line))
 467                 line++;
 468         while (isspace(*line))
 469                 line++;
 470         if (*line != '"')
 471                 error("preprocessor error");
 472         line++;
 473         p = file = xmalloc(strlen(line) + 1);
 474         while (*line && *line != '"')
 475                 *p++ = *line++;
 476         if (*line == 0)
 477                 error("preprocessor error");
 478         *p = 0;
 479         if (*file == 0)
 480                 *fname = NULL;
 481         else
 482                 *fname = file;
 483         *lineno = num - 1;
 484 }