vm.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of vyp08 (compiler and interpreter of VYP08 language).
 *
 * vyp08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * vyp08 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with vyp08.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VM_H
#define VM_H

#include "config.h"
#include "scanner.h"

#ifndef BUILDING_DOX
#   include <boost/smart_ptr.hpp>
#   include <iostream>
#   include <set>
#   include <string>
#   include <vector>
#endif

struct Value {
    enum VType {
        V_NULL = 0,
        V_BOOL,
        V_INT,
        V_DOUBLE,
        V_STRING
    };
    VType           type;                               

    bool            boolVal;                            
    int             intVal;                             
    double          doubleVal;                          
    std::string     stringVal;                          

    Value();                                            
};
std::ostream& operator<< (std::ostream &, const Value::VType &);
std::ostream& operator<< (std::ostream &, const Value &);
typedef SHARED_PTR(Value) PValue;
typedef SHARED_PTR(const Value) PConstValue;

class ValueFactory {
    public:
        static PValue create();                         
        static PValue create(bool);                     
        static PValue create(int);                      
        static PValue create(double);                   
        static PValue create(const std::string &);      
    private:
        ValueFactory();
};

struct Var {
    std::string     name;                               
    Value           value;                              
    Token           defined;                            

    bool            used;

    bool            initialized;

    Var();
};
typedef SHARED_PTR(Var) PVar;

class VarSet {
    public:
        VarSet();
        ~VarSet();

        VarSet &operator= (const VarSet &);

        bool add(PVar);                                 
        unsigned size() const;                          
        PVar operator[] (unsigned);                     
        PVar operator[] (const std::string &);          

        const PVar operator[] (unsigned pos) const {
            return const_cast<VarSet *>(this)
                -> operator[] (pos);
        }
        const PVar operator[] (const std::string &name) const {
            return const_cast<VarSet *>(this)
                -> operator[] (name);
        }
    private:
        struct Private;
        Private *d;

        VarSet(const VarSet &);
};

struct FncDeclaration {
    FncDeclaration();                                   
    FncDeclaration(const FncDeclaration &);             
    FncDeclaration& operator= (const FncDeclaration &); 
    virtual ~FncDeclaration();

    Var     self;

    VarSet  args;
};
bool operator== (const FncDeclaration &, const FncDeclaration &);
bool operator!= (const FncDeclaration &, const FncDeclaration &);

class Vm;
class CmdList;
typedef SHARED_PTR(CmdList) PCmdList;

struct FncDefinition: public FncDeclaration {
    FncDefinition(Vm *vm);

    /*
     * mixed (shallow/deep) copy
     * Everything is deep copied except cmdList.
     */
    FncDefinition(const FncDefinition &);
    virtual ~FncDefinition();

    Vm              *const vm;                          
    VarSet          vars;                               
    const PCmdList  cmdList;                            

    private:
        FncDefinition& operator= (const FncDefinition &);
};
bool chkUnused(FncDefinition *);

class FncSet {
    public:
        FncSet();
        ~FncSet();

        bool addDeclaration(FncDeclaration *);

        FncDeclaration* getDeclaration(const std::string &);

        bool addDefinition(FncDefinition *);

        FncDefinition* getDefinition(const std::string &);

        typedef STD_VECTOR(const FncDefinition *) TVector;

        void getAllDefinitions(TVector &);
    private:
        struct Private;
        Private *d;
};

class ICmd {
    public:
        virtual ~ICmd() { }

        virtual bool exec(FncDefinition *) = 0;

        virtual void toStream(std::ostream &) const = 0;
};
typedef SHARED_PTR(ICmd) PCmd;

class CmdList: public ICmd {
    public:
        CmdList();
        virtual ~CmdList();
        virtual bool exec(FncDefinition *);
        virtual void toStream(std::ostream &) const;

        void add(PCmd);
    private:
        struct Private;
        Private *d;
};
typedef SHARED_PTR(CmdList) PCmdList;

class ValueStack {
    public:
        ValueStack(Vm *vm);                             
        ~ValueStack();

        bool isEmpty() const;                           
        void push(PValue);                              
        PValue pop();                                   

        bool push(PValue, const Token &);

        bool pushFromVar(const Var &, const Token &);

        bool pop(PValue &, const Token &);

        bool popToVar(Var &, const Token &);

    private:
        struct Private;
        Private *d;
};

class CalleeSet {
    public:
        typedef STD_VECTOR(std::string) TStringList;
        typedef STD_VECTOR(Token)       TTokenList;
        CalleeSet();
        ~CalleeSet();

        void add(std::string name, Token tCall);

        bool isCalled(std::string name);

        void getNames(TStringList &);

        bool getCalls(std::string name, TTokenList &);

    private:
        struct Private;
        Private *d;
};

struct Vm {
    const std::string           fileName;               
    VarSet                      glVars;                 
    FncSet                      fncSet;                 
    ValueStack                  vmStack;                
    CalleeSet                   calleeSet;              
    int                         callDepth;              
    int                         maxCallDepth;           
    static const int            DEF_MAX_CALL_DEPTH = 1024;

    Vm(std::string fileName_):
        fileName(fileName_),
        vmStack(this),
        callDepth(0),
        maxCallDepth(DEF_MAX_CALL_DEPTH)
    {
    }
};

class VmRunner: public IErrorSensitive {
    public:
        VmRunner(Vm *vm);                               
        virtual ~VmRunner();
        virtual bool hasError() const;                  
        bool run();                                     
    private:
        struct Private;
        Private *d;
};

#endif /* VM_H */

---