1.0.4.61: stack-alignment on CALL-OUT VOP on x86/Darwin
[sbcl.git] / src / runtime / parse.c
1 /* parsing for LDB monitor */
2
3 /*
4  * This software is part of the SBCL system. See the README file for
5  * more information.
6  *
7  * This software is derived from the CMU CL system, which was
8  * written at Carnegie Mellon University and released into the
9  * public domain. The software is in the public domain and is
10  * provided with absolutely no warranty. See the COPYING and CREDITS
11  * files for more information.
12  */
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <ctype.h>
17 #include <signal.h>
18
19 #include "sbcl.h"
20 #include "runtime.h"
21
22 #if defined(LISP_FEATURE_SB_LDB)
23
24 #include "globals.h"
25 #include "vars.h"
26 #include "parse.h"
27 #include "os.h"
28 #include "interrupt.h"
29 #include "lispregs.h"
30 #include "monitor.h"
31 #include "validate.h"
32 #include "arch.h"
33 #include "search.h"
34 #include "thread.h"
35
36 #include "genesis/simple-fun.h"
37 #include "genesis/fdefn.h"
38 #include "genesis/symbol.h"
39 #include "genesis/static-symbols.h"
40
41 static void skip_ws(char **ptr)
42 {
43     while (**ptr <= ' ' && **ptr != '\0')
44         (*ptr)++;
45 }
46
47 static boolean string_to_long(char *token, long *value)
48 {
49     int base, digit;
50     long num;
51     char *ptr;
52
53     if (token == 0)
54         return 0;
55
56     if (token[0] == '0')
57         if (token[1] == 'x') {
58             base = 16;
59             token += 2;
60         }
61         else {
62             base = 8;
63             token++;
64         }
65     else if (token[0] == '#') {
66         switch (token[1]) {
67             case 'x':
68             case 'X':
69                 base = 16;
70                 token += 2;
71                 break;
72             case 'o':
73             case 'O':
74                 base = 8;
75                 token += 2;
76                 break;
77             default:
78                 return 0;
79         }
80     }
81     else
82         base = 10;
83
84     num = 0;
85     ptr = token;
86     while (*ptr != '\0') {
87         if (*ptr >= 'a' && *ptr <= 'f')
88             digit = *ptr + 10 - 'a';
89         else if (*ptr >= 'A' && *ptr <= 'F')
90             digit = *ptr + 10 - 'A';
91         else if (*ptr >= '0' && *ptr <= '9')
92             digit = *ptr - '0';
93         else
94             return 0;
95         if (digit < 0 || digit >= base)
96             return 0;
97
98         ptr++;
99         num = num * base + digit;
100     }
101
102     *value = num;
103     return 1;
104 }
105
106 static boolean lookup_variable(char *name, lispobj *result)
107 {
108     struct var *var = lookup_by_name(name);
109
110     if (var == NULL)
111         return 0;
112     else {
113         *result = var_value(var);
114         return 1;
115     }
116 }
117
118
119 boolean more_p(ptr)
120 char **ptr;
121 {
122     skip_ws(ptr);
123
124     if (**ptr == '\0')
125         return 0;
126     else
127         return 1;
128 }
129
130 char *parse_token(ptr)
131 char **ptr;
132 {
133     char *token;
134
135     skip_ws(ptr);
136
137     if (**ptr == '\0')
138         return NULL;
139
140     token = *ptr;
141
142     while (**ptr > ' ')
143         (*ptr)++;
144
145     if (**ptr != '\0') {
146         **ptr = '\0';
147         (*ptr)++;
148     }
149
150     return token;
151 }
152
153 #if 0
154 static boolean number_p(token)
155 char *token;
156 {
157     char *okay;
158
159     if (token == NULL)
160         return 0;
161
162     okay = "abcdefABCDEF987654321d0";
163
164     if (token[0] == '0')
165         if (token[1] == 'x' || token[1] == 'X')
166             token += 2;
167         else {
168             token++;
169             okay += 14;
170         }
171     else if (token[0] == '#') {
172         switch (token[1]) {
173             case 'x':
174             case 'X':
175                 break;
176             case 'o':
177             case 'O':
178                 okay += 14;
179                 break;
180             default:
181                 return 0;
182         }
183     }
184     else
185         okay += 12;
186
187     while (*token != '\0')
188         if (index(okay, *token++) == NULL)
189             return 0;
190     return 1;
191 }
192 #endif
193
194 long parse_number(ptr)
195 char **ptr;
196 {
197     char *token = parse_token(ptr);
198     long result;
199
200     if (token == NULL) {
201         printf("expected a number\n");
202         throw_to_monitor();
203     }
204     else if (string_to_long(token, &result))
205         return result;
206     else {
207         printf("invalid number: ``%s''\n", token);
208         throw_to_monitor();
209     }
210     return 0;
211 }
212
213 char *parse_addr(ptr)
214 char **ptr;
215 {
216     char *token = parse_token(ptr);
217     lispobj result;
218
219     if (token == NULL) {
220         printf("expected an address\n");
221         throw_to_monitor();
222     }
223     else if (token[0] == '$') {
224         if (!lookup_variable(token+1, &result)) {
225             printf("unknown variable: ``%s''\n", token);
226             throw_to_monitor();
227         }
228         result &= ~7;
229     }
230     else {
231         long value;
232         if (!string_to_long(token, &value)) {
233             printf("invalid number: ``%s''\n", token);
234             throw_to_monitor();
235         }
236         result = (value & ~3);
237     }
238
239     if (!is_valid_lisp_addr((os_vm_address_t)result)) {
240         printf("invalid Lisp-level address: %p\n", (void *)result);
241         throw_to_monitor();
242     }
243
244     return (char *)result;
245 }
246
247 static boolean lookup_symbol(char *name, lispobj *result)
248 {
249     int count;
250     lispobj *headerptr;
251
252     /* Search static space. */
253     headerptr = (lispobj *)STATIC_SPACE_START;
254     count =
255         (lispobj *)SymbolValue(STATIC_SPACE_FREE_POINTER,0) -
256         (lispobj *)STATIC_SPACE_START;
257     if (search_for_symbol(name, &headerptr, &count)) {
258         *result = make_lispobj(headerptr,OTHER_POINTER_LOWTAG);
259         return 1;
260     }
261
262     /* Search dynamic space. */
263 #if defined(LISP_FEATURE_GENCGC)
264     headerptr = (lispobj *)DYNAMIC_SPACE_START;
265     count = (lispobj *)get_alloc_pointer() - headerptr;
266 #else
267     headerptr = (lispobj *)current_dynamic_space;
268     count = dynamic_space_free_pointer - headerptr;
269 #endif
270
271     if (search_for_symbol(name, &headerptr, &count)) {
272         *result = make_lispobj(headerptr, OTHER_POINTER_LOWTAG);
273         return 1;
274     }
275
276     return 0;
277 }
278
279 static int
280 parse_regnum(char *s)
281 {
282     if ((s[1] == 'R') || (s[1] == 'r')) {
283         int regnum;
284
285         if (s[2] == '\0')
286             return -1;
287
288         /* skip the $R part and call atoi on the number */
289         regnum = atoi(s + 2);
290         if ((regnum >= 0) && (regnum < NREGS))
291             return regnum;
292         else
293             return -1;
294     } else {
295         int i;
296
297         for (i = 0; i < NREGS ; i++)
298             if (strcasecmp(s + 1, lisp_register_names[i]) == 0)
299 #ifdef LISP_FEATURE_X86
300                 return i*2;
301 #else
302         return i;
303 #endif
304
305         return -1;
306     }
307 }
308
309 lispobj parse_lispobj(ptr)
310 char **ptr;
311 {
312     struct thread *thread=arch_os_get_current_thread();
313     char *token = parse_token(ptr);
314     long pointer;
315     lispobj result;
316     long value;
317
318     if (token == NULL) {
319         printf("expected an object\n");
320         throw_to_monitor();
321     } else if (token[0] == '$') {
322         if (isalpha(token[1])) {
323             int free_ici;
324             int regnum;
325             os_context_t *context;
326
327             free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread));
328
329             if (free_ici == 0) {
330                 printf("Variable ``%s'' is not valid -- there is no current interrupt context.\n", token);
331                 throw_to_monitor();
332             }
333
334             context = thread->interrupt_contexts[free_ici - 1];
335
336             regnum = parse_regnum(token);
337             if (regnum < 0) {
338                 printf("bogus register: ``%s''\n", token);
339                 throw_to_monitor();
340             }
341
342             result = *os_context_register_addr(context, regnum);
343         } else if (!lookup_variable(token+1, &result)) {
344             printf("unknown variable: ``%s''\n", token);
345             throw_to_monitor();
346         }
347     } else if (token[0] == '@') {
348         if (string_to_long(token+1, &pointer)) {
349             pointer &= ~3;
350             if (is_valid_lisp_addr((os_vm_address_t)pointer))
351                 result = *(lispobj *)pointer;
352             else {
353                 printf("invalid Lisp-level address: ``%s''\n", token+1);
354                 throw_to_monitor();
355             }
356         }
357         else {
358             printf("invalid address: ``%s''\n", token+1);
359             throw_to_monitor();
360         }
361     }
362     else if (string_to_long(token, &value))
363         result = value;
364     else if (lookup_symbol(token, &result))
365         ;
366     else {
367         printf("invalid Lisp object: ``%s''\n", token);
368         throw_to_monitor();
369     }
370
371     return result;
372 }
373
374 #endif /* defined(LISP_FEATURE_SB_LDB) */