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