![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to token.lex CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / command|
Return to token.lex CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / command |
1.1 root 1: %{
2: /*
3: * Copyright (c) 1982 Regents of the University of California.
4: * All rights reserved. The Berkeley software License Agreement
5: * specifies the terms and conditions for redistribution.
6: */
7:
8: #ifndef lint
9: static char sccsid[] = "@(#)token.lex 5.1 (Berkeley) 6/7/85";
10: #endif not lint
11:
12: /*
13: * Token definitions for pdx scanner.
14: */
15:
16: #include "defs.h"
17: #include "command.h"
18: #include "y.tab.h"
19: #include "main.h"
20: #include "symtab.h"
21: #include "sym.h"
22: #include "process.h"
23: #include "process/pxinfo.h"
24:
25: char *initfile = ".pdxinit";
26:
27: /*
28: * This is a silly "lex" thing.
29: */
30:
31: #define yywrap() (1)
32:
33: /*
34: * Override Lex default input macros.
35: */
36:
37: #undef input
38: #undef unput
39:
40: #define unput(c) ungetc(c, yyin)
41:
42: %}
43:
44: blank [ \t]
45: white {blank}+
46: alpha [a-zA-Z]
47: digit [0-9]
48: n {digit}+
49: h [0-9a-fA-F]+
50: e (("e"|"E")("+"|"-")?{n})
51: alphanum [a-zA-Z0-9]
52: ident {alpha}{alphanum}*
53: filenm [^ \t\n"<>!*"]+
54: qfilenm {filenm}/":"
55: string '[^']+'('[^']*')*
56: newline "\n"
57: char .
58:
59: %Start file sh
60:
61: %%
62:
63: {white} ;
64: ^sh{white}.*$ { BEGIN 0; yylval.y_string = &yytext[3]; return(SH); }
65: ^sh { BEGIN 0; yylval.y_string = NIL; return(SH); }
66: ^{ident} { return(findcmd(yytext)); }
67: <file>{filenm} { yylval.y_string = strdup(yytext); return(FILENAME); }
68: {qfilenm} { yylval.y_string = strdup(yytext); return(FILENAME); }
69: {n}?\.{n}{e}? { yylval.y_real = atof(yytext); return(REAL); }
70: 0{n} { yylval.y_long = octal(yytext); return(INT); }
71: 0x{h} { yylval.y_long = hex(yytext); return(INT); }
72: {n} { yylval.y_long = atol(yytext); return(INT); }
73: at { return(AT); }
74: {ident} { return(ident(yytext)); }
75: {string} { yylval.y_string = yytext; return(STRING); }
76: "%dp" { yylval.y_long = (long) DP; return(INT); }
77: {newline} { BEGIN 0; nlflag = TRUE; return('\n'); }
78: {char} { return(yylval.y_int = yytext[0]); }
79:
80: %%
81:
82: LOCAL SYMTAB *dbtab, *specialtab;
83:
84: /*
85: * Look for the given string in the debugger keyword table.
86: * If it's there, return the associated token, otherwise report an error.
87: */
88:
89: LOCAL int findcmd(s)
90: char *s;
91: {
92: register SYM *p;
93:
94: if ((p = st_lookup(dbtab, s)) == NIL) {
95: error("\"%s\" is not a command", s);
96: }
97: yylval.y_int = tokval(p);
98: switch (toknum(p)) {
99: case ALIAS:
100: case DUMP:
101: case EDIT:
102: case CHFILE:
103: case RUN:
104: case SOURCE:
105: case STATUS:
106: BEGIN file;
107: break;
108:
109: default:
110: /* do nothing */;
111: }
112: return(toknum(p));
113: }
114:
115: /*
116: * Look for a symbol, first in the special table (if, in, etc.)
117: * then in the symbol table. If it's there, return the SYM pointer,
118: * otherwise it's an error.
119: */
120:
121: LOCAL int ident(s)
122: char *s;
123: {
124: register SYM *p;
125:
126: if ((p = st_lookup(specialtab, s)) != NIL) {
127: yylval.y_sym = p;
128: return(toknum(p));
129: }
130: p = st_lookup(symtab, s);
131: if (p == NIL) {
132: if (strcmp(s, "nil") == 0) {
133: yylval.y_long = 0L;
134: return(INT);
135: } else {
136: error("\"%s\" is not defined", s);
137: }
138: }
139: yylval.y_sym = p;
140: return(NAME);
141: }
142:
143: /*
144: * Convert a string to octal. No check that digits are less than 8.
145: */
146:
147: LOCAL int octal(s)
148: char *s;
149: {
150: register char *p;
151: register int n;
152:
153: n = 0;
154: for (p = s; *p != '\0'; p++) {
155: n = 8*n + (*p - '0');
156: }
157: return(n);
158: }
159:
160: /*
161: * Convert a string to hex.
162: */
163:
164: LOCAL int hex(s)
165: char *s;
166: {
167: register char *p;
168: register int n;
169:
170: n = 0;
171: for (p = s+2; *p != '\0'; p++) {
172: n *= 16;
173: if (*p >= 'a' && *p <= 'f') {
174: n += (*p - 'a' + 10);
175: } else if (*p >= 'A' && *p <= 'F') {
176: n += (*p - 'A' + 10);
177: } else {
178: n += (*p - '0');
179: }
180: }
181: return(n);
182: }
183:
184: /*
185: * Initialize the debugger keyword table (dbtab) and special symbol
186: * table (specialtab).
187: */
188:
189: #define db_keyword(nm, n) make_keyword(dbtab, nm, n)
190: #define sp_keyword(nm, n) make_keyword(specialtab, nm, n)
191:
192: lexinit()
193: {
194: dbtab = st_creat(150);
195: db_keyword("alias", ALIAS);
196: db_keyword("assign", ASSIGN);
197: db_keyword("call", CALL);
198: db_keyword("cont", CONT);
199: db_keyword("delete", DELETE);
200: db_keyword("dump", DUMP);
201: db_keyword("edit", EDIT);
202: db_keyword("file", CHFILE);
203: db_keyword("gripe", GRIPE);
204: db_keyword("help", HELP);
205: db_keyword("list", LIST);
206: db_keyword("next", NEXT);
207: db_keyword("pi", REMAKE);
208: db_keyword("print", PRINT);
209: db_keyword("quit", QUIT);
210: db_keyword("run", RUN);
211: db_keyword("sh", SH);
212: db_keyword("source", SOURCE);
213: db_keyword("status", STATUS);
214: db_keyword("step", STEP);
215: db_keyword("stop", STOP);
216: db_keyword("stopi", STOPI);
217: db_keyword("trace", TRACE);
218: db_keyword("tracei", TRACEI);
219: db_keyword("whatis", WHATIS);
220: db_keyword("where", WHERE);
221: db_keyword("which", WHICH);
222: db_keyword("xd", XD);
223: db_keyword("xi", XI);
224:
225: specialtab = st_creat(10);
226: sp_keyword("div", DIV);
227: sp_keyword("mod", MOD);
228: sp_keyword("in", IN);
229: sp_keyword("if", IF);
230: sp_keyword("and", AND);
231: sp_keyword("or", OR);
232: }
233:
234: /*
235: * Send an alias directive over to the symbol table manager.
236: */
237:
238: alias(new, old)
239: char *new, *old;
240: {
241: if (old == NIL) {
242: print_alias(dbtab, new);
243: } else {
244: enter_alias(dbtab, new, old);
245: }
246: }
247:
248: /*
249: * Input file management routines, "yyin" is Lex's idea of
250: * where the input comes from.
251: */
252:
253: #define MAXINPUT 10
254:
255: LOCAL FILE *infp[MAXINPUT];
256: LOCAL FILE **curfp = &infp[0];
257:
258: LOCAL BOOLEAN isnewfile;
259: LOCAL BOOLEAN firsttime;
260:
261: /*
262: * Initially, we set the input to the initfile if it exists.
263: * If it does exist, we play a game or two to avoid generating
264: * multiple prompts.
265: */
266:
267: initinput()
268: {
269: FILE *fp;
270:
271: firsttime = FALSE;
272: fp = fopen(initfile, "r");
273: if (fp != NIL) {
274: fclose(fp);
275: setinput(initfile);
276: if (!option('r')) {
277: firsttime = TRUE;
278: }
279: }
280: nlflag = TRUE;
281: }
282:
283: /*
284: * Set the input to the named file. It is expected that the file exists
285: * and is readable.
286: */
287:
288: setinput(filename)
289: char *filename;
290: {
291: register FILE *fp;
292:
293: if ((fp = fopen(filename, "r")) == NIL) {
294: error("can't open %s", filename);
295: }
296: if (curfp >= &infp[MAXINPUT]) {
297: error("unreasonable input nesting on %s", filename);
298: }
299: *curfp++ = yyin;
300: yyin = fp;
301: isnewfile = TRUE;
302: }
303:
304: BOOLEAN isstdin()
305: {
306: return((BOOLEAN) (yyin == stdin));
307: }
308:
309: LOCAL int input()
310: {
311: register int c;
312:
313: if (isnewfile) {
314: isnewfile = FALSE;
315: return('\n');
316: }
317: while ((c = getc(yyin)) == EOF) {
318: if (curfp == &infp[0]) {
319: return(0);
320: } else {
321: fclose(yyin);
322: yyin = *--curfp;
323: if (yyin == stdin) {
324: if (firsttime) {
325: firsttime = FALSE;
326: } else {
327: prompt();
328: }
329: }
330: }
331: }
332: return(c);
333: }
334:
335: /*
336: * Handle an input string by stripping the quotes and converting
337: * two interior quotes to one. Copy to newly allocated space and
338: * return a pointer to it.
339: *
340: * The handling of strings here is not particularly efficient,
341: * nor need it be.
342: */
343:
344: LOCAL char *pstring(p)
345: char *p;
346: {
347: int i, len;
348: char *r, *newp;
349:
350: len = strlen(p);
351: r = newp = alloc(len - 2 + 1, char);
352: for (i = 1; i < len - 1; i++) {
353: if (p[i] == '\'' && p[i+1] == '\'') {
354: i++;
355: }
356: *newp++ = p[i];
357: }
358: *newp = '\0';
359: return(r);
360: }
361:
362: /*
363: * prompt for a command
364: */
365:
366: prompt()
367: {
368: nlflag = FALSE;
369: if (yyin == stdin) {
370: printf("> ");
371: fflush(stdout);
372: }
373: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.