AST.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "../../Containers/Collection.h"
#include "../Data.h"
#include "../Instruction.h"
 
 
namespace Gorgon { namespace Scripting { namespace Compilers {
 
    class Base;
 
    class ASTNode {
    public:
        
        enum NodeType {
            Literal,
            
            FunctionCall,
            
            MethodCall,
            
            Member,
            
            Identifier,
            
            Variable,
            
            Operator,
            
            Index,
            
            Construct,
            
            Keyword,
            
            Assignment,
            
            Empty,
            
            List,
        };
 
        ASTNode(NodeType type): Type(type) { }
 
        ASTNode *Duplicate() {
            ASTNode *newnode=new ASTNode(Type);
            newnode->Start=Start;
            newnode->Text=Text;
            newnode->Leaves=Leaves.Duplicate();
 
            return newnode;
        }
        
        ~ASTNode() {
            Leaves.Destroy();
        }
        
        NodeType Type;
        
        int Start = -1;
        
        int Line = -1;
        
        std::string Text;
        
        Data LiteralValue = Data::Invalid();
        
        Containers::Collection<ASTNode> Leaves;
 
 
    };
    
    class ASTCompiler {
    public:
        
        ASTCompiler(std::vector<Instruction> &list, Base &parser) : parser(parser), list(&list) { }
        
        unsigned Compile(ASTNode *tree);
        
        bool IsReady() const { return waitingcount==0; }
        
        void Finalize() {
            if(scopes.size()) {
                throw FlowException(scope::keywordnames[scopes.back().type]+" scope is not closed.");
            }
        }
        
    private:
        bool compilekeyword(ASTNode *tree, Byte &tempind);
        void release(int start, int except=-1);
        void release(int start, Value except);
        
        
        struct scope {
            enum scopetype {
                unknown,
                ifkeyword,
                whilekeyword,
                functionkeyword,
                methodkeyword,
                forkeyword
            } type;
            
            static const std::string keywordnames[];
            
            scope(scopetype type, int index) : type(type) { indices.push_back(index); }
            
            scope(scopetype type) : type(type) { }
            
            scope(scopetype type, const Data &data) : type(type), data(data) { }
            
            bool passed=0;
            Data data;
            std::vector<int> indices;
            std::vector<int> indices2;
            
            int state=0;
            int clear=-1;
        };
        
        std::vector<scope> scopes;
        std::vector<std::vector<Instruction>*> redirects;
        
        //temporaries start from 1
        int indstart=1;
        int waitingcount = 0;
        std::vector<Instruction> *list;
        Base &parser;
    };
 
    void ASTToSVG(const std::string &line, ASTNode &tree, const std::vector<std::string> &compiled={}, bool show=false);
    
    void PrintAST(ASTNode &tree);
} } }