spl/interp/VarInterp.h

/*
 *   This file is part of the Standard Portable Library (SPL).
 *
 *   SPL 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
 *   (at your option) any later version.
 *
 *   SPL 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 SPL.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _variantinterp_h
#define _variantinterp_h

#include <spl/types.h>
#include <spl/Debug.h>
#include <spl/interp/JsMethod.h>
#include <spl/interp/JsObject.h>
#include <spl/Memory.h>
#include <spl/interp/Program.h>
#include <spl/RefCountPtr.h>
#include <spl/Variant.h>
#include <spl/collection/Vector.h>

class StackFrame : public IMemoryValidate
{
private:
        int m_pc;
        const Program *m_program;
        VariantPtr m_context;
        RefCountPtr<IJsObject> m_contextObj;
        
        StackFrame *m_outer;
        Vector<VariantPtr> m_stack;
        Vector<int> m_enterStack;

public:
        StackFrame();
        StackFrame(JsMethodPtr context);

        StackFrame(JsMethodPtr context, StackFrame *outer);

        StackFrame(const StackFrame& frm);

        virtual ~StackFrame();

        StackFrame& operator =(const StackFrame& frm);

        void InitArgs(Vector<VariantPtr> args);

        inline VariantPtr Context() { return m_context; }
        VariantPtr GetThis();
        inline RefCountPtr<IJsObject> ContextObject() { return m_contextObj; }

        inline VariantPtr PeekStack() { return m_stack.Peek(); }
        inline VariantPtr PeekStackRef() { return m_stack.PeekRef(); }

        inline Vector<VariantPtr>& GetStack() { return m_stack; }
        Vector<VariantPtr> GetArgs();

        VariantPtr FindProperty(const Variant& propName);
        void DefineProperty();

        inline void SetPc(int pc) { m_pc = pc; }
        inline int GetPc() const { return m_pc; }
        inline int IncPc() { return m_pc++; }
        inline Instruction CurrentInstruction() { ASSERT(NULL != m_program); return m_program->InstructionAt(m_pc); }

        inline StackFrame *NextFrame() { return m_outer; }

        inline void PopStack()
        {       
                GetStack().PeekRef() = NULL; 
                GetStack().Pop();
        }
        
        inline void EnterBlock()
        {
                m_enterStack.Add(m_stack.Count());
        }

        inline void LeaveBlock()
        {
                int pos = m_enterStack.Peek();
                m_enterStack.Pop();
                
                while (m_stack.Count() != pos)
                {
                        PopStack();                     
                }
        }
        
        inline VariantPtr GetCallThis()
        {
                return m_stack.ElementAt(m_enterStack.Peek());
        }

        inline bool CanContinue()
        {
                ASSERT(NULL != m_program);
                return m_program->CanContinue(GetPc());
        }

        inline Instruction PreExecute()
        {
                ASSERT(NULL != m_program);
                Instruction i = m_program->InstructionAt(IncPc());
                if (i.argSrc != JSOPARG_NONE)
                {
                        m_stack.Add(m_program->GetArg(i, m_stack));
                }
                return i;
        }

#if defined(DEBUG) || defined(_DEBUG)
        void CheckMem() const;
        void ValidateMem() const;
#endif
};

class VarInterp : public IMemoryValidate
{
protected:
        Vector<StackFrame> m_stackFrames;
        //RefCountPtr<IJsObject> m_globalObject;

        inline StackFrame& Frame() { return m_stackFrames.PeekRef(); }
        
public:
        VarInterp();
        VarInterp(VariantPtr method, Vector<VariantPtr>& args);
        virtual ~VarInterp();

        void PrepareToExecute(VariantPtr method, Vector<VariantPtr>& args);
        bool Execute(bool continueAfterLine = false);

        inline int FrameCount() const { return m_stackFrames.Count(); }
        inline int StackCount() const { return m_stackFrames.PeekRef().GetStack().Count(); }
        inline VariantPtr StackPeek() const { return m_stackFrames.PeekRef().GetStack().Peek(); }
        inline VariantPtr StackPeekAt(int idx) const { m_stackFrames.PeekRef().GetStack().ElementAt(idx); }

        inline VariantPtr ReturnValue() 
        { 
                return m_stackFrames.Peek().GetStack().Count() > 0 ? m_stackFrames.Peek().GetStack().Peek() : VariantPtr(new Variant()); 
        }

        inline void PopStack()
        {
                Frame().PopStack();
        }
        
        inline void PushStack(VariantPtr var)
        {
                Frame().GetStack().Add(var);
        }
        
        inline void PushStack(IJsObjectPtr obj)
        {
                PushStack(VariantPtr(new Variant(obj)));
        }

        static RefCountPtr<IJsObject> CreateDefaultContext(Program& prog);

#if defined(DEBUG) || defined(_DEBUG)
        void CheckMem() const;
        void ValidateMem() const;
#endif
};

#endif