Attachment #687721 for bug #568953

Attachment #687721: Module objects for bug #568953

View | Details | Raw Unified | Return to bug 568953
Collapse All | Expand All





		Statistics.cpp \
		StoreBuffer.cpp \
		FindSCCs.cpp \
		Iteration.cpp \
		Verifier.cpp \
		StringBuffer.cpp \
		Unicode.cpp \
		Xdr.cpp \
		Module.cpp \
		$(NULL)

# Changes to internal header files, used externally, massively slow down
# browser builds.  Don't add new files here unless you know what you're
# doing!
INSTALLED_HEADERS = \
		js-config.h \
		jscpucfg.h \





#include "jsobjinlines.h"
#include "builtin/Module.h"
#include "gc/Marking.h"

using namespace js;

Class js::ModuleClass = {
    js_Module_str,
    JSCLASS_HAS_RESERVED_SLOTS(2),
    JS_PropertyStub,        /* addProperty */
    JS_PropertyStub,        /* delProperty */
    JS_PropertyStub,        /* getProperty */
    JS_StrictPropertyStub,  /* setProperty */
    JS_EnumerateStub,
    JS_ResolveStub,
    JS_ConvertStub
};

JSObject *
js_InitModuleClass(JSContext *cx, HandleObject obj)
{
    Rooted<GlobalObject *> global(cx, &obj->asGlobal());
    return global->createBlankPrototype(cx, &ModuleClass);
}

Module *
js_NewModule(JSContext *cx, JSAtom *atom)
{
    RootedModule module(cx, &NewBuiltinClassInstance(cx, &ModuleClass)->asModule());
    module->setAtom(atom);
    module->setScript(NULL);
    return module;
}

Module &
JSObject::asModule()
{
    JS_ASSERT(isModule());
    return *static_cast<Module *>(this);
}





#ifndef Module_h___
#define Module_h___

#include "jsobj.h"

namespace js {

class Module : public JSObject {
  public:
    JSAtom *atom() {
        return (JSAtom *) GetReservedSlot(this, ATOM_SLOT).toPrivate();
    };

    void setAtom(JSAtom *atom) {
        SetReservedSlot(this, ATOM_SLOT, PrivateValue(atom));
    };

    JSScript *script() {
        return (JSScript *) GetReservedSlot(this, SCRIPT_SLOT).toPrivate();
    }

    void setScript(JSScript *script) {
        SetReservedSlot(this, SCRIPT_SLOT, PrivateValue(script));
    }

  private:
    static const uint32_t ATOM_SLOT = 0;
    static const uint32_t SCRIPT_SLOT = 1;
};

} // namespace js

JSObject *
js_InitModuleClass(JSContext *cx, js::HandleObject obj);

js::Module *
js_NewModule(JSContext *cx, JSAtom *atom);

#endif // Module_h___





 *   then redundant rooting of multiple copies of the GC thing can be avoided.
 *   Second, if the caller does not pass a rooted value a compile error will be
 *   generated, which is quicker and easier to fix than when relying on a
 *   separate rooting analysis.
 */

namespace js {

class Module;

template <typename T> class Rooted;

template <typename T>
struct RootMethods {};

template <typename T>
class HandleBase {};



    const T *ptr;

    template <typename S>
    void operator =(S v) MOZ_DELETE;
};

typedef Handle<JSObject*>    HandleObject;
typedef Handle<js::Module*>  HandleModule;
typedef Handle<JSFunction*>  HandleFunction;
typedef Handle<JSScript*>    HandleScript;
typedef Handle<JSString*>    HandleString;
typedef Handle<jsid>         HandleId;
typedef Handle<Value>        HandleValue;

/*
 * Similar to a handle, but the underlying storage can be changed. This is

template <typename T>
bool
Return<T>::operator==(const Rooted<T> &other)
{
    return ptr_ == other.get();
}

typedef Rooted<JSObject*>    RootedObject;
typedef Rooted<js::Module*>  RootedModule;
typedef Rooted<JSFunction*>  RootedFunction;
typedef Rooted<JSScript*>    RootedScript;
typedef Rooted<JSString*>    RootedString;
typedef Rooted<jsid>         RootedId;
typedef Rooted<Value>        RootedValue;

/*
 * Mark a stack location as a root for the rooting analysis, without actually





#include "jsstr.h"
#include "jsdbgapi.h"
#include "json.h"
#include "jswatchpoint.h"
#include "jswrapper.h"
#include "jsxml.h"

#include "builtin/MapObject.h"
#include "builtin/Module.h"
#include "builtin/ParallelArray.h"
#include "frontend/BytecodeCompiler.h"
#include "frontend/Parser.h"
#include "gc/Marking.h"
#include "js/MemoryMetrics.h"
#include "vm/StringBuffer.h"
#include "vm/Xdr.h"






extern Class DateClass;
extern Class ErrorClass;
extern Class ElementIteratorClass;
extern Class GeneratorClass;
extern Class IntlClass;
extern Class JSONClass;
extern Class MapIteratorClass;
extern Class MathClass;
extern Class ModuleClass;
extern Class NumberClass;
extern Class NormalArgumentsObjectClass;
extern Class ObjectClass;
extern Class ProxyClass;
extern Class RegExpClass;
extern Class RegExpStaticsClass;
extern Class SetIteratorClass;
extern Class SlowArrayClass;

class ClonedBlockObject;
class DataViewObject;
class DebugScopeObject;
class DeclEnvObject;
class ElementIteratorObject;
class GlobalObject;
class MapObject;
class MapIteratorObject;
class Module;
class NestedScopeObject;
class NewObjectCache;
class NormalArgumentsObject;
class NumberObject;
class PropertyIteratorObject;
class ScopeObject;
class SetObject;
class SetIteratorObject;

    inline bool isDataView() const;
    inline bool isDate() const;
    inline bool isElementIterator() const;
    inline bool isError() const;
    inline bool isFunction() const;
    inline bool isGenerator() const;
    inline bool isGlobal() const;
    inline bool isMapIterator() const;
    inline bool isModule() const;
    inline bool isObject() const;
    inline bool isPrimitive() const;
    inline bool isPropertyIterator() const;
    inline bool isProxy() const;
    inline bool isRegExp() const;
    inline bool isRegExpStatics() const;
    inline bool isScope() const;
    inline bool isScript() const;

    inline js::CallObject &asCall();
    inline js::ClonedBlockObject &asClonedBlock();
    inline js::DataViewObject &asDataView();
    inline js::DeclEnvObject &asDeclEnv();
    inline js::DebugScopeObject &asDebugScope();
    inline js::GlobalObject &asGlobal();
    inline js::MapObject &asMap();
    inline js::MapIteratorObject &asMapIterator();
    inline js::Module &asModule();
    inline js::NestedScopeObject &asNestedScope();
    inline js::NormalArgumentsObject &asNormalArguments();
    inline js::NumberObject &asNumber();
    inline js::PropertyIteratorObject &asPropertyIterator();
    inline const js::PropertyIteratorObject &asPropertyIterator() const;
    inline js::RegExpObject &asRegExp();
    inline js::ScopeObject &asScope();
    inline js::SetObject &asSet();





inline bool JSObject::isDate() const { return hasClass(&js::DateClass); }
inline bool JSObject::isDeclEnv() const { return hasClass(&js::DeclEnvClass); }
inline bool JSObject::isElementIterator() const { return hasClass(&js::ElementIteratorClass); }
inline bool JSObject::isError() const { return hasClass(&js::ErrorClass); }
inline bool JSObject::isFunction() const { return hasClass(&js::FunctionClass); }
inline bool JSObject::isFunctionProxy() const { return hasClass(&js::FunctionProxyClass); }
inline bool JSObject::isGenerator() const { return hasClass(&js::GeneratorClass); }
inline bool JSObject::isMapIterator() const { return hasClass(&js::MapIteratorClass); }
inline bool JSObject::isModule() const { return hasClass(&js::ModuleClass); }
inline bool JSObject::isNestedScope() const { return isBlock() || isWith(); }
inline bool JSObject::isNormalArguments() const { return hasClass(&js::NormalArgumentsObjectClass); }
inline bool JSObject::isNumber() const { return hasClass(&js::NumberClass); }
inline bool JSObject::isObject() const { return hasClass(&js::ObjectClass); }
inline bool JSObject::isPrimitive() const { return isNumber() || isString() || isBoolean(); }
inline bool JSObject::isRegExp() const { return hasClass(&js::RegExpClass); }
inline bool JSObject::isRegExpStatics() const { return hasClass(&js::RegExpStaticsClass); }
inline bool JSObject::isScope() const { return isCall() || isDeclEnv() || isNestedScope(); }

(-)a/js/src/jsprototypes.h (+1 lines)

Line	Link Here

Lines 56-65	Link Here

    macro(Proxy,                 34,     js_InitProxyClass) \

    macro(Proxy,                 34,     js_InitProxyClass) \

    macro(AnyName,               35,     js_InitNullClass) \

    macro(AnyName,               35,     js_InitNullClass) \

    macro(WeakMap,               36,     js_InitWeakMapClass) \

    macro(WeakMap,               36,     js_InitWeakMapClass) \

    macro(Map,                   37,     js_InitMapClass) \

    macro(Map,                   37,     js_InitMapClass) \

    macro(Set,                   38,     js_InitSetClass) \

    macro(Set,                   38,     js_InitSetClass) \

    macro(DataView,              39,     js_InitTypedArrayClasses) \

    macro(DataView,              39,     js_InitTypedArrayClasses) \

    macro(ParallelArray,         40,     js_InitParallelArrayClass) \

    macro(ParallelArray,         40,     js_InitParallelArrayClass) \

    macro(Intl,                  41,     js_InitIntlClass) \

    macro(Intl,                  41,     js_InitIntlClass) \

    macro(Module,                42,     js_InitModuleClass) \

#endif /* jsprototypes_h___ */

#endif /* jsprototypes_h___ */

Return to bug 568953