src/debug/lex.l

%{
#define USE_PURE_PARSER

#ifdef USE_PURE_PARSER
#define YY_DECL int yylex (YYSTYPE *lvalp)
#define YY_LVALP lvalp
#else
#define YY_LVALP (&yylval)
#endif

/* get current pos (offset from start of line) */
#define YY_USER_ACTION lex_pos=yy_bp - YY_CURRENT_BUFFER->yy_ch_buf;

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include "debug/debugtype.h"
#include "debugparse.h"
#include "parsehelper.h"

static int lex_pos;

static int char2int(char a, int base)
{
        int i;
        if ((a>='A') && (a<='Z')) {
                i=a-'A'+10;
        } else if ((a>='a') && (a<='z')) {
                i=a-'a'+10;
        } else if ((a>='0') && (a<='9')) {
                i=a-'0';
        } else return -1;
        if (i>=base) return -1;
        return i;
}

static int parse_integer(struct eval_scalar *i, char *num, int base, int lenmod)
{
        uint64 k = 0;
        int l = strlen(num)+lenmod;
        while (l--) {
                int c = char2int(*num, base);
                if (c==-1) return 0;
                k *= base;
                k += c;
                num++;
        }
        i->type = SCALAR_INT;
        i->scalar.integer.value = k;
        i->scalar.integer.type = TYPE_UNKNOWN;
        return 1;
}

static int parse_gpr(struct eval_scalar *i, char *s)
{
        int r = 0;
        if (tolower(*s) != 'r') return 0;
        s++;
        do {
                int c = char2int(*s, 10);
                if (c == -1) return 0;
                r *= 10;
                r += c;
                s++;
        } while (*s);
        if (r>31) return 0;
        i->type = SCALAR_REG;
        i->scalar.reg.type = REG_GPR;
        i->scalar.reg.num = r;
        return 1;
}

static int parse_fpr(struct eval_scalar *i, char *s)
{
        int r = 0;
        if (tolower(*s) != 'f') return 0;
        s++;
        if (tolower(*s) != 'r') return 0;
        s++;
        do {
                int c = char2int(*s, 10);
                if (c == -1) return 0;
                r *= 10;
                r += c;
                s++;
        } while (*s);
        if (r>31) return 0;
        i->type = SCALAR_REG;
        i->scalar.reg.type = REG_FPR;
        i->scalar.reg.num = r;
        return 1;
}

static int parse_float(struct eval_scalar *f, char *fpn)
{
        char *end;
        double d;
        d=strtod(fpn, &end);
        if (*end==0) {
                f->type=SCALAR_FLOAT;
                f->scalar.floatnum.value=d;
                return 1;
        }
        return 0;               
}

static int parse_cstring(struct eval_scalar *r, char *s, int len)
{
        char *result;

        int alloclen=len;
        if (!len) alloclen=1;

        r->type=SCALAR_STR;
        r->scalar.str.value=(char*)malloc(alloclen);
        /* translate */
        result=r->scalar.str.value;
        
        while (s && *s && len) {
                if (*s == '\\') {
                        s++;len--;if (!len) break;
                        switch (*s) {
                                case '0':
                                        *result++='\0';
                                        break;
                                case 'a':
                                        *result++='\a';
                                        break;
                                case 'b':
                                        *result++='\b';
                                        break;
                                case 'e':
                                        *result++='\e';
                                        break;
                                case 'f':
                                        *result++='\f';
                                        break;
                                case 'n':
                                        *result++='\n';
                                        break;
                                case 'r':
                                        *result++='\r';
                                        break;
                                case 't':
                                        *result++='\t';
                                        break;
                                case 'v':
                                        *result++='\v';
                                        break;
                                case '\"':
                                        *result++='"';
                                        break;
                                case '\\':
                                        *result++='\\';
                                        break;
                                case 'x': {
                                        int p, q;
                                        s++;len--;if (!len) break;
                                        p=char2int(*s, 16);
                                        if (p==-1)  return 0;
                                        s++;len--;if (!len) break;
                                        q=char2int(*s, 16);
                                        if (q==-1) return 0;
                                        *result++=(char)p*16+q;
                                        break;
                                }
                                default:
                                        *result++='\\';
                                        if (len) *result++=*s;
                                        break;
                        }
                } else {
                        *result++ = *s;
                }
                s++;len--;
        }
        
        r->scalar.str.len=result-r->scalar.str.value;
        
        return 1;
}

static int parse_pstring(struct eval_scalar *s, char *cstr, int len)
{
        int alloclen = len;
        if (!len) alloclen = 1;
        
        s->type = SCALAR_STR;
        s->scalar.str.value = (char*)malloc(alloclen);
        memmove(s->scalar.str.value, cstr, len);
        s->scalar.str.len = len;
        return 1;
}

void *lex_current_buffer()
{
        return (void*)YY_CURRENT_BUFFER;
}

int lex_current_buffer_pos()
{
        return lex_pos;
}

void lex_switch_buffer(void *buffer)
{
        yy_switch_to_buffer(buffer);    
}

void lex_delete_buffer(void *buffer)
{
        yy_delete_buffer(buffer);       
}

void *lex_scan_string_buffer(const char *str)
{
        return yy_scan_string(str);
}

%}

%option noyywrap

%%
[ \t]+                          /* nop */
\"(\\\"|[^"])*\"                if (parse_cstring(&YY_LVALP->scalar, yytext+1, strlen(yytext+1)-1)) return EVAL_STR;
'[^']*'                         if (parse_pstring(&YY_LVALP->scalar, yytext+1, strlen(yytext+1)-1)) return EVAL_STR;
\*\*                            return EVAL_POW;
\<\<                            return EVAL_SHL;
\>\>                            return EVAL_SHR;
\<                              return EVAL_LT;
\<\=                            return EVAL_LE;
\>                              return EVAL_GT;
\>\=                            return EVAL_GE;
\=\=                            return EVAL_EQ;
\!\=                            return EVAL_NE;
\&\&                            return EVAL_LAND;
\|\|                            return EVAL_LOR;
\^\^                            return EVAL_LXOR;
print                           |
p                               |
eval                            return EVAL_PRINT;
regs                            return EVAL_REGS;
f                               |
fprs                            |
floats                          return EVAL_FLOATS;
setreg                          return EVAL_SETREG;
break                           |
b                               return EVAL_BREAK;
list_break                      |
lb                              return EVAL_LIST_BREAK;
step                            return EVAL_STEP;
s                               return EVAL_STEP;
next                            return EVAL_NEXT;
n                               return EVAL_NEXT;
continue                        |
cont                            |
c                               return EVAL_CONTINUE;
quit                            |
bye                             return EVAL_QUIT;
virt_to_phys                    |
ea_to_pa                        |
e2p                             |
v2p                             return EVAL_E2P;
inspect_byte                    |
ib                              return EVAL_INSPECT_BYTE;
inspect_half                    |
ih                              return EVAL_INSPECT_HALF;
inspect_word                    |
iw                              return EVAL_INSPECT_WORD;
inspect_dword                   |
id                              return EVAL_INSPECT_DWORD;
inspect_string                  |
is                              return EVAL_INSPECT_STRING;
inspect_memory                  |
im                              return EVAL_INSPECT_MEM;
watch                           |
w                               return EVAL_WATCH;
watch_byte                      |
wb                              return EVAL_WATCH_BYTE;
watch_half                      |
wh                              return EVAL_WATCH_HALF;
watch_word                      |
ww                              return EVAL_WATCH_WORD;
watch_dword                     |
wd                              return EVAL_WATCH_DWORD;
delete_watch                    |
dw                              return EVAL_DELETE_WATCH;
dump                            |
d                               return EVAL_DUMP;
disasm                          |
unasm                           |
u                               return EVAL_DISASM;
help                            |
h                               return EVAL_HELP;
[#][^\n]*                       /* comment */
[pP][cC]                        { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_PC; return EVAL_REG_PC; }
[cC][rR]                        { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_CR; return EVAL_REG_CR; }
[lL][rR]                        { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_LR; return EVAL_REG_LR; }
[xX][eE][rR]                    { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_XER; return EVAL_REG_XER; }
[cC][tT][rR]                    { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_CTR; return EVAL_REG_CTR; }
[mM][sS][rR]                    { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_MSR; return EVAL_REG_MSR; }
[sS][rR][rR]0                   { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_SRR0; return EVAL_REG_SRR0; }
[sS][rR][rR]1                   { YY_LVALP->scalar.type=SCALAR_REG; YY_LVALP->scalar.scalar.reg.type=REG_SRR1; return EVAL_REG_SRR1; }
[rR][0-3]?[0-9]                 if (parse_gpr(&YY_LVALP->scalar, yytext)) return EVAL_GPR;
[fF][rR][0-3]?[0-9]             if (parse_fpr(&YY_LVALP->scalar, yytext)) return EVAL_FPR;
[$@a-zA-Z_][a-zA-Z0-9_]*        YY_LVALP->ident=strdup(yytext); return EVAL_IDENT;
[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?        if (parse_float(&YY_LVALP->scalar, yytext)) return EVAL_FLOAT;
[0-9]+                          if (parse_integer(&YY_LVALP->scalar, yytext, 10, 0)) return EVAL_INT;
0x[0-9a-fA-F]+                  if (parse_integer(&YY_LVALP->scalar, yytext+2, 16, 0)) return EVAL_INT;
[0-9][0-9a-fA-F]*h              if (parse_integer(&YY_LVALP->scalar, yytext, 16, -1)) return EVAL_INT;
[0-9]+d                         if (parse_integer(&YY_LVALP->scalar, yytext, 10, -1)) return EVAL_INT;
[0-7]+o                         if (parse_integer(&YY_LVALP->scalar, yytext, 8, -1)) return EVAL_INT;
[0-1]+b                         if (parse_integer(&YY_LVALP->scalar, yytext, 2, -1)) return EVAL_INT;
\n                              return '\n';
.                               return *yytext;

%%

1	dpavlin	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)p16+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