SyntaxNode.h

Go to the documentation of this file.

 
#pragma once
#include "../runner/common/Setup.h"
#include <memory>
 
namespace mana
{
    class Symbol;
    class TypeDescriptor;
    class TypeDescriptorFactory;
 
    class SyntaxNode final : public std::enable_shared_from_this<SyntaxNode>
    {
    public:
        enum class Id : uint8_t
        {
            Array,                              
            Assign,                             
            CallArgument,                       
            DeclareArgument,                    
            Const,                              
            Call,                               
            Add,                                
            Sub,                                
            Mul,                                
            Div,                                
            Rem,                                
            Neg,                                
            Pow,                                
            Not,                                
            And,                                
            Or,                                 
            Xor,                                
            LeftShift,                          
            RightShift,                         
            Less,                               
            LessEqual,                          
            Equal,                              
            NotEqual,                           
            GreaterEqual,                       
            Greater,                            
            String,                             
            IntegerToFloat,                     
            FloatToInteger,                     
            LogicalOr,                          
            LogicalAnd,                         
            LogicalNot,                         
            Halt,                               
            Yield,                              
            Request,                            
            AwaitStart,                         
            AwaitCompletion,                    
            Accept,                             
            Reject,                             
            Join,                               
            Sender,                             
            Self,                               
            Priority,                           
            ExpressionIf,                       
            Print,                              
            Return,                             
            Rollback,                           
 
            Block,                              
            If,                                 
            Switch,                             
            Case,                               
            Default,                            
            While,                              
            Do,                                 
            For,                                
            Loop,                               
            Lock,                               
            Goto,                               
            Label,                              
            Break,                              
            Continue,                           
 
            Identifier,
            TypeDescription,
            Declarator,
 
            DeclareVariable,
            ConstDeclaration,
            Sizeof,
 
            Actor,                              
            Phantom,
            Module,
            Struct,
            Action,
            Extend,
            Allocate,
            Static,
            NativeFunction,
            DeclareFunction,
            Namespace,
            Using,
 
            DefineConstant,
            UndefineConstant,
 
            MemberFunction,
            MemberVariable,
 
            VariableSize,
        };
        static constexpr size_t IdSize = static_cast<size_t>(Id::VariableSize);
 
    public:
        explicit SyntaxNode(const Id id);
        ~SyntaxNode() = default;
 
        std::shared_ptr<SyntaxNode> Clone() const;
 
        bool Is(const Id id) const;
        bool IsNot(const Id id) const;
        Id GetId() const;
 
        address_t GetMemorySize() const;
 
        std::shared_ptr<SyntaxNode> GetLeftNode() const;
        void SetLeftNode(const std::shared_ptr<SyntaxNode>& left);
 
        std::shared_ptr<SyntaxNode> GetRightNode() const;
        void SetRightNode(const std::shared_ptr<SyntaxNode>& right);
 
        std::shared_ptr<SyntaxNode> GetBodyNode() const;
        void SetBodyNode(const std::shared_ptr<SyntaxNode>& body);
 
        std::shared_ptr<SyntaxNode> GetNextNode() const;
        void SetNextNode(const std::shared_ptr<SyntaxNode>& next);
 
        std::shared_ptr<Symbol> GetSymbol() const;
        std::shared_ptr<TypeDescriptor> GetTypeDescriptor() const;
        
        IntermediateLanguage GetOpecode() const;
        int_t GetInt() const;
        float_t GetFloat() const;
        const std::string_view& GetString() const;
 
        const std::string_view& GetFilename() const;
        int32_t GetLineno() const;
 
        void Set(const std::shared_ptr<Symbol>& symbol);
        void Set(const std::shared_ptr<TypeDescriptor>& type);
        void Set(const IntermediateLanguage code);
        void Set(const int_t value);
        void Set(const float_t value);
        void Set(const std::string_view text);
 
        std::shared_ptr<SyntaxNode> Cast(const std::shared_ptr<TypeDescriptor>& type, const std::shared_ptr<TypeDescriptorFactory>& typeDescriptorFactory);
 
        void Dump(std::ofstream& output) const;
 
    private:
        SyntaxNode() = default;
 
        std::shared_ptr<SyntaxNode> CreateCast(const std::shared_ptr<TypeDescriptor>& type, const std::shared_ptr<TypeDescriptorFactory>& typeDescriptorFactory);
 
        std::string GetMagic() const;
        void DumpRecursive(std::ofstream& output) const;
 
#if defined(MANA_MEMORY_LEAK_ANALYSIS)
        char mMagicName[8];
#endif
 
        std::shared_ptr<SyntaxNode> mLeft;
        std::shared_ptr<SyntaxNode> mRight;
        std::shared_ptr<SyntaxNode> mBody;
        std::shared_ptr<SyntaxNode> mNext;
 
        std::shared_ptr<Symbol> mSymbol;
        std::shared_ptr<TypeDescriptor> mType;
 
        uint32_t mMagic;
 
        Id mId = Id::VariableSize;
 
        IntermediateLanguage mCode = IntermediateLanguage::Halt;
 
        int16_t mLineNo = -1;
        
        int_t mDigit = 0;
        float_t mReal = 0;
        std::string_view mString;
 
        std::string_view mFilename;
    };
}