ast.hpp

Go to the documentation of this file.

#ifndef __AST_HPP_X_
#define __AST_HPP_X_
 
#include "mxvm/instruct.hpp"
#include <memory>
#include <string>
#include <vector>
 
namespace mxvm {
 
    class ASTVisitor;

    class ASTNode {
      public:
        virtual ~ASTNode() = default;
        virtual void accept(ASTVisitor &visitor) = 0;
        virtual std::string toString() const = 0;
    };

    class SectionNode : public ASTNode {
      public:
        enum SectionType {
            DATA,
            CODE,
            MODULE,
            OBJECT
        };
        SectionType type;
        std::vector<std::unique_ptr<ASTNode>> statements;
 
        SectionNode(SectionType sectionType) : type(sectionType) {}
 
        void addStatement(std::unique_ptr<ASTNode> stmt) {
            statements.push_back(std::move(stmt));
        }
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class ProgramNode : public ASTNode {
      public:
        std::string name;
        bool object = false;            
        std::string root_name;
        std::vector<std::unique_ptr<SectionNode>> sections;
        std::vector<std::unique_ptr<ProgramNode>> inlineObjects;
 
        void addSection(std::unique_ptr<SectionNode> section) {
            sections.push_back(std::move(section));
        }
 
        void addInlineObject(std::unique_ptr<ProgramNode> obj) {
            inlineObjects.push_back(std::move(obj));
        }
 
        virtual void accept(ASTVisitor &visitor) override;
        virtual std::string toString() const override;
    };

    class VariableNode : public ASTNode {
      public:
        std::string name;
        VarType type;
        std::string initialValue;
        bool hasInitializer;
        size_t buffer_size = 0;         
        bool is_global = false;
        std::string object;             
 
        VariableNode(VarType varType, const std::string &varName)
            : name(varName), type(varType), hasInitializer(false), buffer_size(0) {}
 
        VariableNode(VarType varType, const std::string &varName, size_t buf_size)
            : name(varName), type(varType), hasInitializer(false), buffer_size(buf_size) {}
 
        VariableNode(VarType varType, const std::string &varName, const std::string &value)
            : name(varName), type(varType), initialValue(value), hasInitializer(true), buffer_size(0) {}
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class ModuleNode : public ASTNode {
      public:
        std::string name;
        ModuleNode(const std::string &n) : name(n) {}
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class ObjectNode : public ASTNode {
      public:
        std::string name;
        ObjectNode(const std::string &o) : name(o) {}
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class InstructionNode : public ASTNode {
      public:
        Inc instruction;                
        std::vector<Operand> operands;
 
        InstructionNode(Inc inst) : instruction(inst) {}
 
        InstructionNode(Inc inst, const std::vector<Operand> &ops)
            : instruction(inst), operands(ops) {}
 
        void addOperand(const Operand &operand) {
            operands.push_back(operand);
        }
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class LabelNode : public ASTNode {
      public:
        std::string name;
        bool function = false;          
        LabelNode(const std::string &labelName) : name(labelName) {}
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class ExpressionNode : public ASTNode {
      public:
        std::string value;
        bool isNumeric;
 
        ExpressionNode(const std::string &val, bool numeric = false)
            : value(val), isNumeric(numeric) {}
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class CommentNode : public ASTNode {
      public:
        std::string text;
        CommentNode(const std::string &commentText) : text(commentText) {}
 
        void accept(ASTVisitor &visitor) override;
        std::string toString() const override;
    };

    class ASTVisitor {
      public:
        virtual ~ASTVisitor() = default;
        virtual void visit(ProgramNode &node) = 0;
        virtual void visit(SectionNode &node) = 0;
        virtual void visit(InstructionNode &node) = 0;
        virtual void visit(LabelNode &node) = 0;
        virtual void visit(VariableNode &node) = 0;
        virtual void visit(ExpressionNode &node) = 0;
        virtual void visit(CommentNode &node) = 0;
        virtual void visit(ModuleNode &node) = 0;
        virtual void visit(ObjectNode &node) = 0;
    };
} // namespace mxvm
 
#endif