1 /*-
2 * SPDX-License-Identifier: MIT-CMU
3 *
4 * Mach Operating System
5 * Copyright (c) 1991,1990 Carnegie Mellon University
6 * All Rights Reserved.
7 *
8 * Permission to use, copy, modify and distribute this software and its
9 * documentation is hereby granted, provided that both the copyright
10 * notice and this permission notice appear in all copies of the
11 * software, derivative works or modified versions, and any portions
12 * thereof, and that both notices appear in supporting documentation.
13 *
14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
16 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17 *
18 * Carnegie Mellon requests users of this software to return to
19 *
20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
21 * School of Computer Science
22 * Carnegie Mellon University
23 * Pittsburgh PA 15213-3890
24 *
25 * any improvements or extensions that they make and grant Carnegie the
26 * rights to redistribute these changes.
27 */
28 /*
29 * Author: David B. Golub, Carnegie Mellon University
30 * Date: 7/90
31 */
32 /*
33 * Lexical analyzer.
34 */
35
36 #include <sys/cdefs.h>
37 #include <sys/param.h>
38 #include <sys/libkern.h>
39 #include <sys/lock.h>
40
41 #include <ddb/ddb.h>
42 #include <ddb/db_lex.h>
43
44 static char db_line[DB_MAXLINE];
45 static char * db_lp, *db_endlp;
46
47 static int db_lex(int);
48 static void db_flush_line(void);
49 static int db_read_char(void);
50 static void db_unread_char(int);
51
52 int
db_read_line(void)53 db_read_line(void)
54 {
55 int i;
56
57 i = db_readline(db_line, sizeof(db_line));
58 if (i == 0)
59 return (0); /* EOI */
60 db_lp = db_line;
61 db_endlp = db_lp + i;
62 return (i);
63 }
64
65 /*
66 * Simulate a line of input into DDB.
67 */
68 void
db_inject_line(const char * command)69 db_inject_line(const char *command)
70 {
71
72 strlcpy(db_line, command, sizeof(db_line));
73 db_lp = db_line;
74 db_endlp = db_lp + strlen(command);
75 }
76
77 /*
78 * In rare cases, we may want to pull the remainder of the line input
79 * verbatim, rather than lexing it. For example, when assigning literal
80 * values associated with scripts. In that case, return a static pointer to
81 * the current location in the input buffer. The caller must be aware that
82 * the contents are not stable if other lex/input calls are made.
83 */
84 char *
db_get_line(void)85 db_get_line(void)
86 {
87
88 return (db_lp);
89 }
90
91 static void
db_flush_line(void)92 db_flush_line(void)
93 {
94 db_lp = db_line;
95 db_endlp = db_line;
96 }
97
98 static int
db_read_char(void)99 db_read_char(void)
100 {
101 int c;
102
103 if (db_lp >= db_endlp)
104 c = -1;
105 else
106 c = *db_lp++;
107 return (c);
108 }
109
110 static void
db_unread_char(int c)111 db_unread_char(int c)
112 {
113
114 if (c == -1) {
115 /* Unread EOL at EOL is okay. */
116 if (db_lp < db_endlp)
117 db_error("db_unread_char(-1) before end of line\n");
118 } else {
119 if (db_lp > db_line) {
120 db_lp--;
121 if (*db_lp != c)
122 db_error("db_unread_char() wrong char\n");
123 } else {
124 db_error("db_unread_char() at beginning of line\n");
125 }
126 }
127 }
128
129 static int db_look_token = 0;
130
131 void
db_unread_token(int t)132 db_unread_token(int t)
133 {
134 db_look_token = t;
135 }
136
137 int
db_read_token_flags(int flags)138 db_read_token_flags(int flags)
139 {
140 int t;
141
142 MPASS((flags & ~(DRT_VALID_FLAGS_MASK)) == 0);
143
144 if (db_look_token) {
145 t = db_look_token;
146 db_look_token = 0;
147 }
148 else
149 t = db_lex(flags);
150 return (t);
151 }
152
153 db_expr_t db_tok_number;
154 char db_tok_string[TOK_STRING_SIZE];
155
156 db_expr_t db_radix = 16;
157
158 void
db_flush_lex(void)159 db_flush_lex(void)
160 {
161 db_flush_line();
162 db_look_token = 0;
163 }
164
165 static int
db_lex(int flags)166 db_lex(int flags)
167 {
168 int c, n, radix_mode;
169 bool lex_wspace, lex_hex_numbers;
170
171 switch (flags & DRT_RADIX_MASK) {
172 case DRT_DEFAULT_RADIX:
173 radix_mode = -1;
174 break;
175 case DRT_OCTAL:
176 radix_mode = 8;
177 break;
178 case DRT_DECIMAL:
179 radix_mode = 10;
180 break;
181 case DRT_HEXADECIMAL:
182 radix_mode = 16;
183 break;
184 }
185
186 lex_wspace = ((flags & DRT_WSPACE) != 0);
187 lex_hex_numbers = ((flags & DRT_HEX) != 0);
188
189 c = db_read_char();
190 for (n = 0; c <= ' ' || c > '~'; n++) {
191 if (c == '\n' || c == -1)
192 return (tEOL);
193 c = db_read_char();
194 }
195 if (lex_wspace && n != 0) {
196 db_unread_char(c);
197 return (tWSPACE);
198 }
199
200 if ((c >= '0' && c <= '9') ||
201 (lex_hex_numbers &&
202 ((c >= 'a' && c <= 'f') ||
203 (c >= 'A' && c <= 'F')))) {
204 /* number */
205 int r, digit = 0;
206
207 if (radix_mode != -1)
208 r = radix_mode;
209 else if (c != '0')
210 r = db_radix;
211 else {
212 c = db_read_char();
213 if (c == 'O' || c == 'o')
214 r = 8;
215 else if (c == 'T' || c == 't')
216 r = 10;
217 else if (c == 'X' || c == 'x')
218 r = 16;
219 else {
220 r = db_radix;
221 db_unread_char(c);
222 }
223 c = db_read_char();
224 }
225 db_tok_number = 0;
226 for (;;) {
227 if (c >= '0' && c <= ((r == 8) ? '7' : '9'))
228 digit = c - '0';
229 else if (r == 16 && ((c >= 'A' && c <= 'F') ||
230 (c >= 'a' && c <= 'f'))) {
231 if (c >= 'a')
232 digit = c - 'a' + 10;
233 else if (c >= 'A')
234 digit = c - 'A' + 10;
235 }
236 else
237 break;
238 db_tok_number = db_tok_number * r + digit;
239 c = db_read_char();
240 }
241 if ((c >= '0' && c <= '9') ||
242 (c >= 'A' && c <= 'Z') ||
243 (c >= 'a' && c <= 'z') ||
244 (c == '_'))
245 {
246 db_error("Bad character in number\n");
247 db_flush_lex();
248 return (tEOF);
249 }
250 db_unread_char(c);
251 return (tNUMBER);
252 }
253 if ((c >= 'A' && c <= 'Z') ||
254 (c >= 'a' && c <= 'z') ||
255 c == '_' || c == '\\')
256 {
257 /* string */
258 char *cp;
259
260 cp = db_tok_string;
261 if (c == '\\') {
262 c = db_read_char();
263 if (c == '\n' || c == -1)
264 db_error("Bad escape\n");
265 }
266 *cp++ = c;
267 while (1) {
268 c = db_read_char();
269 if ((c >= 'A' && c <= 'Z') ||
270 (c >= 'a' && c <= 'z') ||
271 (c >= '0' && c <= '9') ||
272 c == '_' || c == '\\' || c == ':' || c == '.')
273 {
274 if (c == '\\') {
275 c = db_read_char();
276 if (c == '\n' || c == -1)
277 db_error("Bad escape\n");
278 }
279 *cp++ = c;
280 if (cp == db_tok_string+sizeof(db_tok_string)) {
281 db_error("String too long\n");
282 db_flush_lex();
283 return (tEOF);
284 }
285 continue;
286 }
287 else {
288 *cp = '\0';
289 break;
290 }
291 }
292 db_unread_char(c);
293 return (tIDENT);
294 }
295
296 switch (c) {
297 case '+':
298 return (tPLUS);
299 case '-':
300 return (tMINUS);
301 case '.':
302 c = db_read_char();
303 if (c == '.')
304 return (tDOTDOT);
305 db_unread_char(c);
306 return (tDOT);
307 case '*':
308 return (tSTAR);
309 case '/':
310 return (tSLASH);
311 case '=':
312 c = db_read_char();
313 if (c == '=')
314 return (tLOG_EQ);
315 db_unread_char(c);
316 return (tEQ);
317 case '%':
318 return (tPCT);
319 case '#':
320 return (tHASH);
321 case '(':
322 return (tLPAREN);
323 case ')':
324 return (tRPAREN);
325 case ',':
326 return (tCOMMA);
327 case '"':
328 return (tDITTO);
329 case '$':
330 return (tDOLLAR);
331 case '!':
332 c = db_read_char();
333 if (c == '='){
334 return (tLOG_NOT_EQ);
335 }
336 db_unread_char(c);
337 return (tEXCL);
338 case ':':
339 c = db_read_char();
340 if (c == ':')
341 return (tCOLONCOLON);
342 db_unread_char(c);
343 return (tCOLON);
344 case ';':
345 return (tSEMI);
346 case '&':
347 c = db_read_char();
348 if (c == '&')
349 return (tLOG_AND);
350 db_unread_char(c);
351 return (tBIT_AND);
352 case '|':
353 c = db_read_char();
354 if (c == '|')
355 return (tLOG_OR);
356 db_unread_char(c);
357 return (tBIT_OR);
358 case '<':
359 c = db_read_char();
360 if (c == '<')
361 return (tSHIFT_L);
362 if (c == '=')
363 return (tLESS_EQ);
364 db_unread_char(c);
365 return (tLESS);
366 case '>':
367 c = db_read_char();
368 if (c == '>')
369 return (tSHIFT_R);
370 if (c == '=')
371 return (tGREATER_EQ);
372 db_unread_char(c);
373 return (tGREATER);
374 case '?':
375 return (tQUESTION);
376 case '~':
377 return (tBIT_NOT);
378 case -1:
379 return (tEOF);
380 }
381 db_printf("Bad character\n");
382 db_flush_lex();
383 return (tEOF);
384 }
385