BaseListener.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
 
#include <AST/ASTNode.h>
#include <AST/NodeTypes.h>
#include <AST/Nodes/Nodes.h>
#include <error/InternalError.h>
#include <error/SyntaxError.h>
#include <error/ParserError.h>
 
namespace AST {
 
// Single source of truth for node list (used to generate wrappers + map)
#define AST_LISTENER_NODE_LIST(X) \
    X(ArrayAssignment) \
    X(ArrayIndex) \
    X(Bash53NativeSupershell) \
    X(BashArithmeticForCondition) \
    X(BashArithmeticForStatement) \
    X(BashArithmeticStatement) \
    X(BashArithmeticSubstitution) \
    X(BashCaseInput) \
    X(BashCasePattern) \
    X(BashCasePatternHeader) \
    X(BashCaseStatement) \
    X(BashCommand) \
    X(BashCommandSequence) \
    X(BashForStatement) \
    X(BashFunction) \
    X(BashIfCondition) \
    X(BashIfElseBranch) \
    X(BashIfRootBranch) \
    X(BashIfStatement) \
    X(BashInCondition) \
    X(BashPipeline) \
    X(BashRedirection) \
    X(BashSelectStatement) \
    X(BashTestConditionCommand) \
    X(BashUntilStatement) \
    X(BashVariable) \
    X(BashWhileOrUntilCondition) \
    X(BashWhileStatement) \
    X(Block) \
    X(ClassDefinition) \
    X(Connective) \
    X(ConstructorDefinition) \
    X(DatamemberDeclaration) \
    X(DeleteStatement) \
    X(DestructorDefinition) \
    X(DoublequotedString) \
    X(DynamicCast) \
    X(DynamicCastTarget) \
    X(HeredocBody) \
    X(HereString) \
    X(IncludeStatement) \
    X(MethodDefinition) \
    X(NewStatement) \
    X(ObjectAssignment) \
    X(ObjectInstantiation) \
    X(ObjectReference) \
    X(ParameterExpansion) \
    X(PointerDeclaration) \
    X(PrimitiveAssignment) \
    X(ProcessSubstitution) \
    X(Program) \
    X(RawSubshell) \
    X(RawText) \
    X(Rvalue) \
    X(SubshellSubstitution) \
    X(Supershell) \
    X(TypeofExpression) \
    X(ValueAssignment) \
 
template <class Derived>
class BaseListener {
    private:
        Derived& self() {
            return static_cast<Derived&>(*this);
        }
 
    protected:
        bool program_has_errors = false;
        std::vector<AST::ParserError> parser_errors;
 
    public:
        void walk(std::shared_ptr<AST::ASTNode> node) {
            try {
                switch (node->getType()) {
                    #define AST_CASE(Name) \
                        case AST::NodeType::Name: \
                            if constexpr (requires(Derived& d, std::shared_ptr<AST::Name> x) { d.enter##Name(x); }) { \
                                self().enter##Name(std::static_pointer_cast<AST::Name>(node)); \
                            } \
                            for (const auto& child : node->getChildren()) { \
                                walk(child); \
                            } \
                            if constexpr (requires(Derived& d, std::shared_ptr<AST::Name> x) { d.exit##Name(x); }) { \
                                self().exit##Name(std::static_pointer_cast<AST::Name>(node)); \
                            } \
                            break;
                    
                    AST_LISTENER_NODE_LIST(AST_CASE)
 
                    #undef AST_CASE
 
                    default:
                        throw bpp::ErrorHandling::InternalError("Unknown AST node type encountered in listener walk");
                }
            } catch (const bpp::ErrorHandling::SyntaxError& e) {
                // Cancel traversal of this node and its children, but continue to traverse the rest of the tree
                this->program_has_errors = true;
                e.print();
                return;
            }
        }
        #undef AST_LISTENER_NODE_LIST
 
        void set_has_errors(bool has_errors) {
            this->program_has_errors = has_errors;
        }
 
        void set_parser_errors(const std::vector<AST::ParserError>& errors) {
            this->parser_errors = errors;
            if (!errors.empty()) this->program_has_errors = true;
        }
};
 
} // namespace AST