Machine.h

Go to the documentation of this file.

// Machine.h A VM to run AS3 code, and AS2 code in the future.
//
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc.
// 
// This program 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.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_MACHINE_H
#define GNASH_MACHINE_H

#include <string>
#include <vector>
#include "SafeStack.h"
#include "as_value.h"
#include "log.h"

namespace gnash {
    namespace abc {
        class AbcBlock;
        class MultiName;
        class Class;
        class abc_function;
        class Method;
        class Namespace;
    }
    class Global_as;
    class DisplayObject;
    class as_object;
    class Property;
    class CodeStream;
    class VM;
    template <typename T> class FunctionArgs;
    class string_table;
}


namespace gnash {

namespace abc {

//
class Machine
{
public:

        Machine(VM& vm);

    //
    //
    void init();


        // Flash specific members.
        DisplayObject *getTarget();

        void setTarget(DisplayObject* target);

        int completeName(MultiName& name, int initial = 0);

        Class* findSuper(as_value& obj, bool find_primitive);

        void getMember(Class* pDefinition, MultiName& name, as_value& source);

        void setMember(Class*, MultiName&, as_value& target, as_value& val);

        Property* findProperty(MultiName&) { return NULL; }

        void execute();

        void pushGet(as_object *this_obj, as_value& return_slot, Property *prop);

        void pushSet(as_object *this_obj, as_value& value, Property *prop);

        void pushCall(as_function *func, as_object *pThis, as_value& return_slot,
                unsigned char stack_in, short stack_out);

        void immediateFunction(const as_function *to_call, as_object* pThis,
                as_value& storage, unsigned char stack_in, short stack_out);

        void immediateProcedure(const as_function *to_call, as_object *pthis,
                unsigned char stack_in, short stack_out) {
        immediateFunction(to_call, pthis, mIgnoreReturn, stack_in, stack_out);
    }

        void initMachine(AbcBlock* pool_block);

        as_value executeFunction(Method* function, const fn_call& fn);

        void instantiateClass(std::string className, as_object* global);
    //
    Global_as* global();

    void markReachableResources() const;

private:
        class State
        {
        public:
                unsigned int _stackDepth;
                unsigned int _stackTotalSize;
                unsigned int _scopeStackDepth;
                unsigned int mScopeTotalSize;
                bool mReturn;
                CodeStream *mStream;
                Namespace *mDefaultXMLNamespace;
                as_object *mCurrentScope;
                as_value *mGlobalReturn;
                as_object *mThis;
                std::vector<as_value> _registers;
                abc_function* mFunction;
        void to_debug_string(){
                log_abc("StackDepth=%u StackTotalSize=%u ScopeStackDepth=%u ScopeTotalSize=%u",_stackDepth,_stackTotalSize,_scopeStackDepth,mScopeTotalSize);

        }
        };

        class Scope
        {
        public:
                unsigned int mHeightAfterPop;
                as_object *mScope;

                Scope() : mHeightAfterPop(0), mScope(NULL) {}
                Scope(unsigned int i, as_object *o) : mHeightAfterPop(i),
                        mScope(o)
                {}
        };

        void saveState();
        void restoreState();

        as_value find_prop_strict(MultiName multiname);

        void print_stack();

        void print_scope_stack();

        void get_args(size_t argc, FunctionArgs<as_value>& args);
        
        void load_function(CodeStream* stream, std::uint32_t maxRegisters);

        void executeCodeblock(CodeStream* stream);

        void clearRegisters(std::uint32_t maxRegsiters);

        const as_value& getRegister(int index){
                log_abc("Getting value at a register %d ", index);
                return _registers[index];
        }

    void setRegister(size_t index, const as_value& val) {
        log_abc("Putting %s in register %s", val, index);
        if (_registers.size() <= index) {
            log_abc("Register doesn't exist! Adding new registers!");
            _registers.resize(index + 1);
        }
        _registers[index] = val;
    }

        void push_stack(as_value object){
                log_abc("Pushing value %s onto stack.", object);
                _stack.push(object);
        }

        as_value pop_stack(){
                as_value value = _stack.pop();
                log_abc("Popping value %s off the stack.", value);
                return value;
        }

        void push_scope_stack(as_value object);

        as_object* pop_scope_stack() {
                log_abc("Popping value %s off the scope stack.  There will be "
                "%u items left.", as_value(_scopeStack.top(0)),
                _scopeStack.size()-1);
                return _scopeStack.pop();
        }

        as_object* get_scope_stack(std::uint8_t depth) const {
                log_abc("Getting value from scope stack %u from the bottom.",
                depth | 0x0);
                return _scopeStack.value(depth);
        }

        SafeStack<as_value> _stack;
        SafeStack<State> mStateStack;
        std::vector<as_value> _registers;

    //
        SafeStack<as_object*> _scopeStack;

    CodeStream *mStream;

        string_table& mST;

        Namespace* mDefaultXMLNamespace;
        as_object* mCurrentScope;
        as_object* mGlobalScope;
        as_object* mDefaultThis;
        as_object* mThis;

        Global_as* _global;

        as_value mGlobalReturn;
        as_value mIgnoreReturn; // Throw away returns go here.

        bool mExitWithReturn;
    AbcBlock* mPoolObject; // Where all of the pools are stored.

        abc_function* mCurrentFunction;

        VM& _vm;
};
} // namespace abc
} // namespace gnash
#endif