bx_debug/lexer.l

   1 %{
   2 /////////////////////////////////////////////////////////////////////////
   3 // $Id: lexer.l,v 1.27 2008/05/01 19:10:04 sshwarts Exp $
   4 /////////////////////////////////////////////////////////////////////////
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include "debug.h"
   9 #if BX_DEBUGGER
  10
  11 #include "parser.h"
  12
  13 int bx_yyinput(char *buf, int max_size);
  14 #undef YY_INPUT
  15 #define YY_INPUT(buf, ret, max_size) (ret = bx_yyinput(buf, max_size))
  16
  17 static char    *lex_input_ptr = NULL;
  18 static unsigned lex_input_size = 0;
  19
  20 #if BX_SUPPORT_X86_64
  21   #define LONG_MODE_8BL_REG(reg) \
  22      { bxlval.uval = reg; return(BX_TOKEN_8BL_REG); }
  23   #define LONG_MODE_16B_REG(reg) \
  24      { bxlval.uval = reg; return(BX_TOKEN_16B_REG); }
  25   #define LONG_MODE_32B_REG(reg) \
  26      { bxlval.uval = reg; return(BX_TOKEN_32B_REG); }
  27   #define LONG_MODE_64B_REG(reg) \
  28      { bxlval.uval = reg; return(BX_TOKEN_64B_REG); }
  29 #else
  30   #define LONG_MODE_8BL_REG(reg) \
  31      { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GENERIC); }
  32   #define LONG_MODE_16B_REG(reg) \
  33      { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GENERIC); }
  34   #define LONG_MODE_32B_REG(reg) \
  35      { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GENERIC); }
  36   #define LONG_MODE_64B_REG(reg) \
  37      { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GENERIC); }
  38 #endif
  39
  40 %}
  41
  42 %x EXAMINE
  43 %x DISASM
  44
  45 %%
  46 <*>[ \t]+       ; // eat up whitespace
  47 set             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SET); }
  48 on              { bxlval.bval = 1; return(BX_TOKEN_ON); }
  49 off             { bxlval.bval = 0; return(BX_TOKEN_OFF); }
  50 crc             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CRC); }
  51 c               |
  52 cont            |
  53 continue        { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CONTINUE); }
  54 stepi           |
  55 step            |
  56 s               { bxlval.sval = strdup(bxtext); return(BX_TOKEN_STEPN); }
  57 next            |
  58 n               |
  59 p               { bxlval.sval = strdup(bxtext); return(BX_TOKEN_STEP_OVER); }
  60 blist           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LIST_BREAK); }
  61 vb|vbreak       { bxlval.sval = strdup(bxtext); return(BX_TOKEN_VBREAKPOINT); }
  62 lb|lbreak       { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LBREAKPOINT); }
  63 break           |
  64 b|pb            |
  65 pbreak          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PBREAKPOINT); }
  66 info            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_INFO); }
  67 cr              |
  68 creg            |
  69 cregs           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CONTROL_REGS); }
  70 sreg            |
  71 sregs           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SEGMENT_REGS); }
  72 r|reg           |
  73 regs            |
  74 registers       { bxlval.sval = strdup(bxtext); return(BX_TOKEN_REGISTERS); }
  75 fp|fpu          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_FPU); }
  76 sse             |
  77 xmm             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SSE); }
  78 mmx             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_MMX); }
  79 cpu             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CPU); }
  80 idt             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_IDT); }
  81 ivt             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_IVT); }
  82 gdt             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GDT); }
  83 ldt             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LDT); }
  84 tss             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TSS); }
  85 tab             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TAB); }
  86 dirty           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DIRTY); }
  87 linux           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LINUX); }
  88 delete          |
  89 del             |
  90 d               { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DEL_BREAKPOINT); }
  91 bpe             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_ENABLE_BREAKPOINT); }
  92 bpd             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DISABLE_BREAKPOINT); }
  93 quit            |
  94 exit            |
  95 q               { bxlval.sval = strdup(bxtext); return(BX_TOKEN_QUIT); }
  96 x               |
  97 xp              { BEGIN(EXAMINE); bxlval.sval = strdup(bxtext); return(BX_TOKEN_EXAMINE); }
  98 restore         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_RESTORE); }
  99 setpmem         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SETPMEM); }
 100 query           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_QUERY); }
 101 pending         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PENDING); }
 102 take            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TAKE); }
 103 dma             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DMA); }
 104 irq             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_IRQ); }
 105 pic             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PIC); }
 106 u               |
 107 disasm          |
 108 disassemble     { BEGIN(DISASM); bxlval.sval = strdup(bxtext); return(BX_TOKEN_DISASSEMBLE); }
 109 instrument      { bxlval.sval = strdup(bxtext); return(BX_TOKEN_INSTRUMENT); }
 110 stop            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_STOP); }
 111 doit            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DOIT); }
 112 trace           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TRACE); }
 113 trace-reg       { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TRACEREG); }
 114 trace-mem       { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TRACEMEM); }
 115 switch-mode     { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SWITCH_MODE); }
 116 size            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SIZE); }
 117 ptime           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PTIME); }
 118 sb              { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TIMEBP); }
 119 sba             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_TIMEBP_ABSOLUTE); }
 120 record          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_RECORD); }
 121 playback        { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PLAYBACK); }
 122 modebp          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_MODEBP); }
 123 print-stack     { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PRINT_STACK); }
 124 watch           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_WATCH); }
 125 unwatch         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_UNWATCH); }
 126 read            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_READ); }
 127 write           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_WRITE); }
 128 show            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SHOW); }
 129 ldsym           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LOAD_SYMBOLS); }
 130 symbols         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SYMBOLS); }
 131 slist           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_LIST_SYMBOLS); }
 132 global          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GLOBAL); }
 133 where           { bxlval.sval = strdup(bxtext); return(BX_TOKEN_WHERE); }
 134 print-string    { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PRINT_STRING); }
 135 ne2k|ne2000     { bxlval.sval = strdup(bxtext); return(BX_TOKEN_NE2000); }
 136 page            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PAGE); }
 137 vga             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_VGA); }
 138 pci             { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PCI); }
 139 al              { bxlval.uval = BX_DBG_REG8L_AL; return(BX_TOKEN_8BL_REG);}
 140 bl              { bxlval.uval = BX_DBG_REG8L_BL; return(BX_TOKEN_8BL_REG);}
 141 cl              { bxlval.uval = BX_DBG_REG8L_CL; return(BX_TOKEN_8BL_REG);}
 142 dl              { bxlval.uval = BX_DBG_REG8L_DL; return(BX_TOKEN_8BL_REG);}
 143 sil             { LONG_MODE_8BL_REG(BX_DBG_REG8L_SIL); }
 144 dil             { LONG_MODE_8BL_REG(BX_DBG_REG8L_DIL); }
 145 spl             { LONG_MODE_8BL_REG(BX_DBG_REG8L_SPL); }
 146 bpl             { LONG_MODE_8BL_REG(BX_DBG_REG8L_BPL); }
 147 r8b             { LONG_MODE_8BL_REG(BX_DBG_REG8L_R8);  }
 148 r9b             { LONG_MODE_8BL_REG(BX_DBG_REG8L_R9);  }
 149 r10b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R10); }
 150 r11b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R11); }
 151 r12b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R12); }
 152 r13b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R13); }
 153 r14b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R14); }
 154 r15b            { LONG_MODE_8BL_REG(BX_DBG_REG8L_R15); }
 155 ah              { bxlval.uval = BX_DBG_REG8H_AH; return(BX_TOKEN_8BH_REG);}
 156 bh              { bxlval.uval = BX_DBG_REG8H_BH; return(BX_TOKEN_8BH_REG);}
 157 ch              { bxlval.uval = BX_DBG_REG8H_CH; return(BX_TOKEN_8BH_REG);}
 158 dh              { bxlval.uval = BX_DBG_REG8H_DH; return(BX_TOKEN_8BH_REG);}
 159 ax              { bxlval.uval = BX_DBG_REG16_AX; return(BX_TOKEN_16B_REG);}
 160 bx              { bxlval.uval = BX_DBG_REG16_BX; return(BX_TOKEN_16B_REG);}
 161 cx              { bxlval.uval = BX_DBG_REG16_CX; return(BX_TOKEN_16B_REG);}
 162 dx              { bxlval.uval = BX_DBG_REG16_DX; return(BX_TOKEN_16B_REG);}
 163 si              { bxlval.uval = BX_DBG_REG16_SI; return(BX_TOKEN_16B_REG);}
 164 di              { bxlval.uval = BX_DBG_REG16_DI; return(BX_TOKEN_16B_REG);}
 165 bp              { bxlval.uval = BX_DBG_REG16_BP; return(BX_TOKEN_16B_REG);}
 166 sp              { bxlval.uval = BX_DBG_REG16_SP; return(BX_TOKEN_16B_REG);}
 167 r8w             { LONG_MODE_16B_REG(BX_DBG_REG16_R8);  }
 168 r9w             { LONG_MODE_16B_REG(BX_DBG_REG16_R9);  }
 169 r10w            { LONG_MODE_16B_REG(BX_DBG_REG16_R10); }
 170 r11w            { LONG_MODE_16B_REG(BX_DBG_REG16_R11); }
 171 r12w            { LONG_MODE_16B_REG(BX_DBG_REG16_R12); }
 172 r13w            { LONG_MODE_16B_REG(BX_DBG_REG16_R13); }
 173 r14w            { LONG_MODE_16B_REG(BX_DBG_REG16_R14); }
 174 r15w            { LONG_MODE_16B_REG(BX_DBG_REG16_R15); }
 175 eax             { bxlval.uval = BX_DBG_REG32_EAX; return(BX_TOKEN_32B_REG);}
 176 ebx             { bxlval.uval = BX_DBG_REG32_EBX; return(BX_TOKEN_32B_REG);}
 177 ecx             { bxlval.uval = BX_DBG_REG32_ECX; return(BX_TOKEN_32B_REG);}
 178 edx             { bxlval.uval = BX_DBG_REG32_EDX; return(BX_TOKEN_32B_REG);}
 179 esi             { bxlval.uval = BX_DBG_REG32_ESI; return(BX_TOKEN_32B_REG);}
 180 edi             { bxlval.uval = BX_DBG_REG32_EDI; return(BX_TOKEN_32B_REG);}
 181 ebp             { bxlval.uval = BX_DBG_REG32_EBP; return(BX_TOKEN_32B_REG);}
 182 esp             { bxlval.uval = BX_DBG_REG32_ESP; return(BX_TOKEN_32B_REG);}
 183 r8d             { LONG_MODE_32B_REG(BX_DBG_REG32_R8);  }
 184 r9d             { LONG_MODE_32B_REG(BX_DBG_REG32_R9);  }
 185 r10d            { LONG_MODE_32B_REG(BX_DBG_REG32_R10); }
 186 r11d            { LONG_MODE_32B_REG(BX_DBG_REG32_R11); }
 187 r12d            { LONG_MODE_32B_REG(BX_DBG_REG32_R12); }
 188 r13d            { LONG_MODE_32B_REG(BX_DBG_REG32_R13); }
 189 r14d            { LONG_MODE_32B_REG(BX_DBG_REG32_R14); }
 190 r15d            { LONG_MODE_32B_REG(BX_DBG_REG32_R15); }
 191 rax             { LONG_MODE_64B_REG(BX_DBG_REG64_RAX); }
 192 rbx             { LONG_MODE_64B_REG(BX_DBG_REG64_RBX); }
 193 rcx             { LONG_MODE_64B_REG(BX_DBG_REG64_RCX); }
 194 rdx             { LONG_MODE_64B_REG(BX_DBG_REG64_RDX); }
 195 rsi             { LONG_MODE_64B_REG(BX_DBG_REG64_RSI); }
 196 rdi             { LONG_MODE_64B_REG(BX_DBG_REG64_RDI); }
 197 rsp             { LONG_MODE_64B_REG(BX_DBG_REG64_RSP); }
 198 rbp             { LONG_MODE_64B_REG(BX_DBG_REG64_RBP); }
 199 r8              { LONG_MODE_64B_REG(BX_DBG_REG64_R8);  }
 200 r9              { LONG_MODE_64B_REG(BX_DBG_REG64_R9);  }
 201 r10             { LONG_MODE_64B_REG(BX_DBG_REG64_R10); }
 202 r11             { LONG_MODE_64B_REG(BX_DBG_REG64_R11); }
 203 r12             { LONG_MODE_64B_REG(BX_DBG_REG64_R12); }
 204 r13             { LONG_MODE_64B_REG(BX_DBG_REG64_R13); }
 205 r14             { LONG_MODE_64B_REG(BX_DBG_REG64_R14); }
 206 r15             { LONG_MODE_64B_REG(BX_DBG_REG64_R15); }
 207 ip              { return(BX_TOKEN_REG_IP); }
 208 eip             { return(BX_TOKEN_REG_EIP);}
 209 rip             { return(BX_TOKEN_REG_RIP);}
 210 cs              { bxlval.uval = BX_DBG_SREG_CS; return(BX_TOKEN_CS); }
 211 es              { bxlval.uval = BX_DBG_SREG_ES; return(BX_TOKEN_ES); }
 212 ss              { bxlval.uval = BX_DBG_SREG_SS; return(BX_TOKEN_SS); }
 213 ds              { bxlval.uval = BX_DBG_SREG_DS; return(BX_TOKEN_DS); }
 214 fs              { bxlval.uval = BX_DBG_SREG_FS; return(BX_TOKEN_FS); }
 215 gs              { bxlval.uval = BX_DBG_SREG_GS; return(BX_TOKEN_GS); }
 216 flags|eflags    { bxlval.uval = 0; return (BX_TOKEN_FLAGS); }
 217 h|help          { bxlval.sval = strdup(bxtext); return(BX_TOKEN_HELP); }
 218 \?              |
 219 calc            { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CALC); }
 220 <EXAMINE>\/[0-9]+                 { BEGIN(INITIAL); bxlval.sval = strdup(bxtext); return(BX_TOKEN_XFORMAT); }
 221 <EXAMINE>\/[0-9]*[mxduotcsibhwg]+ { BEGIN(INITIAL); bxlval.sval = strdup(bxtext); return(BX_TOKEN_XFORMAT); }
 222 <DISASM>\/[0-9]+        { BEGIN(INITIAL); bxlval.sval = strdup(bxtext); return(BX_TOKEN_DISFORMAT); }
 223 "+"             { return ('+'); }
 224 "-"             { return ('-'); }
 225 "*"             { return ('*'); }
 226 "/"             { return ('/'); }
 227 ">>"            { return (BX_TOKEN_RSHIFT); }
 228 "<<"            { return (BX_TOKEN_LSHIFT); }
 229 "&"             { return ('&'); }
 230 "|"             { return ('|'); }
 231 "^"             { return ('^'); }
 232 "!"             { return ('!'); }
 233 "("             { return ('('); }
 234 ")"             { return (')'); }
 235 \'([^\\\'\n]|(\\.))*\'    |       /* throw away leading and trailing \" */
 236 \"([^\\\"\n]|(\\.))*\"    { bxlval.sval = strdup(bxtext+1); bxlval.sval[strlen(bxlval.sval)-1] = 0; return(BX_TOKEN_STRING); }
 237 0x[0-9a-fA-F]+  { bxlval.uval = strtoull(bxtext, NULL, 16); return(BX_TOKEN_NUMERIC); }
 238 0[0-7]+         { bxlval.uval = strtoull(bxtext, NULL, 8); return(BX_TOKEN_NUMERIC); }
 239 [0-9]+          { bxlval.uval = strtoull(bxtext, NULL, 10); return(BX_TOKEN_NUMERIC); }
 240 [a-z-]+         { bxlval.sval = strdup(bxtext); return(BX_TOKEN_COMMAND); }
 241 $[a-zA-Z_][a-zA-Z0-9_]* { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SYMBOLNAME); }
 242 [A-Za-z_][A-Za-z0-9_]*  { bxlval.sval = strdup(bxtext); return(BX_TOKEN_GENERIC); }
 243 <*>";"          { return ('\n'); }
 244 <*>\n           { return ('\n'); }
 245 [#][^\n]*    ; // eat up comments '//'
 246 .               { return(bxtext[0]); }
 247 <EXAMINE,DISASM>. { BEGIN(INITIAL); unput(*bxtext); }
 248 %%
 249
 250   int
 251 bx_yyinput(char *buf, int max_size)
 252 {
 253   int len;
 254
 255   if (lex_input_size == 0) {
 256     fprintf(stderr, "lex: no characters in string input buffer.\n");
 257     exit(1);
 258   }
 259
 260   len = strlen(lex_input_ptr) + 1;
 261   if (len > max_size)
 262     len = max_size;
 263
 264   memcpy(buf, lex_input_ptr, len);
 265
 266   return(len);
 267 }
 268
 269   void
 270 bx_add_lex_input(char *buf)
 271 {
 272   lex_input_ptr  = buf;
 273   lex_input_size = strlen(buf);
 274
 275   // Since we're parsing from strings, flush out
 276   // all current buffer state, so the next read
 277   // requests from yyinput
 278
 279   bx_flush_buffer( YY_CURRENT_BUFFER );
 280 }
 281
 282 #endif /* if BX_DEBUGGER */