![[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 [Apple XNU] / XNU / osfmk / ddb|
Return to db_lex.c CVS log | Up to [Apple XNU] / XNU / osfmk / ddb |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * HISTORY
27: *
28: * Revision 1.1.1.1 1998/09/22 21:05:48 wsanchez
29: * Import of Mac OS X kernel (~semeria)
30: *
31: * Revision 1.1.1.1 1998/03/07 02:26:09 wsanchez
32: * Import of OSF Mach kernel (~mburg)
33: *
34: * Revision 1.1.11.3 1996/01/09 19:15:49 devrcs
35: * Change 'register foo' to 'register int foo'.
36: * [1995/12/01 21:42:12 jfraser]
37: *
38: * Merged '64-bit safe' changes from DEC alpha port.
39: * [1995/11/21 18:03:11 jfraser]
40: *
41: * Revision 1.1.11.2 1995/01/06 19:10:21 devrcs
42: * mk6 CR668 - 1.3b26 merge
43: * * Revision 1.1.4.6 1994/05/06 18:39:20 tmt
44: * Merged osc1.3dec/shared with osc1.3b19
45: * Merge Alpha changes into osc1.312b source code.
46: * String protos.
47: * 64bit cleanup.
48: * Cleanup to quiet gcc warnings.
49: * * End1.3merge
50: * [1994/11/04 08:49:35 dwm]
51: *
52: * Revision 1.1.11.1 1994/09/23 01:19:59 ezf
53: * change marker to not FREE
54: * [1994/09/22 21:10:14 ezf]
55: *
56: * Revision 1.1.4.4 1993/08/11 20:37:55 elliston
57: * Add ANSI Prototypes. CR #9523.
58: * [1993/08/11 03:33:26 elliston]
59: *
60: * Revision 1.1.4.3 1993/07/27 18:27:38 elliston
61: * Add ANSI prototypes. CR #9523.
62: * [1993/07/27 18:12:13 elliston]
63: *
64: * Revision 1.1.4.2 1993/06/02 23:11:27 jeffc
65: * Added to OSF/1 R1.3 from NMK15.0.
66: * [1993/06/02 20:56:32 jeffc]
67: *
68: * Revision 1.1 1992/09/30 02:01:10 robert
69: * Initial revision
70: *
71: * $EndLog$
72: */
73: /* CMU_HIST */
74: /*
75: * Revision 2.5 91/10/09 16:00:20 af
76: * Revision 2.4.3.1 91/10/05 13:06:25 jeffreyh
77: * Added relational operator tokens and string constant etc.
78: * Added input switching functions for macro and conditional command.
79: * Moved skip_to_eol() from db_command.c and added db_last_lp to print
80: * skipped input data as a warning message.
81: * Added last input repetition support to db_read_line.
82: * Changed db_lex() to always set db_tok_string for error message.
83: * [91/08/29 tak]
84: *
85: * Revision 2.4.3.1 91/10/05 13:06:25 jeffreyh
86: * Added relational operator tokens and string constant etc.
87: * Added input switching functions for macro and conditional command.
88: * Moved skip_to_eol() from db_command.c and added db_last_lp to print
89: * skipped input data as a warning message.
90: * Added last input repetition support to db_read_line.
91: * Changed db_lex() to always set db_tok_string for error message.
92: * [91/08/29 tak]
93: *
94: * Revision 2.4 91/05/14 15:34:23 mrt
95: * Correcting copyright
96: *
97: * Revision 2.3 91/02/05 17:06:36 mrt
98: * Changed to new Mach copyright
99: * [91/01/31 16:18:20 mrt]
100: *
101: * Revision 2.2 90/08/27 21:51:10 dbg
102: * Add 'dotdot' token.
103: * [90/08/22 dbg]
104: *
105: * Allow backslash to quote any character into an identifier.
106: * Allow colon in identifier for symbol table qualification.
107: * [90/08/16 dbg]
108: * Reduce lint.
109: * [90/08/07 dbg]
110: * Created.
111: * [90/07/25 dbg]
112: *
113: */
114: /* CMU_ENDHIST */
115: /*
116: * Mach Operating System
117: * Copyright (c) 1991,1990 Carnegie Mellon University
118: * All Rights Reserved.
119: *
120: * Permission to use, copy, modify and distribute this software and its
121: * documentation is hereby granted, provided that both the copyright
122: * notice and this permission notice appear in all copies of the
123: * software, derivative works or modified versions, and any portions
124: * thereof, and that both notices appear in supporting documentation.
125: *
126: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
127: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
128: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
129: *
130: * Carnegie Mellon requests users of this software to return to
131: *
132: * Software Distribution Coordinator or [email protected]
133: * School of Computer Science
134: * Carnegie Mellon University
135: * Pittsburgh PA 15213-3890
136: *
137: * any improvements or extensions that they make and grant Carnegie Mellon
138: * the rights to redistribute these changes.
139: */
140: /*
141: */
142: /*
143: * Author: David B. Golub, Carnegie Mellon University
144: * Date: 7/90
145: */
146: /*
147: * Lexical analyzer.
148: */
149: #include <string.h> /* For strcpy(), strncmp(), strlen() */
150: #include <ddb/db_lex.h>
151: #include <ddb/db_command.h>
152: #include <ddb/db_input.h>
153: #include <ddb/db_output.h> /* For db_printf() */
154:
155: char db_line[DB_LEX_LINE_SIZE];
156: char db_last_line[DB_LEX_LINE_SIZE];
157: char *db_lp, *db_endlp;
158: char *db_last_lp;
159: int db_look_char = 0;
160: db_expr_t db_look_token = 0;
161:
162:
163: /* Prototypes for functions local to this file. XXX -- should be static!
164: */
165: void db_flush_line(void);
166: void db_unread_char(int c);
167:
168:
169: int
170: db_read_line(char *repeat_last)
171: {
172: int i;
173:
174: i = db_readline(db_line, sizeof(db_line));
175: if (i == 0)
176: return (0); /* EOI */
177: if (repeat_last) {
178: if (strncmp(db_line, repeat_last, strlen(repeat_last)) == 0) {
179: strcpy(db_line, db_last_line);
180: db_printf("%s", db_line);
181: i = strlen(db_line);
182: } else if (db_line[0] != '\n' && db_line[0] != 0)
183: strcpy(db_last_line, db_line);
184: }
185: db_lp = db_line;
186: db_endlp = db_lp + i;
187: db_last_lp = db_lp;
188: db_look_char = 0;
189: db_look_token = 0;
190: return (i);
191: }
192:
193: void
194: db_flush_line(void)
195: {
196: db_lp = db_line;
197: db_last_lp = db_lp;
198: db_endlp = db_line;
199: }
200:
201: void
202: db_switch_input(
203: char *buffer,
204: int size)
205: {
206: db_lp = buffer;
207: db_last_lp = db_lp;
208: db_endlp = buffer + size;
209: db_look_char = 0;
210: db_look_token = 0;
211: }
212:
213: void
214: db_save_lex_context(register struct db_lex_context *lp)
215: {
216: lp->l_ptr = db_lp;
217: lp->l_eptr = db_endlp;
218: lp->l_char = db_look_char;
219: lp->l_token = db_look_token;
220: }
221:
222: void
223: db_restore_lex_context(register struct db_lex_context *lp)
224: {
225: db_lp = lp->l_ptr;
226: db_last_lp = db_lp;
227: db_endlp = lp->l_eptr;
228: db_look_char = lp->l_char;
229: db_look_token = lp->l_token;
230: }
231:
232: int
233: db_read_char(void)
234: {
235: int c;
236:
237: if (db_look_char != 0) {
238: c = db_look_char;
239: db_look_char = 0;
240: }
241: else if (db_lp >= db_endlp)
242: c = -1;
243: else
244: c = *db_lp++;
245: return (c);
246: }
247:
248: void
249: db_unread_char(int c)
250: {
251: db_look_char = c;
252: }
253:
254: void
255: db_unread_token(int t)
256: {
257: db_look_token = t;
258: }
259:
260: int
261: db_read_token(void)
262: {
263: int t;
264:
265: if (db_look_token) {
266: t = db_look_token;
267: db_look_token = 0;
268: }
269: else {
270: db_last_lp = db_lp;
271: if (db_look_char)
272: db_last_lp--;
273: t = db_lex();
274: }
275: return (t);
276: }
277:
278: db_expr_t db_tok_number;
279: char db_tok_string[TOK_STRING_SIZE];
280:
281: db_expr_t db_radix = 16;
282:
283: void
284: db_flush_lex(void)
285: {
286: db_flush_line();
287: db_look_char = 0;
288: db_look_token = 0;
289: }
290:
291: #define DB_DISP_SKIP 40 /* number of chars to display skip */
292:
293: void
294: db_skip_to_eol(void)
295: {
296: register int skip;
297: register int t;
298: register int n;
299: register char *p;
300:
301: t = db_read_token();
302: p = db_last_lp;
303: for (skip = 0; t != tEOL && t != tSEMI_COLON && t != tEOF; skip++)
304: t = db_read_token();
305: if (t == tSEMI_COLON)
306: db_unread_token(t);
307: if (skip != 0) {
308: while (p < db_last_lp && (*p == ' ' || *p == '\t'))
309: p++;
310: db_printf("Warning: Skipped input data \"");
311: for (n = 0; n < DB_DISP_SKIP && p < db_last_lp; n++)
312: db_printf("%c", *p++);
313: if (n >= DB_DISP_SKIP)
314: db_printf("....");
315: db_printf("\"\n");
316: }
317: }
318:
319: int
320: db_lex(void)
321: {
322: register char *cp;
323: register int c;
324:
325: c = db_read_char();
326: while (c <= ' ' || c > '~') {
327: if (c == '\n' || c == -1)
328: return (tEOL);
329: c = db_read_char();
330: }
331:
332: cp = db_tok_string;
333: *cp++ = c;
334:
335: if (c >= '0' && c <= '9') {
336: /* number */
337: int r, digit;
338:
339: if (c > '0')
340: r = db_radix;
341: else {
342: c = db_read_char();
343: if (c == 'O' || c == 'o')
344: r = 8;
345: else if (c == 'T' || c == 't')
346: r = 10;
347: else if (c == 'X' || c == 'x')
348: r = 16;
349: else {
350: cp--;
351: r = db_radix;
352: db_unread_char(c);
353: }
354: c = db_read_char();
355: *cp++ = c;
356: }
357: db_tok_number = 0;
358: for (;;) {
359: if (c >= '0' && c <= ((r == 8) ? '7' : '9'))
360: digit = c - '0';
361: else if (r == 16 && ((c >= 'A' && c <= 'F') ||
362: (c >= 'a' && c <= 'f'))) {
363: if (c >= 'a')
364: digit = c - 'a' + 10;
365: else
366: digit = c - 'A' + 10;
367: }
368: else
369: break;
370: db_tok_number = db_tok_number * r + digit;
371: c = db_read_char();
372: if (cp < &db_tok_string[sizeof(db_tok_string)-1])
373: *cp++ = c;
374: }
375: cp[-1] = 0;
376: if ((c >= '0' && c <= '9') ||
377: (c >= 'A' && c <= 'Z') ||
378: (c >= 'a' && c <= 'z') ||
379: (c == '_'))
380: {
381: db_printf("Bad character '%c' after number %s\n",
382: c, db_tok_string);
383: db_error(0);
384: db_flush_lex();
385: return (tEOF);
386: }
387: db_unread_char(c);
388: return (tNUMBER);
389: }
390: if ((c >= 'A' && c <= 'Z') ||
391: (c >= 'a' && c <= 'z') ||
392: c == '_' || c == '\\' || c == ':')
393: {
394: /* identifier */
395: if (c == '\\') {
396: c = db_read_char();
397: if (c == '\n' || c == -1)
398: db_error("Bad '\\' at the end of line\n");
399: cp[-1] = c;
400: }
401: while (1) {
402: c = db_read_char();
403: if ((c >= 'A' && c <= 'Z') ||
404: (c >= 'a' && c <= 'z') ||
405: (c >= '0' && c <= '9') ||
406: c == '_' || c == '\\' || c == ':' || c == '.')
407: {
408: if (c == '\\') {
409: c = db_read_char();
410: if (c == '\n' || c == -1)
411: db_error("Bad '\\' at the end of line\n");
412: }
413: *cp++ = c;
414: if (cp == db_tok_string+sizeof(db_tok_string)) {
415: db_error("String too long\n");
416: db_flush_lex();
417: return (tEOF);
418: }
419: continue;
420: }
421: else {
422: *cp = '\0';
423: break;
424: }
425: }
426: db_unread_char(c);
427: return (tIDENT);
428: }
429:
430: *cp = 0;
431: switch (c) {
432: case '+':
433: return (tPLUS);
434: case '-':
435: return (tMINUS);
436: case '.':
437: c = db_read_char();
438: if (c == '.') {
439: *cp++ = c;
440: *cp = 0;
441: return (tDOTDOT);
442: }
443: db_unread_char(c);
444: return (tDOT);
445: case '*':
446: return (tSTAR);
447: case '/':
448: return (tSLASH);
449: case '=':
450: c = db_read_char();
451: if (c == '=') {
452: *cp++ = c;
453: *cp = 0;
454: return(tLOG_EQ);
455: }
456: db_unread_char(c);
457: return (tEQ);
458: case '%':
459: return (tPCT);
460: case '#':
461: return (tHASH);
462: case '(':
463: return (tLPAREN);
464: case ')':
465: return (tRPAREN);
466: case ',':
467: return (tCOMMA);
468: case '\'':
469: return (tQUOTE);
470: case '"':
471: /* string */
472: cp = db_tok_string;
473: c = db_read_char();
474: while (c != '"' && c > 0 && c != '\n') {
475: if (cp >= &db_tok_string[sizeof(db_tok_string)-1]) {
476: db_error("Too long string\n");
477: db_flush_lex();
478: return (tEOF);
479: }
480: if (c == '\\') {
481: c = db_read_char();
482: switch(c) {
483: case 'n':
484: c = '\n'; break;
485: case 't':
486: c = '\t'; break;
487: case '\\':
488: case '"':
489: break;
490: default:
491: db_printf("Bad escape sequence '\\%c'\n", c);
492: db_error(0);
493: db_flush_lex();
494: return (tEOF);
495: }
496: }
497: *cp++ = c;
498: c = db_read_char();
499: }
500: *cp = 0;
501: if (c != '"') {
502: db_error("Non terminated string constant\n");
503: db_flush_lex();
504: return (tEOF);
505: }
506: return (tSTRING);
507: case '$':
508: return (tDOLLAR);
509: case '!':
510: c = db_read_char();
511: if (c == '=') {
512: *cp++ = c;
513: *cp = 0;
514: return(tLOG_NOT_EQ);
515: }
516: db_unread_char(c);
517: return (tEXCL);
518: case '&':
519: c = db_read_char();
520: if (c == '&') {
521: *cp++ = c;
522: *cp = 0;
523: return(tLOG_AND);
524: }
525: db_unread_char(c);
526: return(tBIT_AND);
527: case '|':
528: c = db_read_char();
529: if (c == '|') {
530: *cp++ = c;
531: *cp = 0;
532: return(tLOG_OR);
533: }
534: db_unread_char(c);
535: return(tBIT_OR);
536: case '<':
537: c = db_read_char();
538: *cp++ = c;
539: *cp = 0;
540: if (c == '<')
541: return (tSHIFT_L);
542: if (c == '=')
543: return (tLESS_EQ);
544: cp[-1] = 0;
545: db_unread_char(c);
546: return(tLESS);
547: break;
548: case '>':
549: c = db_read_char();
550: *cp++ = c;
551: *cp = 0;
552: if (c == '>')
553: return (tSHIFT_R);
554: if (c == '=')
555: return (tGREATER_EQ);
556: cp[-1] = 0;
557: db_unread_char(c);
558: return (tGREATER);
559: break;
560: case ';':
561: return (tSEMI_COLON);
562: case '?':
563: return (tQUESTION);
564: case -1:
565: strcpy(db_tok_string, "<EOL>");
566: return (tEOF);
567: }
568: db_printf("Bad character '%c'\n", c);
569: db_flush_lex();
570: return (tEOF);
571: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.