VM.h

Go to the documentation of this file.

// VM.h: the Virtual Machine class, for Gnash
// 
//   Copyright (C) 2005, 2006, 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_VM_H
#define GNASH_VM_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include <map>
#include <vector>
#include <memory> 
#include <locale>
#include <boost/cstdint.hpp> 
#include <boost/random.hpp>
#include <boost/noncopyable.hpp>
#include <boost/array.hpp>

#include "GC.h"
#include "string_table.h"
#include "SafeStack.h"
#include "CallStack.h"
#include "as_value.h"
#include "namedStrings.h"
#include "ObjectURI.h"
#include "ConstantPool.h"

// Forward declarations
namespace gnash {
        class Global_as;
        class VM;
        class fn_call;
        class movie_root;
        class NativeFunction;
    class SharedObjectLibrary;
        class as_value;
        class as_object;
        class VirtualClock;
    class UserFunction;
}

namespace gnash {

//
//
//
//
class DSOEXPORT VM : boost::noncopyable
{
public:

        typedef as_value (*as_c_function_ptr)(const fn_call& fn);
        
    //
        VM(movie_root& root, VirtualClock& clock);

        ~VM();

    //
        SafeStack<as_value>& getStack() {
                return _stack;
        }

    //
    VirtualClock& getClock() {
        return _clock;
    }

        //
        int getSWFVersion() const {
        return _swfversion;
    }

        void setSWFVersion(int v);

        unsigned long int getTime() const;

        string_table& getStringTable() const { return _stringTable; }

        //
        const std::string& getPlayerVersion() const;
        
        std::string getOSName() const;
        
        std::string getSystemLanguage() const;
        
        // The boost Random Number Generator to use.
        //
        // http://www.boost.org/libs/random/random-generators.html
        //
        // TODO: boost/nondet_random.hpp provides access to a random device,
        // which can be used in preference to a pseudo-RNG. It is only
        // presently available on some platforms.
        // http://www.boost.org/libs/random/nondet_random.html
        //
        // Generators have different limits on the size of the seed. Please
        // check if replacing the generator.
        //
        // The mt11213b provides a pseudo-random number cycle
        // of length 2^11213-1 and requires approx 352*sizeof(uint32_t) memory
        // once initialized. It is more than adequate for most purposes.
        typedef boost::mt11213b RNG;    

        // Get a pointer to the random number generator for
        // use by Math.random() and random().
        RNG& randomNumberGenerator();

        movie_root& getRoot() const;

    SharedObjectLibrary& getSharedObjectLibrary() const {
        assert(_shLib.get());
        return *_shLib;
    }

        Global_as* getGlobal() const;

        //
        void markReachableResources() const;

        void registerNative(as_c_function_ptr fun, unsigned int x, unsigned int y);

        NativeFunction* getNative(unsigned int x, unsigned int y) const;

    //
    //
    const as_value* getRegister(size_t index);

    //
    void setRegister(size_t index, const as_value& val);

    //
    //
    CallFrame& pushCallFrame(UserFunction& f);

    //
    void popCallFrame();

    //
    CallFrame& currentCall();

    bool calling() const {
        return !_callStack.empty();
    }

    void dumpState(std::ostream& o, size_t limit = 0);

    void setConstantPool(const ConstantPool *pool) { _constantPool = pool; }

    const ConstantPool *getConstantPool() const { return _constantPool; }

private:

        movie_root& _rootMovie;

        Global_as* _global;

        int _swfversion;

        typedef std::map<unsigned int, as_c_function_ptr> FuncMap;
        typedef std::map<unsigned int, FuncMap> AsNativeTable;
        AsNativeTable _asNativeTable;

        mutable string_table _stringTable;

        VirtualClock& _clock;

        SafeStack<as_value>     _stack;

    typedef boost::array<as_value, 4> GlobalRegisters;
    GlobalRegisters _globalRegisters;

        CallStack _callStack;

    std::auto_ptr<SharedObjectLibrary> _shLib;

    RNG _rng;

    const ConstantPool* _constantPool;
};

// @param lowerCaseHint if true the caller guarantees
//        that the lowercase equivalent of `str' is `str' again
//
inline ObjectURI
getURI(const VM& vm, const std::string& str, bool lowerCaseHint=false)
{
    lowerCaseHint=lowerCaseHint; // TODO pass hint to ObjectURI ctor
    // Possible optimization here is to directly compute
    // noCase value if VM version is < 7
    return ObjectURI((NSV::NamedStrings)vm.getStringTable().find(str));
}

inline ObjectURI
getURI(const VM&, NSV::NamedStrings s)
{
    // Possible optimization here is to directly
    // compute noCase values if VM version is < 7
    // (using the known information in NSV)
    return ObjectURI(s);
}

inline const std::string&
toString(VM& vm, const ObjectURI& uri)
{
        return uri.toString(vm.getStringTable());
}


class FrameGuard
{
public:

    FrameGuard(VM& vm, UserFunction& func)
        :
        _vm(vm),
        _callFrame(_vm.pushCallFrame(func))
    {
    }

    CallFrame& callFrame() {
        return _callFrame;
    }

    ~FrameGuard() {
        _vm.popCallFrame();
    }

private:
    VM& _vm;
    CallFrame& _callFrame;
};


//
//
void newAdd(as_value& op1, const as_value& op2, const VM& vm);

//
void subtract(as_value& op1, const as_value& op2, const VM& vm);

//
as_value newLessThan(const as_value& op1, const as_value& op2, const VM& vm);

//
//
//
bool equals(const as_value& a, const as_value& b, const VM& vm);

//
bool toBool(const as_value& v, const VM& vm);

//
double toNumber(const as_value& v, const VM& vm);

//
as_object* toObject(const as_value& v, VM& vm);

//
//
//
boost::int32_t toInt(const as_value& val, const VM& vm);

//
as_value& convertToNumber(as_value& v, const VM& vm);

//
as_value& convertToString(as_value& v, const VM& vm);

//
as_value& convertToBoolean(as_value& v, const VM& vm);

//
as_value& convertToPrimitive(as_value& v, const VM& vm);

} // namespace gnash

#endif

// Local Variables:
// mode: C++
// indent-tabs-mode: t
// End: