[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Gnash-commit] /srv/bzr/gnash/trunk r11630: Move AS3-specific classe
|
From: |
strk |
|
Subject: |
Re: [Gnash-commit] /srv/bzr/gnash/trunk r11630: Move AS3-specific classes into libcore/abc and under the abc namespace. |
|
Date: |
Mon, 16 Nov 2009 19:25:04 +0100 |
libcore/event_id.cpp:40: error: wrong number of template arguments (2, should
be 4)
libcore/event_id.cpp:40: error: invalid type in declaration before ';' token
and others...
--strk;
On Mon, Nov 16, 2009 at 04:50:35PM +0100, Benjamin Wolsey wrote:
> ------------------------------------------------------------
> revno: 11630 [merge]
> committer: Benjamin Wolsey <address@hidden>
> branch nick: trunk
> timestamp: Mon 2009-11-16 16:50:35 +0100
> message:
> Move AS3-specific classes into libcore/abc and under the abc namespace.
> This may reduce the confusion about what parts of Gnash are for what
> purpose.
> added:
> libcore/abc/
> renamed:
> libcore/abc_function.cpp => libcore/abc/abc_function.cpp
> libcore/abc_function.h => libcore/abc/abc_function.h
> libcore/asBoundValues.h => libcore/abc/BoundValues.h
> libcore/asClass.cpp => libcore/abc/Class.cpp
> libcore/asClass.h => libcore/abc/Class.h
> libcore/asException.h => libcore/abc/asException.h
> libcore/asMethod.cpp => libcore/abc/Method.cpp
> libcore/asMethod.h => libcore/abc/Method.h
> libcore/parser/AbcBlock.cpp => libcore/abc/AbcBlock.cpp
> libcore/parser/AbcBlock.h => libcore/abc/AbcBlock.h
> libcore/vm/MultiName.h => libcore/abc/MultiName.h
> modified:
> libcore/ClassHierarchy.cpp
> libcore/ClassHierarchy.h
> libcore/Makefile.am
> libcore/Namespace.cpp
> libcore/Namespace.h
> libcore/as_object.cpp
> libcore/as_object.h
> libcore/parser/Makefile.am
> libcore/vm/Machine.cpp
> libcore/vm/Machine.h
> libcore/vm/Makefile.am
> libcore/abc/abc_function.cpp
> libcore/abc/abc_function.h
> libcore/abc/BoundValues.h
> libcore/abc/Class.cpp
> libcore/abc/Class.h
> libcore/abc/asException.h
> libcore/abc/Method.cpp
> libcore/abc/Method.h
> libcore/abc/AbcBlock.cpp
> libcore/abc/AbcBlock.h
> === modified file 'libcore/ClassHierarchy.cpp'
> --- a/libcore/ClassHierarchy.cpp 2009-11-16 11:16:48 +0000
> +++ b/libcore/ClassHierarchy.cpp 2009-11-16 14:42:56 +0000
> @@ -23,7 +23,7 @@
> #include "ClassHierarchy.h"
> #include "as_function.h"
> #include "builtin_function.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "Global_as.h"
> #include "Object.h"
> #include "extension.h"
>
> === modified file 'libcore/ClassHierarchy.h'
> --- a/libcore/ClassHierarchy.h 2009-11-13 08:19:10 +0000
> +++ b/libcore/ClassHierarchy.h 2009-11-16 14:42:56 +0000
> @@ -25,13 +25,13 @@
>
> #include "as_object.h"
> #include "SafeStack.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "Namespace.h"
>
> #ifdef ENABLE_AVM2
> -# include "asBoundValues.h"
> +# include "BoundValues.h"
> # include "asException.h"
> -# include "asMethod.h"
> +# include "Method.h"
> #endif
>
> #include <list>
> @@ -207,8 +207,8 @@
> return &mNamespaces[uri];
> }
>
> - /// Create a new asClass object for use.
> - asClass* newClass() {
> + /// Create a new abc::Class object for use.
> + abc::Class* newClass() {
> mClassMemory.grow(1);
> return &mClassMemory.top(0);
> }
> @@ -220,18 +220,18 @@
> return &mExceptionMemory.top(0);
> }
>
> - /// Create a new asMethod object for use.
> - asMethod* newMethod() {
> + /// Create a new Method object for use.
> + abc::Method* newMethod() {
> mMethodMemory.grow(1);
> return &mMethodMemory.top(0);
> }
>
> - asBoundValue* newBoundValue() {
> + abc::BoundValue* newBoundValue() {
> mBoundValueMemory.grow(1);
> return &mBoundValueMemory.top(0);
> }
>
> - asBoundAccessor* newBoundAccessor() {
> + abc::BoundAccessor* newBoundAccessor() {
> mBoundAccessorMemory.grow(1);
> return &mBoundAccessorMemory.top(0);
> }
> @@ -249,13 +249,13 @@
> namespacesContainer mNamespaces;
> SafeStack<Namespace> mAnonNamespaces;
> Namespace* mGlobalNamespace;
> - SafeStack<asClass> mClassMemory;
> + SafeStack<abc::Class> mClassMemory;
>
> #ifdef ENABLE_AVM2
> SafeStack<asException> mExceptionMemory;
> - SafeStack<asMethod> mMethodMemory;
> - SafeStack<asBoundValue> mBoundValueMemory;
> - SafeStack<asBoundAccessor> mBoundAccessorMemory;
> + SafeStack<abc::Method> mMethodMemory;
> + SafeStack<abc::BoundValue> mBoundValueMemory;
> + SafeStack<abc::BoundAccessor> mBoundAccessorMemory;
> #endif
> };
>
>
> === modified file 'libcore/Makefile.am'
> --- a/libcore/Makefile.am 2009-11-16 12:29:31 +0000
> +++ b/libcore/Makefile.am 2009-11-16 14:42:56 +0000
> @@ -32,6 +32,7 @@
> -I$(top_srcdir)/libnet \
> -I$(top_srcdir)/backend \
> -I$(top_srcdir)/libcore/swf \
> + -I$(top_srcdir)/libcore/abc \
> -I$(top_srcdir)/libcore/asobj \
> -I$(top_srcdir)/libcore/asobj/flash \
> -I$(top_srcdir)/libcore/parser \
> @@ -129,7 +130,7 @@
> styles.cpp \
> Timers.cpp \
> RGBA.cpp \
> - asClass.cpp \
> + abc/Class.cpp \
> MovieFactory.cpp \
> MovieLoader.cpp \
> Namespace.cpp \
> @@ -138,8 +139,9 @@
>
> if ENABLE_AVM2
> libgnashcore_la_SOURCES += \
> - abc_function.cpp \
> - asMethod.cpp \
> + abc/abc_function.cpp \
> + abc/Method.cpp \
> + abc/AbcBlock.cpp \
> $(NULL)
> endif
>
> @@ -213,10 +215,12 @@
> if ENABLE_AVM2
> noinst_HEADERS += \
> swf/DoABCTag.h \
> - abc_function.h \
> - asMethod.h \
> - asException.h \
> - asBoundValues.h \
> + abc/abc_function.h \
> + abc/Method.h \
> + abc/asException.h \
> + abc/BoundValues.h \
> + abc/AbcBlock.h \
> + abc/MultiName.h \
> $(NULL)
> endif
>
> @@ -265,7 +269,7 @@
> RGBA.h \
> Geometry.h \
> Video.h \
> - asClass.h \
> + abc/Class.h \
> Namespace.h \
> $(NULL)
>
>
> === modified file 'libcore/Namespace.cpp'
> --- a/libcore/Namespace.cpp 2009-11-13 14:22:20 +0000
> +++ b/libcore/Namespace.cpp 2009-11-16 14:42:56 +0000
> @@ -32,7 +32,7 @@
> void
> Namespace::stubPrototype(ClassHierarchy& ch, string_table::key name)
> {
> - asClass *pClass = ch.newClass();
> + abc::Class *pClass = ch.newClass();
> pClass->setName(name);
> addClass(name, pClass);
> }
>
> === modified file 'libcore/Namespace.h'
> --- a/libcore/Namespace.h 2009-11-13 14:22:20 +0000
> +++ b/libcore/Namespace.h 2009-11-16 14:42:56 +0000
> @@ -23,7 +23,9 @@
>
> // Forward declarations
> namespace gnash {
> - class asClass;
> + namespace abc {
> + class Class;
> + }
> class ClassHierarchy;
> class string_table;
> }
> @@ -73,7 +75,7 @@
>
> /// Add a class to the namespace. The namespace stores this, but
> /// does not take ownership. (So don't delete it.)
> - bool addClass(string_table::key name, asClass *a)
> + bool addClass(string_table::key name, abc::Class *a)
> {
> if (getClassInternal(name)) return false;
> _classes[static_cast<std::size_t>(name)] = a;
> @@ -84,11 +86,11 @@
>
> /// Get the named class. Returns NULL if information is not known
> /// about the class. (Stubbed classes still return NULL here.)
> - asClass* getClass(string_table::key name)
> + abc::Class* getClass(string_table::key name)
> {
> if (mRecursePrevent) return NULL;
>
> - asClass* found = getClassInternal(name);
> + abc::Class* found = getClassInternal(name);
>
> if (found || !getParent()) return found;
>
> @@ -118,7 +120,7 @@
> string_table::key _uri;
> string_table::key _prefix;
>
> - typedef std::map<string_table::key, asClass*> container;
> + typedef std::map<string_table::key, abc::Class*> container;
> container _classes;
> mutable bool mRecursePrevent;
>
> @@ -126,7 +128,7 @@
> bool _protected;
> bool _package;
>
> - asClass* getClassInternal(string_table::key name) const
> + abc::Class* getClassInternal(string_table::key name) const
> {
> container::const_iterator i;
>
>
> === added directory 'libcore/abc'
> === renamed file 'libcore/parser/AbcBlock.cpp' => 'libcore/abc/AbcBlock.cpp'
> --- a/libcore/parser/AbcBlock.cpp 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/AbcBlock.cpp 2009-11-16 14:42:56 +0000
> @@ -24,7 +24,7 @@
> #include "VM.h"
> #include "log.h"
> #include "ClassHierarchy.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "namedStrings.h"
> #include "CodeStream.h"
> #include "action_buffer.h"
> @@ -36,7 +36,7 @@
> namespace abc {
>
> bool
> -Trait::finalize(AbcBlock *pBlock, asClass *pClass, bool do_static)
> +Trait::finalize(AbcBlock *pBlock, abc::Class *pClass, bool do_static)
> {
> log_abc("Finalize class %s (%s), trait kind: %s",
> pBlock->_stringTable->value(pClass->getName()), pClass, _kind);
> @@ -47,7 +47,7 @@
> case KIND_CONST:
> {
> // Validate the type.
> - asClass *pType;
> + abc::Class *pType;
> if (_typeIndex) {
> log_abc("Trait type: %s",
> pBlock->_stringPool[
> @@ -115,7 +115,7 @@
> }
>
> bool
> -Trait::finalize_mbody(AbcBlock *pBlock, asMethod *pMethod)
> +Trait::finalize_mbody(AbcBlock *pBlock, Method *pMethod)
> {
> log_abc("Finalizing method trait: kind %s", _kind);
> switch (_kind)
> @@ -124,7 +124,7 @@
> case KIND_CONST:
> {
> // Validate the type.
> - asClass *pType;
> + abc::Class *pType;
> if (_typeIndex) {
> pType =
> pBlock->locateClass(pBlock->_multinamePool[_typeIndex]);
> }
> @@ -329,7 +329,7 @@
> {
>
> std::for_each(_classes.begin(), _classes.end(),
> - std::mem_fun(&asClass::initPrototype));
> + std::mem_fun(&abc::Class::initPrototype));
>
> // The last (entry) script has Global as its prototype.
> // This can be deduced because the global classes are initialized with a
> @@ -341,10 +341,10 @@
> // scripts have Global as a target object (prototype), so for now we
> // will do that.
> std::for_each(_scripts.begin(), _scripts.end(),
> - boost::bind(&asClass::setPrototype, _1, mach->global()));
> + boost::bind(&abc::Class::setPrototype, _1, mach->global()));
>
> std::for_each(_methods.begin(), _methods.end(),
> - boost::bind(&asMethod::initPrototype, _1, mach));
> + boost::bind(&Method::initPrototype, _1, mach));
>
> std::for_each(_traits.begin(), _traits.end(),
> boost::bind(&Trait::finalize, _1, this));
> @@ -405,7 +405,7 @@
> log_abc("Namespace: %s AbcURI=%u URI=%u.", name, ABCName, global_key);
> }
>
> -asClass*
> +abc::Class*
> AbcBlock::locateClass(const std::string& className)
> {
>
> @@ -436,10 +436,10 @@
>
> }
>
> -asClass*
> +abc::Class*
> AbcBlock::locateClass(MultiName& m)
> {
> - asClass* found = 0;
> + abc::Class* found = 0;
>
> if (m.getNamespace())
> {
> @@ -798,7 +798,7 @@
> for (unsigned int i = 0; i < count; ++i)
> {
> log_abc(" Reading method %u", i);
> - asMethod *pMethod = mCH->newMethod();
> + Method *pMethod = mCH->newMethod();
> pMethod->setMethodID(i);
> _methods[i] = pMethod;
> boost::uint32_t param_count = _stream->read_V32();
> @@ -826,7 +826,7 @@
> // TODO: this can be 'void', which clearly isn't a class, so this
> // seems bogus. As setReturnType is a no-op, we should log it
> // and ignore it.
> - asClass* rtClass = locateClass(_multinamePool[return_type]);
> + abc::Class* rtClass = locateClass(_multinamePool[return_type]);
> if (!rtClass) {
> log_abc(_("ABC: Unknown return type."));
> }
> @@ -851,7 +851,7 @@
>
> // A value of 0 is legitimate, meaning 'any (*)'.
> if (ptype) {
> - asClass* param_type = locateClass(_multinamePool[ptype]);
> + abc::Class* param_type = locateClass(_multinamePool[ptype]);
>
> if (!param_type) {
> log_abc((_("ABC: Unknown parameter type.")));
> @@ -939,7 +939,7 @@
> log_abc("There are %u instances.", count);
> _classes.resize(count);
> for (size_t i = 0; i < count; ++i) {
> - asClass* pClass;
> + abc::Class* pClass;
> //Read multiname index.
> boost::uint32_t index = _stream->read_V32();
> // 0 is allowed as a name, typically for the last entry.
> @@ -996,7 +996,7 @@
> pClass->setSuper(mTheObject);
> }
> else {
> - asClass *pSuper =
> locateClass(_multinamePool[super_index]);
> + abc::Class *pSuper =
> locateClass(_multinamePool[super_index]);
> if (!pSuper)
> {
> log_error(_("ABC: Super type not found (%s)"),
> @@ -1061,7 +1061,7 @@
> log_error(_("ABC: Bad name for interface."));
> return false;
> }
> - asClass *pInterface =
> locateClass(_multinamePool[i_index]);
> + abc::Class *pInterface =
> locateClass(_multinamePool[i_index]);
> // These may be undefined still, so don't check
> interface just yet.
> if (0) //!pInterface || !pInterface->isInterface())
> {
> @@ -1083,8 +1083,8 @@
> // Don't validate for previous owner.
> pClass->setConstructor(_methods[offset]);
>
> - /* Calling the asMethod::setOwner always results in a
> segmentation fault,
> - since it tries to modify asMethod.mPrototype, which is never
> + /* Calling the Method::setOwner always results in a
> segmentation fault,
> + since it tries to modify Method.mPrototype, which is never
> initialized. The parser seems to work ok without this call.*/
> // _methods[offset]->setOwner(pClass);
>
> @@ -1112,7 +1112,7 @@
> log_abc("There are %u classes.", count);
>
> for (size_t i = 0; i < count; ++i) {
> - asClass* pClass = _classes[i];
> + abc::Class* pClass = _classes[i];
> boost::uint32_t offset = _stream->read_V32();
> log_abc("Class %u(%s) static constructor index=%u", i, pClass,
> offset);
>
> @@ -1124,8 +1124,8 @@
> // Don't validate for previous owner.
> pClass->setStaticConstructor(_methods[offset]);
>
> - /* Calling the asMethod::setOwner always results in a
> segmentation fault,
> - since it tries to modify asMethod.mPrototype, which is never
> + /* Calling the Method::setOwner always results in a
> segmentation fault,
> + since it tries to modify Method.mPrototype, which is never
> initialized. The parser seems to work ok without this call.*/
> // _methods[offset]->setOwner(pClass);
>
> @@ -1152,7 +1152,7 @@
> _scripts.resize(count);
> for (unsigned int i = 0; i < count; ++i)
> {
> - asClass* pScript = mCH->newClass();
> + abc::Class* pScript = mCH->newClass();
> _scripts[i] = pScript;
>
> boost::uint32_t offset = _stream->read_V32();
> @@ -1164,8 +1164,8 @@
> return false;
> }
>
> - // Calling the asMethod::setOwner always results in a
> segmentation
> - // fault, since it tries to modify asMethod.mPrototype, which is
> never
> + // Calling the Method::setOwner always results in a segmentation
> + // fault, since it tries to modify Method.mPrototype, which is never
> // initialized. The parser seems to work ok without this call.
> // Don't validate for previous owner.
> // _methods[offset]->setOwner(pScript);
> @@ -1208,7 +1208,7 @@
> return false;
> }
>
> - asMethod& method = *_methods[offset];
> + Method& method = *_methods[offset];
>
> if (method.getBody()) {
> log_error(_("ABC: Only one body per method."));
> @@ -1260,7 +1260,7 @@
> pExcept->catchAny();
> }
> else {
> - asClass *pType =
> locateClass(_multinamePool[catch_type]);
> + abc::Class *pType =
> locateClass(_multinamePool[catch_type]);
> if (!pType) {
>
> log_error(_("ABC: Unknown type of
> object to catch. (%s)"),
> @@ -1359,7 +1359,7 @@
> IF_VERBOSE_PARSE(_methods[i]->print_body());
> }
> /* The loop below causes a segmentation fault, because it tries to modify
> - asMethod.mPrototype, which is never initialized. The parser seems
> + Method.mPrototype, which is never initialized. The parser seems
> to work ok without this call.*/
> /* std::vector<Trait*>::iterator i = mTraits.begin();
> for ( ; i != mTraits.end(); ++i)
>
> === renamed file 'libcore/parser/AbcBlock.h' => 'libcore/abc/AbcBlock.h'
> --- a/libcore/parser/AbcBlock.h 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/AbcBlock.h 2009-11-16 14:42:56 +0000
> @@ -35,14 +35,16 @@
> namespace abc {
> class AbcBlock;
> class Machine;
> + class Class;
> + class Method;
> }
> class SWFStream; // for read signature
> class ClassHierarchy;
> - class asMethod;
> - class asClass;
> }
>
> namespace gnash {
> +
> +/// ABC-only resources for parsing and execution.
> namespace abc {
>
> class Trait
> @@ -73,11 +75,11 @@
> string_table::key _globalName;
>
> Namespace* _namespace;
> - asMethod* _method;
> + Method* _method;
> bool _valueSet;
>
> - asClass* _classTarget;
> - asMethod* _methodTarget;
> + abc::Class* _classTarget;
> + Method* _methodTarget;
> bool _static;
>
> Trait()
> @@ -100,16 +102,16 @@
>
> bool read(SWFStream* in, AbcBlock *pBlock);
>
> - bool finalize(AbcBlock* pBlock, asClass* pClass, bool do_static);
> -
> - bool finalize_mbody(AbcBlock* pBlock, asMethod* pMethod);
> -
> - void set_target(asClass* pClass, bool do_static) {
> + bool finalize(AbcBlock* pBlock, abc::Class* pClass, bool do_static);
> +
> + bool finalize_mbody(AbcBlock* pBlock, Method* pMethod);
> +
> + void set_target(abc::Class* pClass, bool do_static) {
> _classTarget = pClass;
> _static = do_static;
> }
>
> - void set_target(asMethod *pMethod) {
> + void set_target(Method *pMethod) {
> _classTarget = 0;
> _methodTarget = pMethod;
> }
> @@ -138,12 +140,13 @@
>
> }
>
> +
> +/// The ActionScript bytecode of a single ABC tag in a SWF.
> +//
> /// ABC blocks have their own "names" for all resources. In Gnash, these are
> /// a string table index. They are different from global names. These are
> used
> /// to locate resources inside the ABC block.
> //
> -/// Namespaces
> -//
> /// ABC blocks have a set of "namespace" resources. Some namespaces are
> /// private. We make these into anonymous namespaces.
> //
> @@ -230,9 +233,9 @@
>
> AbcBlock();
>
> - asClass* locateClass(MultiName &m);
> + abc::Class* locateClass(MultiName &m);
>
> - asClass* locateClass(const std::string& className);
> + abc::Class* locateClass(const std::string& className);
>
> abc::Trait &newTrait()
> {
> @@ -245,7 +248,7 @@
>
> void update_global_name(unsigned int multiname_index);
>
> - const std::vector<asClass*>& scripts() const {
> + const std::vector<abc::Class*>& scripts() const {
> return _scripts;
> }
>
> @@ -269,7 +272,7 @@
> return _doublePool[i];
> }
>
> - asMethod* methodPoolAt(size_t i) const {
> + Method* methodPoolAt(size_t i) const {
> checkBounds(i, _methods);
> return _methods[i];
> }
> @@ -279,7 +282,7 @@
> return _multinamePool[i];
> }
>
> - asClass* classPoolAt(size_t i) const {
> + abc::Class* classPoolAt(size_t i) const {
> checkBounds(i, _classes);
> return _classes[i];
> }
> @@ -329,16 +332,16 @@
> std::vector<string_table::key> _stringPoolTableIDs;
> std::vector<Namespace*> _namespacePool;
> std::vector<NamespaceSet> _namespaceSetPool;
> - std::vector<asMethod*> _methods;
> + std::vector<Method*> _methods;
> std::vector<MultiName> _multinamePool;
> - std::vector<asClass*> _classes;
> - std::vector<asClass*> _scripts;
> - std::vector<abc::Trait*> _traits;
> + std::vector<Class*> _classes;
> + std::vector<Class*> _scripts;
> + std::vector<Trait*> _traits;
>
> string_table* _stringTable;
> SWFStream* _stream; // Not stored beyond one read.
>
> - asClass *mTheObject;
> + abc::Class *mTheObject;
> ClassHierarchy *mCH;
>
> boost::uint32_t mVersion;
>
> === renamed file 'libcore/asBoundValues.h' => 'libcore/abc/BoundValues.h'
> --- a/libcore/asBoundValues.h 2009-05-14 10:30:48 +0000
> +++ b/libcore/abc/BoundValues.h 2009-11-16 14:42:56 +0000
> @@ -19,43 +19,45 @@
> #define GNASH_AS_BOUND_VALUES_H
>
> namespace gnash {
> -
> -class asBoundValue;
> -
> -class asBoundAccessor
> +namespace abc {
> +
> +class BoundValue;
> +
> +class BoundAccessor
> {
> public:
> - bool setGetter(asMethod *p) { mGetter = p; return true; }
> - bool setSetter(asMethod *p) { _setter = p; return true; }
> - bool setValue(asBoundValue *p) { mValue = p; return true; }
> + bool setGetter(Method *p) { mGetter = p; return true; }
> + bool setSetter(Method *p) { _setter = p; return true; }
> + bool setValue(BoundValue *p) { mValue = p; return true; }
>
> - asBoundValue* getValue() { return mValue; }
> - asMethod *getGetter() { return mGetter; }
> - asMethod *getSetter() { return _setter; }
> + BoundValue* getValue() { return mValue; }
> + Method *getGetter() { return mGetter; }
> + Method *getSetter() { return _setter; }
>
> private:
> - asMethod *mGetter;
> - asMethod *_setter;
> - asBoundValue *mValue;
> + Method *mGetter;
> + Method *_setter;
> + BoundValue *mValue;
> };
>
> -class asBoundValue
> +class BoundValue
> {
> public:
> - asBoundValue() : mConst(false), mValue()
> + BoundValue() : mConst(false), mValue()
> { mValue.set_undefined(); }
> void setValue(as_value &v) { mValue = v; }
> as_value getCurrentValue() { return mValue; }
>
> - void setType(asClass *t) { mType = t; }
> - asClass *getType() { return mType; }
> + void setType(Class *t) { mType = t; }
> + Class *getType() { return mType; }
>
> private:
> bool mConst;
> - asClass *mType;
> + Class *mType;
> as_value mValue;
> };
>
> +} // namespace abc
> } // namespace gnash
>
> #endif
>
> === renamed file 'libcore/asClass.cpp' => 'libcore/abc/Class.cpp'
> --- a/libcore/asClass.cpp 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/Class.cpp 2009-11-16 14:42:56 +0000
> @@ -19,7 +19,7 @@
> #include "gnashconfig.h"
> #endif
>
> -#include "asClass.h"
> +#include "Class.h"
> #include "as_object.h"
> #include "ClassHierarchy.h"
> #include "VM.h"
> @@ -29,16 +29,17 @@
> #include "Global_as.h"
>
> #ifdef ENABLE_AVM2
> -#include "asMethod.h"
> +#include "Method.h"
> #include "abc_function.h"
> #endif
>
> namespace gnash {
> +namespace abc {
>
> #ifdef ENABLE_AVM2
> bool
> -asClass::addValue(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asClass *type, as_value& val, bool isconst,
> +Class::addValue(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Class *type, as_value& val, bool isconst,
> bool isstatic)
> {
> Global_as* g = VM::get().getGlobal();
> @@ -65,25 +66,25 @@
> return true;
> }
> bool
> -asClass::addMemberClass(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asClass *type, bool isstatic)
> +Class::addMemberClass(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Class *type, bool isstatic)
> {
> return addSlot(name, ns, slotId, type, isstatic);
> }
>
> bool
> -asClass::addSlotFunction(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asMethod *method, bool isstatic)
> +Class::addSlotFunction(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Method *method, bool isstatic)
> {
> - asClass a;
> + Class a;
> a.setName(NSV::CLASS_FUNCTION);
> as_value b(method->getPrototype());
> return addValue(name, ns, slotId, &a, b, false, isstatic);
> }
>
> bool
> -asClass::addSlot(string_table::key name, Namespace* ns,
> - boost::uint32_t slotId, asClass* /*type*/, bool /*isstatic*/)
> +Class::addSlot(string_table::key name, Namespace* ns,
> + boost::uint32_t slotId, Class* /*type*/, bool /*isstatic*/)
> {
> string_table::key nsname = ns ? ns->getURI() : 0;
>
> @@ -98,8 +99,8 @@
> }
>
> bool
> -asClass::addMethod(string_table::key name, Namespace* /*ns*/,
> - asMethod* method, bool /*isstatic*/)
> +Class::addMethod(string_table::key name, Namespace* /*ns*/,
> + Method* method, bool /*isstatic*/)
> {
> as_value val = new abc::abc_function(method,
> getVM(*_prototype).getMachine());
> @@ -114,7 +115,7 @@
>
>
> bool
> -asClass::addGetter(string_table::key name, Namespace *ns, asMethod *method,
> +Class::addGetter(string_table::key name, Namespace *ns, Method *method,
> bool isstatic)
> {
> string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
> @@ -135,7 +136,7 @@
> }
>
> bool
> -asClass::addSetter(string_table::key name, Namespace *ns, asMethod *method,
> +Class::addSetter(string_table::key name, Namespace *ns, Method *method,
> bool isstatic)
> {
> string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
> @@ -157,7 +158,7 @@
>
> #if 0 // TODO
> void
> -asClass::buildFromPrototype(as_object *o, string_table::key name,
> +Class::buildFromPrototype(as_object *o, string_table::key name,
> ClassHierarchy *pCH)
> {
> setName(name);
> @@ -184,8 +185,8 @@
> }
>
> bool
> -asClass::addValue(string_table::key name, Namespace *ns, boost::uint32_t
> slotId,
> - asClass *type, as_value& val, bool isconst, bool isstatic,
> +Class::addValue(string_table::key name, Namespace *ns, boost::uint32_t
> slotId,
> + Class *type, as_value& val, bool isconst, bool isstatic,
> ClassHierarchy *CH)
> {
> asBoundValue *bv = CH->newBoundValue();
> @@ -197,8 +198,8 @@
> }
>
> bool
> -asClass::addSlot(string_table::key name, Namespace *ns, boost::uint32_t
> slotId,
> - asClass *type, bool isstatic, ClassHierarchy *CH)
> +Class::addSlot(string_table::key name, Namespace *ns, boost::uint32_t slotId,
> + Class *type, bool isstatic, ClassHierarchy *CH)
> {
> asBoundValue *bv = CH->newBoundValue();
> bv->setType(type);
> @@ -208,7 +209,7 @@
> }
>
> bool
> -asClass::addMethod(string_table::key name, Namespace *ns, asMethod *method,
> +Class::addMethod(string_table::key name, Namespace *ns, Method *method,
> bool isstatic)
> {
> if (!isstatic)
> @@ -218,8 +219,8 @@
> }
>
> bool
> -asClass::addMemberClass(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asClass *type, bool isstatic)
> +Class::addMemberClass(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Class *type, bool isstatic)
> {
> if (!isstatic)
> return addBinding(name, asBinding(ns, type, slotId, isstatic));
> @@ -228,8 +229,8 @@
>
> // TODO: Figure out how this differs from addMethod
> bool
> -asClass::addSlotFunction(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asMethod *method, bool isstatic)
> +Class::addSlotFunction(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Method *method, bool isstatic)
> {
> if (!isstatic)
> return addBinding(name, asBinding(ns, method, slotId,
> isstatic));
> @@ -239,4 +240,5 @@
>
> #endif
>
> -} /* namespace gnash */
> +} // namespace abc
> +} // namespace gnash
>
> === renamed file 'libcore/asClass.h' => 'libcore/abc/Class.h'
> --- a/libcore/asClass.h 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/Class.h 2009-11-16 14:42:56 +0000
> @@ -28,8 +28,8 @@
> #include <iostream>
> #include "string_table.h"
> #include "as_value.h"
> +#include "as_object.h"
> #include "Property.h"
> -#include "as_function.h"
>
> #ifdef ENABLE_AVM2
> # include "CodeStream.h"
> @@ -41,31 +41,31 @@
> class Machine;
> class MultiName;
> class abc_function;
> + class BoundValue;
> + class BoundAccessor;
> + class Method;
> + class Class;
> + typedef Property Binding;
> }
> - class as_function;
> class Namespace;
> - class asMethod;
> - class asClass;
> - typedef Property asBinding;
> - class asBoundValue;
> - class asBoundAccessor;
> class ClassHierarchy;
> class Property;
> }
>
> namespace gnash {
> -
> +namespace abc {
> +
> /// A class to represent, abstractly, ActionScript prototypes.
> ///
> /// This class is intended to be able to capture the structure of an
> /// ActionScript prototype as a type, rather than as an object. This is
> /// contrary to the spirit of ActionScript as a dynamic language, but it is
> /// incredibly helpful to an interpreter for that language.
> -class asClass
> +class Class
> {
> public:
>
> - asClass()
> + Class()
> :
> _prototype(0),
> _final(false),
> @@ -104,27 +104,27 @@
> #ifdef ENABLE_AVM2
>
> bool addValue(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type, as_value& val,
> + boost::uint32_t slotID, Class *type, as_value& val,
> bool isconst, bool isstatic);
>
> bool addSlot(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type, bool isstatic);
> -
> - bool addMethod(string_table::key name, Namespace *ns, asMethod *method,
> - bool isstatic);
> -
> - bool addGetter(string_table::key name, Namespace *ns, asMethod *method,
> - bool isstatic);
> -
> - bool addSetter(string_table::key name, Namespace *ns, asMethod *method,
> + boost::uint32_t slotID, Class *type, bool isstatic);
> +
> + bool addMethod(string_table::key name, Namespace *ns, Method *method,
> + bool isstatic);
> +
> + bool addGetter(string_table::key name, Namespace *ns, Method *method,
> + bool isstatic);
> +
> + bool addSetter(string_table::key name, Namespace *ns, Method *method,
> bool isstatic);
>
> bool addMemberClass(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type, bool isstatic);
> + boost::uint32_t slotID, Class *type, bool isstatic);
>
> // TODO: Figure out how this differs from addMethod
> bool addSlotFunction(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asMethod *method, bool isstatic);
> + boost::uint32_t slotID, Method *method, bool isstatic);
>
> /// Is the class final?
> bool isFinal() const { return _final; }
> @@ -182,28 +182,28 @@
> }
>
> /// What is the type of our parent class?
> - asClass* getSuper() const { return _super; }
> + Class* getSuper() const { return _super; }
>
> /// We implement this interface.
> - void pushInterface(asClass* p) { _interfaces.push_back(p); }
> + void pushInterface(Class* p) { _interfaces.push_back(p); }
>
> /// This is our constructor.
> - void setConstructor(asMethod *m) { _constructor = m; }
> - asMethod *getConstructor() { return _constructor; }
> + void setConstructor(Method *m) { _constructor = m; }
> + Method *getConstructor() { return _constructor; }
>
> - void setStaticConstructor(asMethod *m) { _staticConstructor = m; }
> + void setStaticConstructor(Method *m) { _staticConstructor = m; }
>
> - asMethod* getStaticConstructor() const {
> + Method* getStaticConstructor() const {
> return _staticConstructor;
> }
>
> - void setSuper(asClass *p) { _super = p; }
> + void setSuper(Class *p) { _super = p; }
>
> - /// Try to build an asClass object from just a prototype.
> + /// Try to build an Class object from just a prototype.
> void buildFro_prototype(as_object *o, string_table::key name,
> ClassHierarchy *);
>
> - asBinding *getBinding(string_table::key name)
> + Binding *getBinding(string_table::key name)
> {
> BindingContainer::iterator i;
> if (_bindings.empty()) return NULL;
> @@ -213,24 +213,24 @@
> return &i->second;
> }
>
> - asBinding* getGetBinding(as_value& v, abc::MultiName& n);
> - asBinding* getSetBinding(as_value& v, abc::MultiName& n);
> + Binding* getGetBinding(as_value& v, abc::MultiName& n);
> + Binding* getSetBinding(as_value& v, abc::MultiName& n);
> std::vector<abc::Trait> _traits;
>
> #endif
>
> private:
>
> - typedef std::map<string_table::key, asBinding> BindingContainer;
> + typedef std::map<string_table::key, Binding> BindingContainer;
>
> as_object *_prototype;
>
> - bool addBinding(string_table::key name, asBinding b)
> + bool addBinding(string_table::key name, Binding b)
> { _bindings[name] = b; return true; }
> - bool addStaticBinding(string_table::key name, asBinding b)
> + bool addStaticBinding(string_table::key name, Binding b)
> { _staticBindings[name] = b; return true; }
>
> - asBinding *getStaticBinding(string_table::key name)
> + Binding *getStaticBinding(string_table::key name)
> {
> BindingContainer::iterator i;
> if (_staticBindings.empty())
> @@ -246,11 +246,11 @@
> bool _dynamic;
> bool _interface;
> string_table::key _name;
> - std::list<asClass*> _interfaces;
> + std::list<Class*> _interfaces;
> Namespace* _protectedNs;
> - asClass* _super;
> - asMethod* _constructor;
> - asMethod* _staticConstructor;
> + Class* _super;
> + Method* _constructor;
> + Method* _staticConstructor;
>
> BindingContainer _bindings;
> BindingContainer _staticBindings;
> @@ -259,6 +259,7 @@
> bool _system;
> };
>
> +} // namespace abc
> } // namespace gnash
>
> #endif
>
> === renamed file 'libcore/asMethod.cpp' => 'libcore/abc/Method.cpp'
> --- a/libcore/asMethod.cpp 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/Method.cpp 2009-11-16 14:42:56 +0000
> @@ -19,16 +19,17 @@
> #include "gnashconfig.h"
> #endif
>
> -#include "asMethod.h"
> -#include "asClass.h"
> +#include "Method.h"
> +#include "Class.h"
> #include "CodeStream.h"
> #include "abc_function.h"
> #include "Global_as.h"
> #include "VM.h"
>
> namespace gnash {
> +namespace abc {
>
> -asMethod::asMethod()
> +Method::Method()
> :
> _methodID(0),
> _prototype(0),
> @@ -48,7 +49,7 @@
> }
>
> void
> -asMethod::print_body()
> +Method::print_body()
> {
> if (!_body) {
> log_parse("Method has no body.");
> @@ -64,9 +65,9 @@
> }
>
> void
> -asMethod::setOwner(asClass *pOwner)
> +Method::setOwner(Class *pOwner)
> {
> - log_debug("asMethod::setOwner");
> + log_debug("Method::setOwner");
> if (!_prototype) {
> log_debug("ERROR _prototype is null.");
> }
> @@ -74,14 +75,14 @@
> }
>
> void
> -asMethod::setReturnType(asClass* /*type*/)
> +Method::setReturnType(Class* /*type*/)
> {
> /* No-op */
> }
>
> bool
> -asMethod::addValue(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asClass *type, as_value& val, bool isconst)
> +Method::addValue(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Class *type, as_value& val, bool isconst)
> {
> Global_as* g = VM::get().getGlobal();
> if (val.is_object()) {
> @@ -105,7 +106,7 @@
> }
>
> bool
> -asMethod::addGetter(string_table::key name, Namespace *ns, asMethod *method)
> +Method::addGetter(string_table::key name, Namespace *ns, Method *method)
> {
> string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
>
> @@ -123,7 +124,7 @@
> }
>
> bool
> -asMethod::addSetter(string_table::key name, Namespace *ns, asMethod *method)
> +Method::addSetter(string_table::key name, Namespace *ns, Method *method)
> {
> string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
>
> @@ -141,15 +142,15 @@
> }
>
> bool
> -asMethod::addMemberClass(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asClass *type)
> +Method::addMemberClass(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Class *type)
> {
> return addSlot(name, ns, slotId, type);
> }
>
> bool
> -asMethod::addSlot(string_table::key name, Namespace* ns, boost::uint32_t
> slotId,
> - asClass */*type*/)
> +Method::addSlot(string_table::key name, Namespace* ns, boost::uint32_t
> slotId,
> + Class */*type*/)
> {
> string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
> int flags = PropFlags::dontDelete;
> @@ -159,33 +160,33 @@
> }
>
> bool
> -asMethod::addSlotFunction(string_table::key name, Namespace *ns,
> - boost::uint32_t slotId, asMethod *method)
> +Method::addSlotFunction(string_table::key name, Namespace *ns,
> + boost::uint32_t slotId, Method *method)
> {
> - asClass a;
> + Class a;
> a.setName(NSV::CLASS_FUNCTION);
> as_value b(method->getPrototype());
> return addValue(name, ns, slotId, &a, b, false);
> }
>
> void
> -asMethod::initPrototype(abc::Machine* machine)
> +Method::initPrototype(abc::Machine* machine)
> {
> _prototype = new abc::abc_function(this,machine);
> }
>
> bool
> -asMethod::addMethod(string_table::key /*name*/, Namespace* /*ns*/, asMethod*
> +Method::addMethod(string_table::key /*name*/, Namespace* /*ns*/, Method*
> /*method*/)
> {
> // string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
> // as_value val(method->getPrototype());
> -// as value val = new
> as_value(abc_function(asMethod->getBody,getVM(_prototype).getMachine()));
> +// as value val = new
> as_value(abc_function(Method->getBody,getVM(_prototype).getMachine()));
> // _prototype->init_member(name, val, PropFlags::readOnly |
> // PropFlags::dontDelete | PropFlags::dontEnum, nsname);
> // return true;
> return false;
> }
>
> -
> +} // namespace abc
> } // namespace gnash
>
> === renamed file 'libcore/asMethod.h' => 'libcore/abc/Method.h'
> --- a/libcore/asMethod.h 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/Method.h 2009-11-16 14:42:56 +0000
> @@ -34,26 +34,27 @@
> namespace abc {
> class Machine;
> class abc_function;
> + class Class;
> }
> class CodeStream;
> class as_object;
> - class asClass;
> }
>
> namespace gnash {
> +namespace abc {
>
> typedef Property asBinding;
>
> /// A class to represent, abstractly, an ActionScript method.
> ///
> /// Methods are unnamed until they are bound to an object.
> -class asMethod
> +class Method
> {
> public:
>
> - typedef std::list<asClass*> ArgumentList;
> + typedef std::list<Class*> ArgumentList;
>
> - asMethod();
> + Method();
>
> boost::uint32_t methodID() const {
> return _methodID;
> @@ -63,7 +64,7 @@
> _methodID = m;
> }
>
> - void initPrototype(abc::Machine* machine);
> + void initPrototype(Machine* machine);
>
> boost::uint32_t getMaxRegisters() { return _maxRegisters;}
>
> @@ -99,7 +100,7 @@
> return _scopeDepth;
> }
>
> - abc::abc_function* getPrototype() { return _prototype; }
> + abc_function* getPrototype() { return _prototype; }
>
> asBinding* getBinding(string_table::key name);
>
> @@ -123,45 +124,45 @@
> void setBody(CodeStream *b) { _body = b; }
>
> bool addValue(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type, as_value& val, bool
> isconst);
> + boost::uint32_t slotID, Class *type, as_value& val, bool
> isconst);
>
> bool addSlot(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type);
> -
> - bool addMethod(string_table::key name, Namespace *ns, asMethod *method);
> -
> - bool addGetter(string_table::key name, Namespace *ns, asMethod *method);
> -
> - bool addSetter(string_table::key name, Namespace *ns, asMethod *method);
> + boost::uint32_t slotID, Class *type);
> +
> + bool addMethod(string_table::key name, Namespace *ns, Method *method);
> +
> + bool addGetter(string_table::key name, Namespace *ns, Method *method);
> +
> + bool addSetter(string_table::key name, Namespace *ns, Method *method);
>
> bool addMemberClass(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asClass *type);
> + boost::uint32_t slotID, Class *type);
>
> bool addSlotFunction(string_table::key name, Namespace *ns,
> - boost::uint32_t slotID, asMethod *method);
> + boost::uint32_t slotID, Method *method);
>
> /// \brief
> /// Set the owner of this method.
> - void setOwner(asClass* s);
> + void setOwner(Class* s);
>
> /// \brief
> /// Get the unique identifier for the return type. 0 is 'anything'.
> /// (This is the value of any dynamic property.)
> /// Id reference: Type
> - asClass* getReturnType() const;
> + Class* getReturnType() const;
>
> /// Set the return type
> //
> /// TODO: This is currently a no-op, so find out what it's for and
> /// implement it.
> /// NB: the return type of a method can be * (any) or void, neither of
> - /// which are asClasses, so this may not be an appropriate way to
> + /// which are abc::Classes, so this may not be an appropriate way to
> /// handle return type.
> - void setReturnType(asClass* t);
> -
> - asMethod *getSuper();
> -
> - void setSuper(asMethod* s);
> + void setReturnType(Class* t);
> +
> + Method *getSuper();
> +
> + void setSuper(Method* s);
>
> /// \brief
> /// Is the method final? If so, it may not be overridden.
> @@ -219,7 +220,7 @@
> /// Push an argument of type t into the method definition
> //
> /// A value of 0 stands for 'any'.
> - void pushArgument(asClass* t) { _arguments.push_back(t); }
> + void pushArgument(Class* t) { _arguments.push_back(t); }
>
> /// Push an optional argument's default value.
> void pushOptional(const as_value& v) { _optionalArguments.push_back(v);
> }
> @@ -265,7 +266,7 @@
>
> boost::uint32_t _methodID;
>
> - abc::abc_function* _prototype;
> + abc_function* _prototype;
> int _minArguments;
> int _maxArguments;
> boost::uint32_t _bodyLength;
> @@ -285,6 +286,7 @@
>
> };
>
> +} // namespace abc
> } // namespace gnash
>
> #endif
>
> === renamed file 'libcore/vm/MultiName.h' => 'libcore/abc/MultiName.h'
> === renamed file 'libcore/abc_function.cpp' => 'libcore/abc/abc_function.cpp'
> --- a/libcore/abc_function.cpp 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/abc_function.cpp 2009-11-16 14:42:56 +0000
> @@ -17,14 +17,14 @@
>
> #include "log.h"
> #include "abc_function.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "fn_call.h"
> #include "Machine.h"
>
> namespace gnash {
> namespace abc {
>
> -abc_function::abc_function(asMethod* methodInfo, Machine* machine)
> +abc_function::abc_function(Method* methodInfo, Machine* machine)
> :
> as_function(*machine->global()),
> _methodInfo(methodInfo),
>
> === renamed file 'libcore/abc_function.h' => 'libcore/abc/abc_function.h'
> --- a/libcore/abc_function.h 2009-11-15 16:26:27 +0000
> +++ b/libcore/abc/abc_function.h 2009-11-16 14:42:56 +0000
> @@ -25,11 +25,11 @@
> #include "as_function.h"
> #include "as_value.h"
> #include "CodeStream.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "SafeStack.h"
> #include "as_object.h"
> #include "as_environment.h"
> -#include "asMethod.h"
> +#include "Method.h"
>
> namespace gnash {
> namespace abc {
> @@ -41,7 +41,7 @@
> {
>
> public:
> - abc_function(asMethod* methodInfo, Machine* machine);
> + abc_function(Method* methodInfo, Machine* machine);
>
> as_value operator()(const fn_call& fn);
>
> @@ -59,7 +59,7 @@
>
> private:
>
> - asMethod* _methodInfo;
> + Method* _methodInfo;
>
> Machine* _machine;
>
>
> === renamed file 'libcore/asException.h' => 'libcore/abc/asException.h'
> --- a/libcore/asException.h 2009-11-13 08:19:10 +0000
> +++ b/libcore/abc/asException.h 2009-11-16 14:42:56 +0000
> @@ -27,7 +27,7 @@
> void setEnd(boost::uint32_t i) { mEnd = i; }
> void setCatch(boost::uint32_t i) { mCatch = i; }
> void catchAny() { mCatchAny = true; }
> - void setCatchType(asClass* p) { mCatchType = p; }
> + void setCatchType(abc::Class* p) { mCatchType = p; }
> void setNamespace(Namespace* n) { _namespace = n; }
> void setName(string_table::key name) { _name = name; }
>
> @@ -36,7 +36,7 @@
> boost::uint32_t mEnd;
> boost::uint32_t mCatch;
> bool mCatchAny;
> - asClass *mCatchType;
> + abc::Class *mCatchType;
> Namespace *_namespace;
> string_table::key _name;
> };
>
> === modified file 'libcore/as_object.cpp'
> --- a/libcore/as_object.cpp 2009-11-16 12:34:46 +0000
> +++ b/libcore/as_object.cpp 2009-11-16 14:42:56 +0000
> @@ -44,7 +44,7 @@
> #include <boost/algorithm/string/case_conv.hpp>
> #include <utility> // for std::pair
> #include "namedStrings.h"
> -#include "asClass.h"
> +#include "Class.h"
>
>
> namespace gnash {
>
> === modified file 'libcore/as_object.h'
> --- a/libcore/as_object.h 2009-11-16 12:17:00 +0000
> +++ b/libcore/as_object.h 2009-11-16 14:42:56 +0000
> @@ -43,6 +43,7 @@
> namespace gnash {
> namespace abc {
> class Machine;
> + class Class;
> }
> class as_function;
> class MovieClip;
> @@ -51,7 +52,6 @@
> class VM;
> class IOChannel;
> class movie_root;
> - class asClass;
> class RunResources;
> class Global_as;
> }
> @@ -164,7 +164,7 @@
> ///
> class as_object : public GcResource
> {
> - friend class asClass;
> + friend class abc::Class;
> friend class abc::Machine;
>
> typedef std::set<std::pair<string_table::key, string_table::key> >
>
> === modified file 'libcore/parser/Makefile.am'
> --- a/libcore/parser/Makefile.am 2009-07-03 08:19:37 +0000
> +++ b/libcore/parser/Makefile.am 2009-11-16 14:01:20 +0000
> @@ -53,11 +53,6 @@
> sound_definition.cpp \
> sprite_definition.cpp
>
> -if ENABLE_AVM2
> -libgnashparser_la_SOURCES += \
> - AbcBlock.cpp
> -endif
> -
> noinst_HEADERS = \
> action_buffer.h \
> BitmapMovieDefinition.h \
> @@ -67,11 +62,6 @@
> sound_definition.h \
> sprite_definition.h
>
> -if ENABLE_AVM2
> -noinst_HEADERS += \
> - AbcBlock.h
> -endif
> -
> EXTENSIONS_API = \
> movie_definition.h \
> $(NULL)
>
> === modified file 'libcore/vm/Machine.cpp'
> --- a/libcore/vm/Machine.cpp 2009-11-16 12:34:46 +0000
> +++ b/libcore/vm/Machine.cpp 2009-11-16 14:42:56 +0000
> @@ -125,7 +125,7 @@
>
> }
>
> -inline asMethod*
> +inline Method*
> pool_method(boost::uint32_t index, AbcBlock* pool)
> {
> if (!pool) throw ASException();
> @@ -137,7 +137,7 @@
> }
> }
>
> -inline asClass*
> +inline Class*
> pool_class(boost::uint32_t index, AbcBlock* pool)
> {
> if (!pool) throw ASException();
> @@ -1228,7 +1228,7 @@
> {
> boost::int32_t method_index = mStream->read_V32();
> log_abc("Creating new abc_function: method
> index=%u",method_index);
> - asMethod *m = pool_method(method_index, mPoolObject);
> + Method *m = pool_method(method_index, mPoolObject);
> abc_function* new_function = m->getPrototype();
>
> push_stack(as_value(new_function));
> @@ -1328,7 +1328,7 @@
> /// ..., argN)
> case SWF::ABC_ACTION_CALLSTATIC:
> {
> - asMethod *m = pool_method(mStream->read_V32(),
> mPoolObject);
> + Method *m = pool_method(mStream->read_V32(),
> mPoolObject);
> boost::uint32_t argc = mStream->read_V32();
> as_function *func = m->getPrototype();
> ENSURE_OBJECT(_stack.top(argc));
> @@ -1701,7 +1701,7 @@
> {
> boost::uint32_t cid = mStream->read_V32();
> log_abc("Class index: %s", cid);
> - asClass *c = pool_class(cid, mPoolObject);
> + Class *c = pool_class(cid, mPoolObject);
> log_abc("Creating new class id=%u name=%s", c->getName(),
> mST.value(c->getName()));
>
> @@ -1712,7 +1712,7 @@
> new_class->set_prototype(base_class);
>
> //Create the class.
> - asMethod* scmethod = c->getStaticConstructor();
> + Method* scmethod = c->getStaticConstructor();
> // What if there isn't one?
> assert(scmethod);
>
> @@ -2907,7 +2907,7 @@
> }
>
> void
> -Machine::getMember(asClass* pDefinition, MultiName& name,
> +Machine::getMember(Class* pDefinition, MultiName& name,
> as_value& instance)
> {
> if (!instance.is_object())
> @@ -2931,7 +2931,7 @@
> }
>
> void
> -Machine::setMember(asClass *pDefinition, MultiName& name, as_value& instance,
> +Machine::setMember(Class *pDefinition, MultiName& name, as_value& instance,
> as_value& newvalue)
> {
> if (!instance.is_object())
> @@ -2988,13 +2988,13 @@
> return size;
> }
>
> -asClass *
> +Class *
> Machine::findSuper(as_value &v, bool find_for_primitive)
> {
> if (v.is_undefined() || v.is_null()) return NULL;
>
> if (v.is_object()) {
> - asClass *pProto = NULL; // TODO:
> v.to_object(*_global)->getClass();
> + Class *pProto = NULL; // TODO:
> v.to_object(*_global)->getClass();
> return pProto ? pProto->getSuper() : NULL;
> }
>
> @@ -3135,9 +3135,9 @@
> {
> mPoolObject = pool_block;
> log_debug("Getting entry script.");
> - asClass* start_script = pool_block->scripts().back();
> + Class* start_script = pool_block->scripts().back();
> log_debug("Getting constructor.");
> - asMethod* constructor = start_script->getConstructor();
> + Method* constructor = start_script->getConstructor();
> clearRegisters(constructor->getMaxRegisters());
> log_debug("Loading code stream.");
> mStream = constructor->getBody();
> @@ -3149,7 +3149,7 @@
> //TODO: There is probably a better way to do this, once we understand what
> the VM is supposed
> //todo, this should be fixed.
> as_value
> -Machine::executeFunction(asMethod* method, const fn_call& fn)
> +Machine::executeFunction(Method* method, const fn_call& fn)
> {
>
> //TODO: Figure out a good way to use the State object to handle
> @@ -3211,7 +3211,7 @@
>
> log_debug("instantiateClass: class name %s", className);
>
> - asClass* cl = mPoolObject->locateClass(className);
> + Class* cl = mPoolObject->locateClass(className);
> if (!cl)
> {
> /// This seems like a big error.
> @@ -3219,7 +3219,7 @@
> return;
> }
>
> - asMethod* ctor = cl->getConstructor();
> + Method* ctor = cl->getConstructor();
>
> if (!ctor) {
> log_error("Class found has no constructor, can't instantiate "
>
> === modified file 'libcore/vm/Machine.h'
> --- a/libcore/vm/Machine.h 2009-11-15 16:26:27 +0000
> +++ b/libcore/vm/Machine.h 2009-11-16 14:42:56 +0000
> @@ -23,7 +23,7 @@
> #include <sstream>
> #include "SafeStack.h"
> #include "as_value.h"
> -#include "asClass.h"
> +#include "Class.h"
> #include "SWF.h"
> #include "as_environment.h"
> #include "VM.h"
> @@ -46,6 +46,8 @@
>
> namespace abc {
>
> +/// The virtual machine for executing ABC (ActionScript Bytecode).
> +//
> /// This machine is intended to work without relying on the C++ call stack,
> /// by resetting its Stream and Stack members (actually, by limiting the
> stack)
> /// to make function calls, rather than calling them directly in C++.
> @@ -97,7 +99,7 @@
> /// the stack.
> ///
> /// @param name
> - /// A partially filled asBoundName, this should be the id
> + /// A partially filled MultiName, this should be the id
> /// from the stream.
> ///
> /// @param initial
> @@ -118,7 +120,7 @@
> ///
> /// @return
> /// Null if the superclass was not found, or the superclass.
> - asClass* findSuper(as_value& obj, bool find_primitive);
> + Class* findSuper(as_value& obj, bool find_primitive);
>
> /// Get a member from an object.
> ///
> @@ -136,7 +138,7 @@
> /// This returns the value, but on the stack.
> /// (Since the return value is not known until after control has left
> /// the caller of this, it's impossible to return a meaningful value.
> - void getMember(asClass* pDefinition, MultiName& name,
> + void getMember(Class* pDefinition, MultiName& name,
> as_value& source);
>
> /// Set a member in an object.
> @@ -155,9 +157,9 @@
> ///
> /// @return
> /// Nothing.
> - void setMember(asClass*, MultiName&, as_value& target, as_value& val);
> + void setMember(Class*, MultiName&, as_value& target, as_value& val);
>
> - asBinding* findProperty(MultiName&) { return NULL; }
> + Binding* findProperty(MultiName&) { return NULL; }
>
> void execute();
>
> @@ -236,7 +238,7 @@
>
> void initMachine(AbcBlock* pool_block);
>
> - as_value executeFunction(asMethod* function, const fn_call& fn);
> + as_value executeFunction(Method* function, const fn_call& fn);
>
> void instantiateClass(std::string className, as_object* global);
> /// Return the Global object for this Machine.
>
> === modified file 'libcore/vm/Makefile.am'
> --- a/libcore/vm/Makefile.am 2009-11-16 12:29:31 +0000
> +++ b/libcore/vm/Makefile.am 2009-11-16 14:01:20 +0000
> @@ -27,6 +27,7 @@
> -I$(top_srcdir)/libcore/asobj \
> -I$(top_srcdir)/libcore/asobj/flash \
> -I$(top_srcdir)/libcore/swf \
> + -I$(top_srcdir)/libcore/abc \
> -I$(top_srcdir)/libcore/parser \
> -I$(top_srcdir)/libbase \
> -I$(top_srcdir)/libamf \
> @@ -56,7 +57,6 @@
> noinst_HEADERS = \
> ASHandlers.h \
> CodeStream.h \
> - MultiName.h \
> ActionExec.h \
> ExecutableCode.h \
> with_stack_entry.h \
> @@ -72,7 +72,6 @@
>
> if ENABLE_AVM2
> noinst_HEADERS += \
> - MultiName.h \
> CodeStream.h \
> Machine.h \
> $(NULL)
>
> _______________________________________________
> Gnash-commit mailing list
> address@hidden
> http://lists.gnu.org/mailman/listinfo/gnash-commit
--
Free GIS & Flash consultant/developer () ASCII Ribbon Campaign
http://foo.keybit.net/~strk/services.html /\ Keep it simple!