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(char **ptr)
 125 {
 126     skip_ws(ptr);
 127
 128     if (**ptr == '\0')
 129         return 0;
 130     else
 131         return 1;
 132 }
 133
 134 char *parse_token(char **ptr)
 135 {
 136     char *token;
 137
 138     skip_ws(ptr);
 139
 140     if (**ptr == '\0')
 141         return NULL;
 142
 143     token = *ptr;
 144
 145     while (**ptr > ' ')
 146         (*ptr)++;
 147
 148     if (**ptr != '\0') {
 149         **ptr = '\0';
 150         (*ptr)++;
 151     }
 152
 153     return token;
 154 }
 155
 156 uword_t parse_number(char **ptr)
 157 {
 158     char *token = parse_token(ptr);
 159     uword_t result;
 160
 161     if (token == NULL) {
 162         printf("expected a number\n");
 163         throw_to_monitor();
 164     }
 165     else if (string_to_long(token, &result))
 166         return result;
 167     else {
 168         printf("invalid number: ``%s''\n", token);
 169         throw_to_monitor();
 170     }
 171     return 0;
 172 }
 173
 174 char *parse_addr(char **ptr, boolean safely)
 175 {
 176     char *token = parse_token(ptr);
 177     lispobj result;
 178
 179     if (token == NULL) {
 180         printf("expected an address\n");
 181         throw_to_monitor();
 182     }
 183     else if (token[0] == '$') {
 184         if (!lookup_variable(token+1, &result)) {
 185             printf("unknown variable: ``%s''\n", token);
 186             throw_to_monitor();
 187         }
 188         result &= ~7;
 189     }
 190     else {
 191         uword_t value;
 192         if (!string_to_long(token, &value)) {
 193             printf("invalid number: ``%s''\n", token);
 194             throw_to_monitor();
 195         }
 196         result = (value & ~3);
 197     }
 198
 199     if (safely && !gc_managed_addr_p(result)) {
 200         printf("invalid Lisp-level address: %p\n", (void *)result);
 201         throw_to_monitor();
 202     }
 203
 204     return (char *)result;
 205 }
 206
 207 static lispobj lookup_symbol(char *name)
 208 {
 209     lispobj *headerptr;
 210
 211     /* Search static space. */
 212     if ((headerptr = search_for_symbol(name,
 213                                        STATIC_SPACE_START,
 214                                        (uword_t)static_space_free_pointer)))
 215         return make_lispobj(headerptr, OTHER_POINTER_LOWTAG);
 216
 217 #ifdef LISP_FEATURE_IMMOBILE_SPACE
 218     /* Search immobile space. */
 219     if ((headerptr = search_for_symbol(name,
 220                                        IMMOBILE_SPACE_START,
 221                                        SymbolValue(IMMOBILE_FIXEDOBJ_FREE_POINTER,0))))
 222         return make_lispobj(headerptr, OTHER_POINTER_LOWTAG);
 223 #endif
 224
 225     /* Search dynamic space. */
 226 #if defined(LISP_FEATURE_GENCGC)
 227     uword_t start = DYNAMIC_SPACE_START;
 228     uword_t end   = (uword_t)get_alloc_pointer();
 229 #else
 230     uword_t start = (uword_t)current_dynamic_space;
 231     uword_t end   = (uword_t)dynamic_space_free_pointer;
 232 #endif
 233     if ((headerptr = search_for_symbol(name, start, end)))
 234         return make_lispobj(headerptr, OTHER_POINTER_LOWTAG);
 235
 236     return 0;
 237 }
 238
 239 static int parse_regnum(char *s)
 240 {
 241     if ((s[1] == 'R') || (s[1] == 'r')) {
 242         int regnum;
 243
 244         if (s[2] == '\0')
 245             return -1;
 246
 247         /* skip the $R part and call atoi on the number */
 248         regnum = atoi(s + 2);
 249         if ((regnum >= 0) && (regnum < NREGS))
 250             return regnum;
 251         else
 252             return -1;
 253     } else {
 254         int i;
 255
 256         for (i = 0; i < NREGS ; i++)
 257             if (strcasecmp(s + 1, lisp_register_names[i]) == 0)
 258 #ifdef LISP_FEATURE_X86
 259                 return i*2;
 260 #else
 261         return i;
 262 #endif
 263
 264         return -1;
 265     }
 266 }
 267
 268 lispobj parse_lispobj(char **ptr)
 269 {
 270     struct thread *thread=arch_os_get_current_thread();
 271     char *token = parse_token(ptr);
 272     uword_t pointer;
 273     lispobj result;
 274     uword_t value;
 275
 276     if (token == NULL) {
 277         printf("expected an object\n");
 278         throw_to_monitor();
 279     } else if (token[0] == '$') {
 280         if (isalpha(token[1])) {
 281             int free_ici;
 282             int regnum;
 283             os_context_t *context;
 284
 285             free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread));
 286
 287             if (free_ici == 0) {
 288                 printf("Variable ``%s'' is not valid -- there is no current interrupt context.\n", token);
 289                 throw_to_monitor();
 290             }
 291
 292             context = thread->interrupt_contexts[free_ici - 1];
 293
 294             regnum = parse_regnum(token);
 295             if (regnum < 0) {
 296                 printf("bogus register: ``%s''\n", token);
 297                 throw_to_monitor();
 298             }
 299
 300             result = *os_context_register_addr(context, regnum);
 301         } else if (!lookup_variable(token+1, &result)) {
 302             printf("unknown variable: ``%s''\n", token);
 303             throw_to_monitor();
 304         }
 305     } else if (token[0] == '@') {
 306         if (string_to_long(token+1, &pointer)) {
 307             pointer &= ~3;
 308             if (gc_managed_addr_p(pointer))
 309                 result = *(lispobj *)pointer;
 310             else {
 311                 printf("invalid Lisp-level address: ``%s''\n", token+1);
 312                 throw_to_monitor();
 313             }
 314         }
 315         else {
 316             printf("invalid address: ``%s''\n", token+1);
 317             throw_to_monitor();
 318         }
 319     }
 320     else if (string_to_long(token, &value))
 321         result = value;
 322     else if ((result = lookup_symbol(token)) != 0)
 323         ;
 324     else {
 325         printf("invalid Lisp object: ``%s''\n", token);
 326         throw_to_monitor();
 327     }
 328
 329     return result;
 330 }
 331
 332 #endif /* defined(LISP_FEATURE_SB_LDB) */