Compilers.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <string>
#include <vector>
 
#include "Data.h"
#include "Instruction.h"
#include "Compilers/AST.h"
#include "../Types.h"
 
namespace Gorgon {  namespace Scripting {
 
    class Scope;
    class InputSource;
 
namespace Compilers {
 
    class Base {
    public:
        Base(Scope *scope) : scope(scope) { }
        
        virtual ~Base() {}
        
        virtual unsigned Compile(const std::string &input, unsigned long pline) = 0;
        
        virtual void Finalize() = 0;
        
        virtual Base &Duplicate(Scope *scope) const = 0;
        
        bool HasScope() const {
            return scope!=nullptr;
        }
        
        Scope &GetScope() const {
            return *scope;
        }
        
        std::vector<Instruction> List;
        
    protected:
        Scope *scope;
    };
 
    class Intermediate : public Base {
    public:
        Intermediate(Scope *scope=nullptr) : Base(scope) { }
        
        virtual unsigned Compile(const std::string &input, unsigned long pline) override;
        virtual void Finalize() override { }
        
        virtual Intermediate &Duplicate(Scope *scope) const {
            return *new Intermediate(scope);
        }
        
    private:
        void storedfn(const std::string &input, int &ch);
        
        void fncall(const std::string &input, int &ch, bool allowmethod=true);
        
        void varassign(const std::string &input, int &ch);
        
        void memberassign(const std::string &input, int &ch);
        
        Value parsevalue(const std::string &input, int &ch);
        
        unsigned long parsetemporary(const std::string &input, int &ch);
        
        void eatwhite(const std::string &input, int &ch);
        
        void jinst(std::string input, int &ch);
    };
 
    class Programming : public Base {
    public:
        Programming(Scope *scope=nullptr) : Base(scope), compiler(List, *this) { }
        
        virtual unsigned Compile(const std::string &input, unsigned long pline) override;
        
        virtual void Finalize() override;
        
        virtual Programming &Duplicate(Scope *scope) const override {
            return *new Programming(scope);
        }
        
    private:
        ASTNode *parse(const std::string &input);
        void extractline(std::string &input, std::string &prepared);
        
        void transformpos(int ch, int &oline, int &och);
 
        ASTCompiler compiler;
        std::string left;
        struct charmarker {
            int pos;
            int chr;
            int line;
            int off;
        };
        std::vector<charmarker> linemarkers;
        int waiting=0;
        int plinespassed=0; //physical lines that are passed while trying to find the end of the logical line
    };
    
    std::string Disassemble(const Instruction *);
    
    inline std::string Disassemble(const Instruction &inst) { return Disassemble(&inst); }
    
    void Disassemble(InputSource &source, std::ostream &out);
    
} } }