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