5526d709d02e3fef1ef082d74f09ee190dae03f4
[openafs.git] / src / rxgen / rpc_scan.c
1 /* @(#)rpc_scan.c       1.1 87/11/04 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_scan.c, Scanner for the RPC protocol compiler
33  * Copyright (C) 1987, Sun Microsystems, Inc.
34  */
35
36 /* Portions Copyright (c) 2003 Apple Computer, Inc. */
37 #include <afsconfig.h>
38 #include <afs/param.h>
39
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <ctype.h>
44 #include <string.h>
45
46 #include "rpc_scan.h"
47 #include "rpc_parse.h"
48 #include "rpc_util.h"
49
50 #define startcomment(where) (where[0] == '/' && where[1] == '*')
51 #define endcomment(where) (where[-1] == '*' && where[0] == '/')
52 #define verbatimstart(p) (*(p) == '@' && *((p) + 1) == '{')
53 #define verbatimend(p)  (*(p) == '@' && *((p) + 1) == '}')
54
55 int pushed = 0;                 /* is a token pushed */
56 token lasttok;                  /* last token, if pushed */
57 int scan_print = 1;
58
59 /* static prototypes */
60 static void findstrconst(char **str, char **val);
61 static void findconst(char **str, char **val);
62 static int cppline(char *line);
63 static int directive(char *line);
64 static void docppline(char *line, int *lineno, char **fname);
65 #ifdef undef
66 static void deverbatim(void);
67 #endif
68
69
70 /*
71  * scan expecting 1 given token
72  */
73 void
74 scan(tok_kind expect, token * tokp)
75 {
76     get_token(tokp);
77     if (tokp->kind != expect) {
78         expected1(expect);
79     }
80 }
81
82 /*
83  * scan expecting 2 given tokens
84  */
85 void
86 scan2(tok_kind expect1, tok_kind expect2, token * tokp)
87 {
88     get_token(tokp);
89     if (tokp->kind != expect1 && tokp->kind != expect2) {
90         expected2(expect1, expect2);
91     }
92 }
93
94 /*
95  * scan expecting 3 given token
96  */
97 void
98 scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token * tokp)
99 {
100     get_token(tokp);
101     if (tokp->kind != expect1 && tokp->kind != expect2
102         && tokp->kind != expect3) {
103         expected3(expect1, expect2, expect3);
104     }
105 }
106
107
108 /*
109  * scan expecting 4 given token
110  */
111 void
112 scan4(tok_kind expect1, tok_kind expect2, tok_kind expect3, tok_kind expect4,
113       token * tokp)
114 {
115     get_token(tokp);
116     if (tokp->kind != expect1 && tokp->kind != expect2
117         && tokp->kind != expect3 && tokp->kind != expect4) {
118         expected4(expect1, expect2, expect3, expect4);
119     }
120 }
121
122 /*
123  * scan expecting a constant, possibly symbolic
124  */
125 void
126 scan_num(token * tokp)
127 {
128     get_token(tokp);
129     switch (tokp->kind) {
130     case TOK_IDENT:
131         break;
132     default:
133         error("constant or identifier expected");
134     }
135 }
136
137
138 /*
139  * Peek at the next token
140  */
141 void
142 peek(token * tokp)
143 {
144     get_token(tokp);
145     unget_token(tokp);
146 }
147
148
149 /*
150  * Peek at the next token and scan it if it matches what you expect
151  */
152 int
153 peekscan(tok_kind expect, token * tokp)
154 {
155     peek(tokp);
156     if (tokp->kind == expect) {
157         get_token(tokp);
158         return (1);
159     }
160     return (0);
161 }
162
163
164
165 /*
166  * Get the next token, printing out any directive that are encountered.
167  */
168 void
169 get_token(token * tokp)
170 {
171     int commenting;
172     int verbatim = 0;
173
174     if (pushed) {
175         pushed = 0;
176         *tokp = lasttok;
177         return;
178     }
179     commenting = 0;
180     for (;;) {
181         if (*where == 0) {
182             for (;;) {
183                 if (!fgets(curline, MAXLINESIZE, fin)) {
184                     tokp->kind = TOK_EOF;
185                     *where = 0;
186                     return;
187                 }
188                 linenum++;
189                 if (verbatim) {
190                     fputs(curline, fout);
191                     break;
192                 }
193                 if (commenting) {
194                     break;
195                 } else if (cppline(curline)) {
196 #if defined(AFS_DARWIN_ENV)
197                     if (strncmp(curline, "#pragma", 7) == 0)
198                         continue;
199 #endif /* defined(AFS_DARWIN_ENV) */
200                     docppline(curline, &linenum, &infilename);
201                 } else if (directive(curline)) {
202                     printdirective(curline);
203                 } else {
204                     break;
205                 }
206             }
207             where = curline;
208         } else if (isspace(*where)) {
209             while (isspace(*where)) {
210                 where++;        /* eat */
211             }
212         } else if (verbatim) {
213             where++;
214             if (verbatimend(where)) {
215                 where++;
216                 verbatim--;
217             }
218         } else if (verbatimstart(where)) {
219             where += 2;
220             verbatim++;
221         } else if (commenting) {
222             where++;
223             if (endcomment(where)) {
224                 where++;
225                 commenting--;
226             }
227         } else if (startcomment(where)) {
228             where += 2;
229             commenting++;
230         } else {
231             break;
232         }
233     }
234
235     /*
236      * 'where' is not whitespace, comment or directive Must be a token!
237      */
238     switch (*where) {
239     case ':':
240         tokp->kind = TOK_COLON;
241         where++;
242         break;
243     case ';':
244         tokp->kind = TOK_SEMICOLON;
245         where++;
246         break;
247     case ',':
248         tokp->kind = TOK_COMMA;
249         where++;
250         break;
251     case '=':
252         tokp->kind = TOK_EQUAL;
253         where++;
254         break;
255     case '*':
256         tokp->kind = TOK_STAR;
257         where++;
258         break;
259     case '[':
260         tokp->kind = TOK_LBRACKET;
261         where++;
262         break;
263     case ']':
264         tokp->kind = TOK_RBRACKET;
265         where++;
266         break;
267     case '{':
268         tokp->kind = TOK_LBRACE;
269         where++;
270         break;
271     case '}':
272         tokp->kind = TOK_RBRACE;
273         where++;
274         break;
275     case '(':
276         tokp->kind = TOK_LPAREN;
277         where++;
278         break;
279     case ')':
280         tokp->kind = TOK_RPAREN;
281         where++;
282         break;
283     case '<':
284         tokp->kind = TOK_LANGLE;
285         where++;
286         break;
287     case '>':
288         tokp->kind = TOK_RANGLE;
289         where++;
290         break;
291
292     case '"':
293         tokp->kind = TOK_STRCONST;
294         findstrconst(&where, &tokp->str);
295         break;
296
297     case '-':
298     case '0':
299     case '1':
300     case '2':
301     case '3':
302     case '4':
303     case '5':
304     case '6':
305     case '7':
306     case '8':
307     case '9':
308         tokp->kind = TOK_IDENT;
309         findconst(&where, &tokp->str);
310         break;
311
312
313     default:
314         if (!(isalpha(*where) || *where == '_')) {
315             char buf[100];
316             char *p;
317
318             s_print(buf, "illegal character in file: ");
319             p = buf + strlen(buf);
320             if (isprint(*where)) {
321                 s_print(p, "%c", *where);
322             } else {
323                 s_print(p, "%d", *where);
324             }
325             error(buf);
326         }
327         findkind(&where, tokp);
328         break;
329     }
330 }
331
332
333 void
334 unget_token(token * tokp)
335 {
336     lasttok = *tokp;
337     pushed = 1;
338 }
339
340
341 static void
342 findstrconst(char **str, char **val)
343 {
344     char *p;
345     int size;
346
347     p = *str;
348     do {
349         p++;
350     } while (*p && *p != '"');
351     if (*p == 0) {
352         error("unterminated string constant");
353     }
354     p++;
355     size = (int)(p - *str);
356     *val = alloc(size + 1);
357     (void)strncpy(*val, *str, size);
358     (*val)[size] = 0;
359     *str = p;
360 }
361
362 static void
363 findconst(char **str, char **val)
364 {
365     char *p;
366     int size;
367
368     p = *str;
369     if (*p == '0' && *(p + 1) == 'x') {
370         p++;
371         do {
372             p++;
373         } while (isxdigit(*p));
374     } else {
375         do {
376             p++;
377         } while (isdigit(*p));
378     }
379     size = (int)(p - *str);
380     *val = alloc(size + 1);
381     (void)strncpy(*val, *str, size);
382     (*val)[size] = 0;
383     *str = p;
384 }
385
386
387
388 static token symbols[] = {
389     {TOK_CONST, "const"},
390     {TOK_UNION, "union"},
391     {TOK_SWITCH, "switch"},
392     {TOK_CASE, "case"},
393     {TOK_DEFAULT, "default"},
394     {TOK_STRUCT, "struct"},
395     {TOK_TYPEDEF, "typedef"},
396     {TOK_ENUM, "enum"},
397     {TOK_OPAQUE, "opaque"},
398     {TOK_BOOL, "bool"},
399     {TOK_VOID, "void"},
400     {TOK_CHAR, "char"},
401     {TOK_INT, "int"},
402     {TOK_UNSIGNED, "unsigned"},
403     {TOK_SHORT, "short"},
404     {TOK_INT32, "afs_int32"},
405     {TOK_FLOAT, "float"},
406     {TOK_DOUBLE, "double"},
407     {TOK_STRING, "string"},
408     {TOK_PROGRAM, "program"},
409     {TOK_VERSION, "version"},
410     {TOK_PACKAGE, "package"},
411     {TOK_PREFIX, "prefix"},
412     {TOK_STATINDEX, "statindex"},
413     {TOK_SPECIAL, "special"},
414     {TOK_STARTINGOPCODE, "startingopcode"},
415     {TOK_CUSTOMIZED, "customized"},
416     {TOK_PROC, "proc"},
417     {TOK_SPLITPREFIX, "splitprefix"},
418     {TOK_SPLIT, "split"},
419     {TOK_MULTI, "multi"},
420     {TOK_IN, "IN"},
421     {TOK_OUT, "OUT"},
422     {TOK_INOUT, "INOUT"},
423     {TOK_AFSUUID, "afsUUID"},
424     {TOK_EOF, "??????"},
425 };
426
427
428 void
429 findkind(char **mark, token * tokp)
430 {
431
432     int len;
433     token *s;
434     char *str;
435
436     str = *mark;
437     for (s = symbols; s->kind != TOK_EOF; s++) {
438         len = (int)strlen(s->str);
439         if (strncmp(str, s->str, len) == 0) {
440             if (!isalnum(str[len]) && str[len] != '_') {
441                 tokp->kind = s->kind;
442                 tokp->str = s->str;
443                 *mark = str + len;
444                 return;
445             }
446         }
447     }
448     tokp->kind = TOK_IDENT;
449     for (len = 0; isalnum(str[len]) || str[len] == '_'; len++);
450     tokp->str = alloc(len + 1);
451     (void)strncpy(tokp->str, str, len);
452     tokp->str[len] = 0;
453     *mark = str + len;
454 }
455
456 static int
457 cppline(char *line)
458 {
459     return (line == curline && *line == '#');
460 }
461
462 static int
463 directive(char *line)
464 {
465     return (line == curline && *line == '%');
466 }
467
468 void
469 printdirective(char *line)
470 {
471     f_print(fout, "%s", line + 1);
472 }
473
474 static void
475 docppline(char *line, int *lineno, char **fname)
476 {
477     char *file;
478     int num;
479     char *p;
480
481     line++;
482     while (isspace(*line)) {
483         line++;
484     }
485     num = atoi(line);
486     while (isdigit(*line)) {
487         line++;
488     }
489     while (isspace(*line)) {
490         line++;
491     }
492 #ifdef  AFS_HPUX_ENV
493     if (*line == '\0') {
494         *fname = NULL;
495         *lineno = num - 1;
496         return;
497     }
498 #endif
499     if (*line != '"') {
500 #ifdef  AFS_AIX41_ENV
501         if (!strncmp(line, "line", 4)) {
502             while (*line)
503                 *line++;
504             *fname = NULL;
505             *lineno = num - 1;
506             return;
507         }
508 #endif
509         error("preprocessor error");
510     }
511     line++;
512     p = file = alloc(strlen(line) + 1);
513     while (*line && *line != '"') {
514         *p++ = *line++;
515     }
516     if (*line == 0) {
517         error("preprocessor error");
518     }
519     *p = 0;
520     if (*file == 0) {
521         *fname = NULL;
522     } else {
523         *fname = file;
524     }
525     *lineno = num - 1;
526 }
527
528
529 #ifdef undef
530 /* doesn't appear to be used */
531 static void
532 deverbatim(void)
533 {
534     for (where += 2; !verbatimend(where); where++) {
535         if (*where == 0) {
536             if (!fgets(curline, MAXLINESIZE, fin)) {
537                 error("unterminated code: %} is missing");
538             }
539             linenum++;
540             where = curline - 1;
541             if (verbatimend(curline)) {
542                 where++;
543                 break;
544             }
545             fputs(curline, fout);
546         }
547     }
548     where += 2;
549 }
550 #endif