tree-sitter/src/compiler/parse_table.cc

#include "compiler/parse_table.h"
#include <string>

namespace tree_sitter {
    using std::string;
    using std::ostream;
    using std::to_string;
    using std::set;
    using std::vector;
    using rules::Symbol;

    ParseAction::ParseAction(ParseActionType type,
                             size_t state_index,
                             Symbol symbol,
                             size_t consumed_symbol_count,
                             set<int> precedence_values) :
        type(type),
        symbol(symbol),
        state_index(state_index),
        consumed_symbol_count(consumed_symbol_count),
        precedence_values(precedence_values) {}

    ParseAction::ParseAction() :
        type(ParseActionTypeError),
        symbol(Symbol(-1)),
        state_index(-1),
        consumed_symbol_count(0) {}

    ParseAction ParseAction::Error() {
        return ParseAction(ParseActionTypeError, -1, Symbol(-1), 0, { 0 });
    }

    ParseAction ParseAction::Accept() {
        return ParseAction(ParseActionTypeAccept, -1, Symbol(-1), 0, { 0 });
    }

    ParseAction ParseAction::Shift(size_t state_index, set<int> precedence_values) {
        return ParseAction(ParseActionTypeShift, state_index, Symbol(-1), 0, precedence_values);
    }

    ParseAction ParseAction::ShiftExtra() {
        return ParseAction(ParseActionTypeShiftExtra, -1, Symbol(-1), 0, set<int>({}));
    }

    ParseAction ParseAction::Reduce(Symbol symbol, size_t consumed_symbol_count, int precedence) {
        return ParseAction(ParseActionTypeReduce, -1, symbol, consumed_symbol_count, { precedence });
    }

    bool ParseAction::operator==(const ParseAction &other) const {
        bool types_eq = type == other.type;
        bool symbols_eq = symbol == other.symbol;
        bool state_indices_eq = state_index == other.state_index;
        bool consumed_symbol_counts_eq = consumed_symbol_count == other.consumed_symbol_count;
        return types_eq && symbols_eq && state_indices_eq && consumed_symbol_counts_eq;
    }

    ostream& operator<<(ostream &stream, const ParseAction &action) {
        switch (action.type) {
            case ParseActionTypeError:
                return stream << string("#<error>");
            case ParseActionTypeAccept:
                return stream << string("#<accept>");
            case ParseActionTypeShift:
                return stream << (string("#<shift ") + to_string(action.state_index) + ">");
            case ParseActionTypeShiftExtra:
                return stream << string("#<shift_extra");
            case ParseActionTypeReduce:
                return stream << (string("#<reduce sym") + to_string(action.symbol.index) + " " + to_string(action.consumed_symbol_count) + ">");
            default:
                return stream;
        }
    }

    ParseState::ParseState() : lex_state_id(-1) {}

    set<Symbol> ParseState::expected_inputs() const {
        set<Symbol> result;
        for (auto &pair : actions)
            result.insert(pair.first);
        return result;
    }

    ostream& operator<<(ostream &stream, const ParseState &state) {
        stream << string("#<parse_state ");
        bool started = false;
        for (auto pair : state.actions) {
            if (started) stream << string(", ");
            stream << pair.first << string(" => ") << pair.second;
            started = true;
        }
        stream << string(">");
        return stream;
    }

    ParseStateId ParseTable::add_state() {
        states.push_back(ParseState());
        return states.size() - 1;
    }

    void ParseTable::add_action(ParseStateId id, Symbol symbol, ParseAction action) {
        symbols.insert(symbol);
        states[id].actions[symbol] = action;
    }
}