69 lines
1.8 KiB
C++
69 lines
1.8 KiB
C++
#include "compiler/lex_table.h"
|
|
#include "compiler/rules/symbol.h"
|
|
|
|
namespace tree_sitter {
|
|
|
|
using std::string;
|
|
using std::to_string;
|
|
using std::map;
|
|
using std::set;
|
|
using rules::Symbol;
|
|
using rules::CharacterSet;
|
|
|
|
LexAction::LexAction()
|
|
: type(LexActionTypeError),
|
|
symbol(Symbol(-1)),
|
|
state_index(-1),
|
|
precedence_range({ 0, 0 }) {}
|
|
|
|
LexAction::LexAction(LexActionType type, size_t state_index, Symbol symbol,
|
|
PrecedenceRange precedence_range, bool is_string)
|
|
: type(type),
|
|
symbol(symbol),
|
|
state_index(state_index),
|
|
precedence_range(precedence_range),
|
|
is_string(is_string) {}
|
|
|
|
LexAction LexAction::Error() {
|
|
return LexAction(LexActionTypeError, -1, Symbol(-1), { 0, 0 }, false);
|
|
}
|
|
|
|
LexAction LexAction::Advance(size_t state_index,
|
|
PrecedenceRange precedence_range) {
|
|
return LexAction(LexActionTypeAdvance, state_index, Symbol(-1),
|
|
precedence_range, false);
|
|
}
|
|
|
|
LexAction LexAction::Accept(Symbol symbol, int precedence, bool is_string) {
|
|
return LexAction(LexActionTypeAccept, -1, symbol, { precedence, precedence }, is_string);
|
|
}
|
|
|
|
bool LexAction::operator==(const LexAction &other) const {
|
|
return (type == other.type) && (state_index == other.state_index) &&
|
|
(symbol == other.symbol);
|
|
}
|
|
|
|
LexState::LexState() : is_token_start(false) {}
|
|
|
|
set<CharacterSet> LexState::expected_inputs() const {
|
|
set<CharacterSet> result;
|
|
for (auto &pair : actions)
|
|
result.insert(pair.first);
|
|
return result;
|
|
}
|
|
|
|
LexStateId LexTable::add_state() {
|
|
states.push_back(LexState());
|
|
return states.size() - 1;
|
|
}
|
|
|
|
LexState &LexTable::state(LexStateId id) {
|
|
if (id < 0)
|
|
return error_state;
|
|
else
|
|
return states[id];
|
|
}
|
|
|
|
const LexStateId LexTable::ERROR_STATE_ID = -1;
|
|
|
|
} // namespace tree_sitter
|