![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / ddb|
Return to db_lex.c CVS log | Up to [GnuMach] / Gnu-Mach / ddb |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 7/90
29: */
30: #include "mach_kdb.h"
31: #if MACH_KDB
32:
33: /*
34: * Lexical analyzer.
35: */
36: #include <machine/db_machdep.h>
37: #include <kern/strings.h>
38: #include <ddb/db_lex.h>
39:
40: char db_line[DB_LEX_LINE_SIZE];
41: char db_last_line[DB_LEX_LINE_SIZE];
42: char *db_lp, *db_endlp;
43: char *db_last_lp;
44: int db_look_char = 0;
45: db_expr_t db_look_token = 0;
46:
47: int
48: db_read_line(repeat_last)
49: char *repeat_last;
50: {
51: int i;
52:
53: i = db_readline(db_line, sizeof(db_line));
54: if (i == 0)
55: return (0); /* EOI */
56: if (repeat_last) {
57: if (strncmp(db_line, repeat_last, strlen(repeat_last)) == 0) {
58: db_strcpy(db_line, db_last_line);
59: db_printf("%s", db_line);
60: i = strlen(db_line);
61: } else if (db_line[0] != '\n' && db_line[0] != 0)
62: db_strcpy(db_last_line, db_line);
63: }
64: db_lp = db_line;
65: db_endlp = db_lp + i;
66: db_last_lp = db_lp;
67: db_look_char = 0;
68: db_look_token = 0;
69: return (i);
70: }
71:
72: void
73: db_flush_line()
74: {
75: db_lp = db_line;
76: db_last_lp = db_lp;
77: db_endlp = db_line;
78: }
79:
80: void
81: db_switch_input(buffer, size)
82: char *buffer;
83: int size;
84: {
85: db_lp = buffer;
86: db_last_lp = db_lp;
87: db_endlp = buffer + size;
88: db_look_char = 0;
89: db_look_token = 0;
90: }
91:
92: void
93: db_save_lex_context(lp)
94: register struct db_lex_context *lp;
95: {
96: lp->l_ptr = db_lp;
97: lp->l_eptr = db_endlp;
98: lp->l_char = db_look_char;
99: lp->l_token = db_look_token;
100: }
101:
102: void
103: db_restore_lex_context(lp)
104: register struct db_lex_context *lp;
105: {
106: db_lp = lp->l_ptr;
107: db_last_lp = db_lp;
108: db_endlp = lp->l_eptr;
109: db_look_char = lp->l_char;
110: db_look_token = lp->l_token;
111: }
112:
113: int
114: db_read_char()
115: {
116: int c;
117:
118: if (db_look_char != 0) {
119: c = db_look_char;
120: db_look_char = 0;
121: }
122: else if (db_lp >= db_endlp)
123: c = -1;
124: else
125: c = *db_lp++;
126: return (c);
127: }
128:
129: void
130: db_unread_char(c)
131: int c;
132: {
133: db_look_char = c;
134: }
135:
136: void
137: db_unread_token(t)
138: int t;
139: {
140: db_look_token = t;
141: }
142:
143: int
144: db_read_token()
145: {
146: int t;
147:
148: if (db_look_token) {
149: t = db_look_token;
150: db_look_token = 0;
151: }
152: else {
153: db_last_lp = db_lp;
154: if (db_look_char)
155: db_last_lp--;
156: t = db_lex();
157: }
158: return (t);
159: }
160:
161: db_expr_t db_tok_number;
162: char db_tok_string[TOK_STRING_SIZE];
163: db_expr_t db_radix = 16;
164:
165: void
166: db_flush_lex()
167: {
168: db_flush_line();
169: db_look_char = 0;
170: db_look_token = 0;
171: }
172:
173: #define DB_DISP_SKIP 40 /* number of chars to display skip */
174:
175: void
176: db_skip_to_eol()
177: {
178: register skip;
179: register t;
180: register n;
181: register char *p;
182:
183: t = db_read_token();
184: p = db_last_lp;
185: for (skip = 0; t != tEOL && t != tSEMI_COLON && t != tEOF; skip++)
186: t = db_read_token();
187: if (t == tSEMI_COLON)
188: db_unread_token(t);
189: if (skip != 0) {
190: while (p < db_last_lp && (*p == ' ' || *p == '\t'))
191: p++;
192: db_printf("Warning: Skipped input data \"");
193: for (n = 0; n < DB_DISP_SKIP && p < db_last_lp; n++)
194: db_printf("%c", *p++);
195: if (n >= DB_DISP_SKIP)
196: db_printf("....");
197: db_printf("\"\n");
198: }
199: }
200:
201: int
202: db_lex()
203: {
204: register char *cp;
205: register c;
206:
207: c = db_read_char();
208: while (c <= ' ' || c > '~') {
209: if (c == '\n' || c == -1)
210: return (tEOL);
211: c = db_read_char();
212: }
213:
214: cp = db_tok_string;
215: *cp++ = c;
216:
217: if (c >= '0' && c <= '9') {
218: /* number */
219: int r, digit;
220:
221: if (c > '0')
222: r = db_radix;
223: else {
224: c = db_read_char();
225: if (c == 'O' || c == 'o')
226: r = 8;
227: else if (c == 'T' || c == 't')
228: r = 10;
229: else if (c == 'X' || c == 'x')
230: r = 16;
231: else {
232: cp--;
233: r = db_radix;
234: db_unread_char(c);
235: }
236: c = db_read_char();
237: *cp++ = c;
238: }
239: db_tok_number = 0;
240: for (;;) {
241: if (c >= '0' && c <= ((r == 8) ? '7' : '9'))
242: digit = c - '0';
243: else if (r == 16 && ((c >= 'A' && c <= 'F') ||
244: (c >= 'a' && c <= 'f'))) {
245: if (c >= 'a')
246: digit = c - 'a' + 10;
247: else
248: digit = c - 'A' + 10;
249: }
250: else
251: break;
252: db_tok_number = db_tok_number * r + digit;
253: c = db_read_char();
254: if (cp < &db_tok_string[sizeof(db_tok_string)-1])
255: *cp++ = c;
256: }
257: cp[-1] = 0;
258: if ((c >= '0' && c <= '9') ||
259: (c >= 'A' && c <= 'Z') ||
260: (c >= 'a' && c <= 'z') ||
261: (c == '_'))
262: {
263: db_printf("Bad character '%c' after number %s\n",
264: c, db_tok_string);
265: db_error(0);
266: db_flush_lex();
267: return (tEOF);
268: }
269: db_unread_char(c);
270: return (tNUMBER);
271: }
272: if ((c >= 'A' && c <= 'Z') ||
273: (c >= 'a' && c <= 'z') ||
274: c == '_' || c == '\\' || c == ':')
275: {
276: /* identifier */
277: if (c == '\\') {
278: c = db_read_char();
279: if (c == '\n' || c == -1)
280: db_error("Bad '\\' at the end of line\n");
281: cp[-1] = c;
282: }
283: while (1) {
284: c = db_read_char();
285: if ((c >= 'A' && c <= 'Z') ||
286: (c >= 'a' && c <= 'z') ||
287: (c >= '0' && c <= '9') ||
288: c == '_' || c == '\\' || c == ':' || c == '.')
289: {
290: if (c == '\\') {
291: c = db_read_char();
292: if (c == '\n' || c == -1)
293: db_error("Bad '\\' at the end of line\n");
294: }
295: *cp++ = c;
296: if (cp == db_tok_string+sizeof(db_tok_string)) {
297: db_error("String too long\n");
298: db_flush_lex();
299: return (tEOF);
300: }
301: continue;
302: }
303: else {
304: *cp = '\0';
305: break;
306: }
307: }
308: db_unread_char(c);
309: return (tIDENT);
310: }
311:
312: *cp = 0;
313: switch (c) {
314: case '+':
315: return (tPLUS);
316: case '-':
317: return (tMINUS);
318: case '.':
319: c = db_read_char();
320: if (c == '.') {
321: *cp++ = c;
322: *cp = 0;
323: return (tDOTDOT);
324: }
325: db_unread_char(c);
326: return (tDOT);
327: case '*':
328: return (tSTAR);
329: case '/':
330: return (tSLASH);
331: case '=':
332: c = db_read_char();
333: if (c == '=') {
334: *cp++ = c;
335: *cp = 0;
336: return(tLOG_EQ);
337: }
338: db_unread_char(c);
339: return (tEQ);
340: case '%':
341: return (tPCT);
342: case '#':
343: return (tHASH);
344: case '(':
345: return (tLPAREN);
346: case ')':
347: return (tRPAREN);
348: case ',':
349: return (tCOMMA);
350: case '\'':
351: return (tQUOTE);
352: case '"':
353: /* string */
354: cp = db_tok_string;
355: c = db_read_char();
356: while (c != '"' && c > 0 && c != '\n') {
357: if (cp >= &db_tok_string[sizeof(db_tok_string)-1]) {
358: db_error("Too long string\n");
359: db_flush_lex();
360: return (tEOF);
361: }
362: if (c == '\\') {
363: c = db_read_char();
364: switch(c) {
365: case 'n':
366: c = '\n'; break;
367: case 't':
368: c = '\t'; break;
369: case '\\':
370: case '"':
371: break;
372: default:
373: db_printf("Bad escape sequence '\\%c'\n", c);
374: db_error(0);
375: db_flush_lex();
376: return (tEOF);
377: }
378: }
379: *cp++ = c;
380: c = db_read_char();
381: }
382: *cp = 0;
383: if (c != '"') {
384: db_error("Non terminated string constant\n");
385: db_flush_lex();
386: return (tEOF);
387: }
388: return (tSTRING);
389: case '$':
390: return (tDOLLAR);
391: case '!':
392: c = db_read_char();
393: if (c == '=') {
394: *cp++ = c;
395: *cp = 0;
396: return(tLOG_NOT_EQ);
397: }
398: db_unread_char(c);
399: return (tEXCL);
400: case '&':
401: c = db_read_char();
402: if (c == '&') {
403: *cp++ = c;
404: *cp = 0;
405: return(tLOG_AND);
406: }
407: db_unread_char(c);
408: return(tBIT_AND);
409: case '|':
410: c = db_read_char();
411: if (c == '|') {
412: *cp++ = c;
413: *cp = 0;
414: return(tLOG_OR);
415: }
416: db_unread_char(c);
417: return(tBIT_OR);
418: case '<':
419: c = db_read_char();
420: *cp++ = c;
421: *cp = 0;
422: if (c == '<')
423: return (tSHIFT_L);
424: if (c == '=')
425: return (tLESS_EQ);
426: cp[-1] = 0;
427: db_unread_char(c);
428: return(tLESS);
429: break;
430: case '>':
431: c = db_read_char();
432: *cp++ = c;
433: *cp = 0;
434: if (c == '>')
435: return (tSHIFT_R);
436: if (c == '=')
437: return (tGREATER_EQ);
438: cp[-1] = 0;
439: db_unread_char(c);
440: return (tGREATER);
441: break;
442: case ';':
443: return (tSEMI_COLON);
444: case '?':
445: return (tQUESTION);
446: case -1:
447: db_strcpy(db_tok_string, "<EOL>");
448: return (tEOF);
449: }
450: db_printf("Bad character '%c'\n", c);
451: db_flush_lex();
452: return (tEOF);
453: }
454:
455: #endif MACH_KDB
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.