| 1 |
%{ |
| 2 |
#define USE_PURE_PARSER |
| 3 |
|
| 4 |
#ifdef USE_PURE_PARSER |
| 5 |
#define YY_DECL int yylex (YYSTYPE *lvalp) |
| 6 |
#define YY_LVALP lvalp |
| 7 |
#else |
| 8 |
#define YY_LVALP (&yylval) |
| 9 |
#endif |
| 10 |
|
| 11 |
/* get current pos (offset from start of line) */ |
| 12 |
#define YY_USER_ACTION lex_pos=yy_bp - YY_CURRENT_BUFFER->yy_ch_buf; |
| 13 |
|
| 14 |
#include <stdio.h> |
| 15 |
#include <string.h> |
| 16 |
#include <stdlib.h> |
| 17 |
#include <ctype.h> |
| 18 |
|
| 19 |
#include "debug/debugtype.h" |
| 20 |
#include "debugparse.h" |
| 21 |
#include "parsehelper.h" |
| 22 |
|
| 23 |
static int lex_pos; |
| 24 |
|
| 25 |
static int char2int(char a, int base) |
| 26 |
{ |
| 27 |
int i; |
| 28 |
if ((a>='A') && (a<='Z')) { |
| 29 |
i=a-'A'+10; |
| 30 |
} else if ((a>='a') && (a<='z')) { |
| 31 |
i=a-'a'+10; |
| 32 |
} else if ((a>='0') && (a<='9')) { |
| 33 |
i=a-'0'; |
| 34 |
} else return -1; |
| 35 |
if (i>=base) return -1; |
| 36 |
return i; |
| 37 |
} |
| 38 |
|
| 39 |
static int parse_integer(struct eval_scalar *i, char *num, int base, int lenmod) |
| 40 |
{ |
| 41 |
uint64 k = 0; |
| 42 |
int l = strlen(num)+lenmod; |
| 43 |
while (l--) { |
| 44 |
int c = char2int(*num, base); |
| 45 |
if (c==-1) return 0; |
| 46 |
k *= base; |
| 47 |
k += c; |
| 48 |
num++; |
| 49 |
} |
| 50 |
i->type = SCALAR_INT; |
| 51 |
i->scalar.integer.value = k; |
| 52 |
i->scalar.integer.type = TYPE_UNKNOWN; |
| 53 |
return 1; |
| 54 |
} |
| 55 |
|
| 56 |
static int parse_gpr(struct eval_scalar *i, char *s) |
| 57 |
{ |
| 58 |
int r = 0; |
| 59 |
if (tolower(*s) != 'r') return 0; |
| 60 |
s++; |
| 61 |
do { |
| 62 |
int c = char2int(*s, 10); |
| 63 |
if (c == -1) return 0; |
| 64 |
r *= 10; |
| 65 |
r += c; |
| 66 |
s++; |
| 67 |
} while (*s); |
| 68 |
if (r>31) return 0; |
| 69 |
i->type = SCALAR_REG; |
| 70 |
i->scalar.reg.type = REG_GPR; |
| 71 |
i->scalar.reg.num = r; |
| 72 |
return 1; |
| 73 |
} |
| 74 |
|
| 75 |
static int parse_fpr(struct eval_scalar *i, char *s) |
| 76 |
{ |
| 77 |
int r = 0; |
| 78 |
if (tolower(*s) != 'f') return 0; |
| 79 |
s++; |
| 80 |
if (tolower(*s) != 'r') return 0; |
| 81 |
s++; |
| 82 |
do { |
| 83 |
int c = char2int(*s, 10); |
| 84 |
if (c == -1) return 0; |
| 85 |
r *= 10; |
| 86 |
r += c; |
| 87 |
s++; |
| 88 |
} while (*s); |
| 89 |
if (r>31) return 0; |
| 90 |
i->type = SCALAR_REG; |
| 91 |
i->scalar.reg.type = REG_FPR; |
| 92 |
i->scalar.reg.num = r; |
| 93 |
return 1; |
| 94 |
} |
| 95 |
|
| 96 |
static int parse_float(struct eval_scalar *f, char *fpn) |
| 97 |
{ |
| 98 |
char *end; |
| 99 |
double d; |
| 100 |
d=strtod(fpn, &end); |
| 101 |
if (*end==0) { |
| 102 |
f->type=SCALAR_FLOAT; |
| 103 |
f->scalar.floatnum.value=d; |
| 104 |
return 1; |
| 105 |
} |
| 106 |
return 0; |
| 107 |
} |
| 108 |
|
| 109 |
static int parse_cstring(struct eval_scalar *r, char *s, int len) |
| 110 |
{ |
| 111 |
char *result; |
| 112 |
|
| 113 |
int alloclen=len; |
| 114 |
if (!len) alloclen=1; |
| 115 |
|
| 116 |
r->type=SCALAR_STR; |
| 117 |
r->scalar.str.value=(char*)malloc(alloclen); |
| 118 |
/* translate */ |
| 119 |
result=r->scalar.str.value; |
| 120 |
|
| 121 |
while (s && *s && len) { |
| 122 |
if (*s == '\\') { |
| 123 |
s++;len--;if (!len) break; |
| 124 |
switch (*s) { |
| 125 |
case '0': |
| 126 |
*result++='\0'; |
| 127 |
break; |
| 128 |
case 'a': |
| 129 |
*result++='\a'; |
| 130 |
break; |
| 131 |
case 'b': |
| 132 |
*result++='\b'; |
| 133 |
break; |
| 134 |
case 'e': |
| 135 |
*result++='\e'; |
| 136 |
break; |
| 137 |
case 'f': |
| 138 |
*result++='\f'; |
| 139 |
break; |
| 140 |
case 'n': |
| 141 |
*result++='\n'; |
| 142 |
break; |
| 143 |
case 'r': |
| 144 |
*result++='\r'; |
| 145 |
break; |
| 146 |
case 't': |
| 147 |
*result++='\t'; |
| 148 |
break; |
| 149 |
case 'v': |
| 150 |
*result++='\v'; |
| 151 |
break; |
| 152 |
case '\"': |
| 153 |
*result++='"'; |
| 154 |
break; |
| 155 |
case '\\': |
| 156 |
*result++='\\'; |
| 157 |
break; |
| 158 |
case 'x': { |
| 159 |
int p, q; |
| 160 |
s++;len--;if (!len) break; |
| 161 |
p=char2int(*s, 16); |
| 162 |
if (p==-1) return 0; |
| 163 |
s++;len--;if (!len) break; |
| 164 |
q=char2int(*s, 16); |
| 165 |
if (q==-1) return 0; |
| 166 |
*result++=(char)p*16+q; |
| 167 |
break; |
| 168 |
} |
| 169 |
default: |
| 170 |
*result++='\\'; |
| 171 |
if (len) *result++=*s; |
| 172 |
break; |
| 173 |
} |
| 174 |
} else { |
| 175 |
*result++ = *s; |
| 176 |
} |
| 177 |
s++;len--; |
| 178 |
} |
| 179 |
|
| 180 |
r->scalar.str.len=result-r->scalar.str.value; |
| 181 |
|
| 182 |
return 1; |
| 183 |
} |
| 184 |
|
| 185 |
static int parse_pstring(struct eval_scalar *s, char *cstr, int len) |
| 186 |
{ |
| 187 |
int alloclen = len; |
| 188 |
if (!len) alloclen = 1; |
| 189 |
|
| 190 |
s->type = SCALAR_STR; |
| 191 |
s->scalar.str.value = (char*)malloc(alloclen); |
| 192 |
memmove(s->scalar.str.value, cstr, len); |
| 193 |
s->scalar.str.len = len; |
| 194 |
return 1; |
| 195 |
} |
| 196 |
|
| 197 |
void *lex_current_buffer() |
| 198 |
{ |
| 199 |
return (void*)YY_CURRENT_BUFFER; |
| 200 |
} |
| 201 |
|
| 202 |
int lex_current_buffer_pos() |
| 203 |
{ |
| 204 |
return lex_pos; |
| 205 |
} |
| 206 |
|
| 207 |
void lex_switch_buffer(void *buffer) |
| 208 |
{ |
| 209 |
yy_switch_to_buffer(buffer); |
| 210 |
} |
| 211 |
|
| 212 |
void lex_delete_buffer(void *buffer) |
| 213 |
{ |
| 214 |
yy_delete_buffer(buffer); |
| 215 |
} |
| 216 |
|
| 217 |
void *lex_scan_string_buffer(const char *str) |
| 218 |
{ |
| 219 |
return yy_scan_string(str); |
| 220 |
} |
| 221 |
|
| 222 |
%} |
| 223 |
|
| 224 |
%option noyywrap |
| 225 |
|
| 226 |
%% |
| 227 |
[ \t]+ /* nop */ |
| 228 |
\"(\\\"|[^"])*\" if (parse_cstring(&YY_LVALP->scalar, yytext+1, strlen(yytext+1)-1)) return EVAL_STR; |
| 229 |
'[^']*' if (parse_pstring(&YY_LVALP->scalar, yytext+1, strlen(yytext+1)-1)) return EVAL_STR; |
| 230 |
\*\* return EVAL_POW; |
| 231 |
\<\< return EVAL_SHL; |
| 232 |
\>\> return EVAL_SHR; |
| 233 |
\< return EVAL_LT; |
| 234 |
\<\= return EVAL_LE; |
| 235 |
\> return EVAL_GT; |
| 236 |
\>\= return EVAL_GE; |
| 237 |
\=\= return EVAL_EQ; |
| 238 |
\!\= return EVAL_NE; |
| 239 |
\&\& return EVAL_LAND; |
| 240 |
\|\| return EVAL_LOR; |
| 241 |
\^\^ return EVAL_LXOR; |
| 242 |
print | |
| 243 |
p | |
| 244 |
eval return EVAL_PRINT; |
| 245 |
regs return EVAL_REGS; |
| 246 |
f | |
| 247 |
fprs | |
| 248 |
floats return EVAL_FLOATS; |
| 249 |
setreg return EVAL_SETREG; |
| 250 |
break | |
| 251 |
b return EVAL_BREAK; |
| 252 |
list_break | |
| 253 |
lb return EVAL_LIST_BREAK; |
| 254 |
step return EVAL_STEP; |
| 255 |
s return EVAL_STEP; |
| 256 |
next return EVAL_NEXT; |
| 257 |
n return EVAL_NEXT; |
| 258 |
continue | |
| 259 |
cont | |
| 260 |
c return EVAL_CONTINUE; |
| 261 |
quit | |
| 262 |
bye return EVAL_QUIT; |
| 263 |
virt_to_phys | |
| 264 |
ea_to_pa | |
| 265 |
e2p | |
| 266 |
v2p return EVAL_E2P; |
| 267 |
inspect_byte | |
| 268 |
ib return EVAL_INSPECT_BYTE; |
| 269 |
inspect_half | |
| 270 |
ih return EVAL_INSPECT_HALF; |
| 271 |
inspect_word | |
| 272 |
iw return EVAL_INSPECT_WORD; |
| 273 |
inspect_dword | |
| 274 |
id return EVAL_INSPECT_DWORD; |
| 275 |
inspect_string | |
| 276 |
is return EVAL_INSPECT_STRING; |
| 277 |
inspect_memory | |
| 278 |
im return EVAL_INSPECT_MEM; |
| 279 |
watch | |
| 280 |
w return EVAL_WATCH; |
| 281 |
watch_byte | |
| 282 |
wb return EVAL_WATCH_BYTE; |
| 283 |
watch_half | |
| 284 |
wh return EVAL_WATCH_HALF; |
| 285 |
watch_word | |
| 286 |
ww return EVAL_WATCH_WORD; |
| 287 |
watch_dword | |
| 288 |
wd return EVAL_WATCH_DWORD; |
| 289 |
delete_watch | |
| 290 |
dw return EVAL_DELETE_WATCH; |
| 291 |
dump | |
| 292 |
d return EVAL_DUMP; |
| 293 |
disasm | |
| 294 |
unasm | |
| 295 |
u return EVAL_DISASM; |
| 296 |
help | |
| 297 |
h return EVAL_HELP; |
| 298 |
[#][^\n]* /* comment */ |
| 299 |
[pP][cC] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_PC; return EVAL_REG_PC; } |
| 300 |
[cC][rR] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_CR; return EVAL_REG_CR; } |
| 301 |
[lL][rR] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_LR; return EVAL_REG_LR; } |
| 302 |
[xX][eE][rR] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_XER; return EVAL_REG_XER; } |
| 303 |
[cC][tT][rR] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_CTR; return EVAL_REG_CTR; } |
| 304 |
[mM][sS][rR] { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_MSR; return EVAL_REG_MSR; } |
| 305 |
[sS][rR][rR]0 { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_SRR0; return EVAL_REG_SRR0; } |
| 306 |
[sS][rR][rR]1 { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_SRR1; return EVAL_REG_SRR1; } |
| 307 |
[rR][0-3]?[0-9] if (parse_gpr(&YY_LVALP->scalar, yytext)) return EVAL_GPR; |
| 308 |
[fF][rR][0-3]?[0-9] if (parse_fpr(&YY_LVALP->scalar, yytext)) return EVAL_FPR; |
| 309 |
[$@a-zA-Z_][a-zA-Z0-9_]* YY_LVALP->ident=strdup(yytext); return EVAL_IDENT; |
| 310 |
[0-9]+\.[0-9]+([eE][+-]?[0-9]+)? if (parse_float(&YY_LVALP->scalar, yytext)) return EVAL_FLOAT; |
| 311 |
[0-9]+ if (parse_integer(&YY_LVALP->scalar, yytext, 10, 0)) return EVAL_INT; |
| 312 |
0x[0-9a-fA-F]+ if (parse_integer(&YY_LVALP->scalar, yytext+2, 16, 0)) return EVAL_INT; |
| 313 |
[0-9][0-9a-fA-F]*h if (parse_integer(&YY_LVALP->scalar, yytext, 16, -1)) return EVAL_INT; |
| 314 |
[0-9]+d if (parse_integer(&YY_LVALP->scalar, yytext, 10, -1)) return EVAL_INT; |
| 315 |
[0-7]+o if (parse_integer(&YY_LVALP->scalar, yytext, 8, -1)) return EVAL_INT; |
| 316 |
[0-1]+b if (parse_integer(&YY_LVALP->scalar, yytext, 2, -1)) return EVAL_INT; |
| 317 |
\n return '\n'; |
| 318 |
. return *yytext; |
| 319 |
|
| 320 |
%% |
| 321 |
|
Parent Directory
| 
Revision Log