mpw/debugger/lexer.re.cpp

340 lines
6.6 KiB
C++
Raw Normal View History

2013-07-03 21:05:00 +00:00
#include <string>
#include <algorithm>
#include <numeric>
#include <cstdint>
#include <stdlib.h>
#include "commands.h"
#include "parser.h"
// re2c -b -i
extern "C" {
void *ParseAlloc(void *(*mallocProc)(size_t));
void ParseFree(void *p, void (*freeProc)(void*));
void Parse(void *yyp, int yymajor, uint32_t yyminor, Command *command);
2013-07-03 23:55:09 +00:00
void ParseTrace(FILE *TraceFILE, char *zTracePrompt);
2013-07-03 21:05:00 +00:00
}
// p / print expression
// hd / hexdump expression [:expression]
// stack ?
// brk expression
// tbrk expression
namespace {
int tox(char c)
{
c |= 0x20; // lowercase it.
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
return 0;
}
uint32_t scan10(const char *begin, const char *end)
{
return std::accumulate(begin, end, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c){
2013-07-03 21:05:00 +00:00
return value * 10 + c - '0';
});
}
uint32_t scan16(const char *begin, const char *end)
{
return std::accumulate(begin, end, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c){
2013-07-03 21:05:00 +00:00
return (value << 4) + tox(c);
});
}
}
#if 0
/*
* unordered_set of breakpoints?
* bloom filter via std::bitset<16 * 1024> ?
*/
class AddressFilter {
std::bitset<4096> pageSet;
std::unordered_set<uint32_t> addSet;
bool test(uint32_t address) const
{
if (address > 0xffffff) return false;
if (!pageSet[address >> 12]) return false;
return addSet.find(address) != addSet.end();
}
void add(uint32_t address)
{
if (address > 0xffffff) return;
pageSet[address >> 12] = true;
addSet.insert(address);
}
void remove(uint32_t address)
{
if (address > 0xffffff) return;
auto iter = addSet.find(address);
if (iter != addSet.end())
{
addSet.remove();
// need to re-scan all addresses to update the pageSet...
uint32_t page = address >> 12;
pageSet[page] = false;
for (auto x : addSet)
{
if ((x >> 12) == page)
{
addSet[page] = true;
break;
}
}
}
}
};
#endif
bool ParseLine(const char *iter, Command *command)
{
void *parser;
parser = ParseAlloc(malloc);
2013-07-03 23:55:09 +00:00
//ParseTrace(stdout, "--> ");
2013-07-03 21:05:00 +00:00
for (;;)
{
const char *begin = iter;
const char *marker;
/*!re2c
re2c:define:YYCURSOR = iter;
re2c:define:YYMARKER = marker;
re2c:define:YYCTYPE = char;
re2c:yyfill:enable = 0;
[ \t\f\r\n]+ {
// white space
continue;
}
2013-07-03 23:55:09 +00:00
'>=' { Parse(parser, tkGTEQ, 0, command); continue; }
'>>' { Parse(parser, tkGTGT, 0, command); continue; }
'<=' { Parse(parser, tkLTEQ, 0, command); continue; }
'<<' { Parse(parser, tkLTLT, 0, command); continue; }
'!=' { Parse(parser, tkBANGEQ, 0, command); continue; }
'==' { Parse(parser, tkEQEQ, 0, command); continue; }
'||' { Parse(parser, tkPIPEPIPE, 0, command); continue; }
'&&' { Parse(parser, tkAMPAMP, 0, command); continue; }
'(' { Parse(parser, tkLPAREN, 0, command); continue; }
')' { Parse(parser, tkRPAREN, 0, command); continue; }
'=' { Parse(parser, tkEQ, 0, command); continue; }
'+' { Parse(parser, tkPLUS, 0, command); continue; }
'-' { Parse(parser, tkMINUS, 0, command); continue; }
'*' { Parse(parser, tkSTAR, 0, command); continue; }
'/' { Parse(parser, tkSLASH, 0, command); continue; }
'%' { Parse(parser, tkPERCENT, 0, command); continue; }
'~' { Parse(parser, tkTILDE, 0, command); continue; }
'!' { Parse(parser, tkBANG, 0, command); continue; }
'^' { Parse(parser, tkCARET, 0, command); continue; }
'&' { Parse(parser, tkAMP, 0, command); continue; }
'|' { Parse(parser, tkPIPE, 0, command); continue; }
'<' { Parse(parser, tkLT, 0, command); continue; }
'>' { Parse(parser, tkGT, 0, command); continue; }
2013-07-03 21:05:00 +00:00
[0-9]+ {
// integer
uint32_t data;
data = std::accumulate(begin, iter, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c){
return (value * 10) + c - '0';
2013-07-03 21:05:00 +00:00
});
2013-07-03 23:55:09 +00:00
Parse(parser, tkINTEGER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
'$' [0-9A-Fa-f]+ {
// hex number
uint32_t data;
data = std::accumulate(begin + 1, iter, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c){
2013-07-03 21:05:00 +00:00
return (value << 4) + tox(c);
}
);
2013-07-03 23:55:09 +00:00
Parse(parser, tkINTEGER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
'0x' [0-9A-Fa-f]+ {
// hex number
uint32_t data;
data = std::accumulate(begin + 2, iter, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c){
2013-07-03 21:05:00 +00:00
return (value << 4) + tox(c);
}
);
2013-07-03 23:55:09 +00:00
Parse(parser, tkINTEGER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
['] [^']{1,4} ['] {
// 4 cc code
uint32_t data;
data = std::accumulate(begin + 1, iter - 1, 0,
2013-07-03 23:55:09 +00:00
[](uint32_t value, char c)
2013-07-03 21:05:00 +00:00
{
return (value << 8) + (unsigned)c;
}
);
2013-07-03 23:55:09 +00:00
Parse(parser, tkINTEGER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
'd' [0-7] {
// data register
uint32_t data = begin[1] - '0';
2013-07-03 23:55:09 +00:00
Parse(parser, tkDREGISTER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
'a' [0-7] {
// address register
uint32_t data = begin[1] - '0';
2013-07-03 23:55:09 +00:00
Parse(parser, tkAREGISTER, data, command);
2013-07-03 21:05:00 +00:00
continue;
}
'pc' {
// program counter...
2013-07-03 23:55:09 +00:00
Parse(parser, tkXREGISTER, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
'csr' {
// condition status register.
2013-07-03 23:55:09 +00:00
Parse(parser, tkXREGISTER, 1, command);
2013-07-03 21:05:00 +00:00
continue;
}
'sp' {
// stack pointer aka a7
2013-07-03 23:55:09 +00:00
Parse(parser, tkAREGISTER, 7, command);
2013-07-03 21:05:00 +00:00
continue;
}
'fp' {
// frame pointer aka a6
2013-07-03 23:55:09 +00:00
Parse(parser, tkAREGISTER, 6, command);
2013-07-03 21:05:00 +00:00
continue;
}
'c' | 'continue' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkCONTINUE, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
'hd' | 'dump' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkDUMP, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
'h' | 'help' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkHELP, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
2013-07-04 04:29:09 +00:00
'l' | 'list' {
Parse(parser, tkLIST, 0, command);
continue;
}
2013-07-03 21:05:00 +00:00
'n' | 'next' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkNEXT, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
's' | 'step' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkNEXT, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
'b' | 'brk' | 'break' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkBREAK, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
'g' | 'go' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkCONTINUE, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
2013-07-03 23:55:09 +00:00
'p' | 'print' {
Parse(parser, tkPRINT, 0, command);
continue;
}
2013-07-03 21:05:00 +00:00
'r' | 'run' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkCONTINUE, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
';l' | ';list' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkSEMIL, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
';h' | ';hd' | ';hexdump' {
2013-07-03 23:55:09 +00:00
Parse(parser, tkSEMIH, 0, command);
2013-07-03 21:05:00 +00:00
continue;
}
[_A-Za-z][_A-Za-z0-9] + {
// identifier. lookup global address, tool number, etc.
2013-07-03 23:55:09 +00:00
fprintf(stderr, "illegal identifier: `%.*s`\n", (int)(iter - begin), begin);
2013-07-03 21:05:00 +00:00
return false;
}
[\x00] {
// eol.
2013-07-03 23:55:09 +00:00
Parse(parser, tkEOL, 0, command);
2013-07-03 21:05:00 +00:00
break;
}
[^] {
fprintf(stderr, "illegal character: `%c`\n", *begin);
return false;
}
*/
}
2013-07-03 23:55:09 +00:00
Parse(parser, 0, 0, command);
ParseFree(parser, free);
2013-07-03 21:05:00 +00:00
2013-07-04 04:29:09 +00:00
if (!command->valid)
fprintf(stderr,"I don't understand.\n");
2013-07-03 21:05:00 +00:00
return command->valid;
}