namespace JSC {
-const ClassInfo JSCallbackConstructor::info = { "CallbackConstructor", 0, 0, 0 };
+const ClassInfo JSCallbackConstructor::info = { "CallbackConstructor", 0, 0 };
JSCallbackConstructor::JSCallbackConstructor(NonNullPassRefPtr<Structure> structure, JSClassRef jsClass, JSObjectCallAsConstructorCallback callback)
: JSObject(structure)
ASSERT_CLASS_FITS_IN_CELL(JSCallbackFunction);
-const ClassInfo JSCallbackFunction::info = { "CallbackFunction", &InternalFunction::info, 0, 0 };
+const ClassInfo JSCallbackFunction::info = { "CallbackFunction", &InternalFunction::info, 0 };
JSCallbackFunction::JSCallbackFunction(ExecState* exec, JSObjectCallAsFunctionCallback callback, const Identifier& name)
: InternalFunction(&exec->globalData(), exec->lexicalGlobalObject()->callbackFunctionStructure(), name)
ASSERT_CLASS_FITS_IN_CELL(Arguments);
-const ClassInfo Arguments::info = { "Arguments", 0, 0, 0 };
+const ClassInfo Arguments::info = { "Arguments", 0, 0 };
Arguments::~Arguments()
{
// ------------------------------ ArrayPrototype ----------------------------
-const ClassInfo ArrayPrototype::info = {"Array", &JSArray::info, 0, ExecState::arrayTable};
+const ClassInfo ArrayPrototype::info = { "Array", &JSArray::info, ExecState::arrayTable };
/* Source for ArrayPrototype.lut.h
@begin arrayTable 16
ASSERT_CLASS_FITS_IN_CELL(BooleanObject);
-const ClassInfo BooleanObject::info = { "Boolean", 0, 0, 0 };
+const ClassInfo BooleanObject::info = { "Boolean", 0, 0 };
BooleanObject::BooleanObject(NonNullPassRefPtr<Structure> structure)
: JSWrapperObject(structure)
namespace JSC {
- class HashEntry;
struct HashTable;
struct ClassInfo {
{
if (classPropHashTableGetterFunction)
return classPropHashTableGetterFunction(exec);
- return staticPropHashTable;
+ return 0;
}
- const HashTable* staticPropHashTable;
typedef const HashTable* (*ClassPropHashTableGetterFunction)(ExecState*);
const ClassPropHashTableGetterFunction classPropHashTableGetterFunction;
};
namespace JSC {
-const ClassInfo DateInstance::info = {"Date", 0, 0, 0};
+const ClassInfo DateInstance::info = { "Date", 0, 0 };
DateInstance::DateInstance(ExecState* exec, NonNullPassRefPtr<Structure> structure)
: JSWrapperObject(structure)
return ok;
}
-const ClassInfo DatePrototype::info = {"Date", &DateInstance::info, 0, ExecState::dateTable};
+const ClassInfo DatePrototype::info = { "Date", &DateInstance::info, ExecState::dateTable };
/* Source for DatePrototype.lut.h
@begin dateTable
namespace JSC {
-const ClassInfo ErrorInstance::info = { "Error", 0, 0, 0 };
+const ClassInfo ErrorInstance::info = { "Error", 0, 0 };
ErrorInstance::ErrorInstance(NonNullPassRefPtr<Structure> structure)
: JSObject(structure)
ASSERT_CLASS_FITS_IN_CELL(InternalFunction);
-const ClassInfo InternalFunction::info = { "Function", 0, 0, 0 };
+const ClassInfo InternalFunction::info = { "Function", 0, 0 };
const ClassInfo* InternalFunction::classInfo() const
{
ASSERT_CLASS_FITS_IN_CELL(JSActivation);
-const ClassInfo JSActivation::info = { "JSActivation", 0, 0, 0 };
+const ClassInfo JSActivation::info = { "JSActivation", 0, 0 };
JSActivation::JSActivation(CallFrame* callFrame, NonNullPassRefPtr<FunctionExecutable> functionExecutable)
: Base(callFrame->globalData().activationStructure, new JSActivationData(functionExecutable, callFrame->registers()))
// as long as it is 1/8 full. If more sparse than that, we use a map.
static const unsigned minDensityMultiplier = 8;
-const ClassInfo JSArray::info = {"Array", 0, 0, 0};
+const ClassInfo JSArray::info = { "Array", 0, 0 };
static inline size_t storageSize(unsigned vectorLength)
{
namespace JSC {
-const ClassInfo JSByteArray::s_defaultInfo = { "ByteArray", 0, 0, 0 };
+const ClassInfo JSByteArray::s_defaultInfo = { "ByteArray", 0, 0 };
JSByteArray::JSByteArray(ExecState* exec, NonNullPassRefPtr<Structure> structure, ByteArray* storage, const JSC::ClassInfo* classInfo)
: JSObject(structure)
ASSERT_CLASS_FITS_IN_CELL(JSFunction);
-const ClassInfo JSFunction::info = { "Function", &InternalFunction::info, 0, 0 };
+const ClassInfo JSFunction::info = { "Function", &InternalFunction::info, 0 };
bool JSFunction::isHostFunctionNonInline() const
{
ASSERT_CLASS_FITS_IN_CELL(JSGlobalObject);
-const ClassInfo JSGlobalObject::info = { "CallbackGlobalObject", 0, 0, 0 };
+const ClassInfo JSGlobalObject::info = { "CallbackGlobalObject", 0, 0 };
static inline void markIfNeeded(MarkStack& markStack, JSValue v)
{
// ------------------------------ JSONObject --------------------------------
-const ClassInfo JSONObject::info = { "JSON", 0, 0, ExecState::jsonTable };
+const ClassInfo JSONObject::info = { "JSON", 0, ExecState::jsonTable };
/* Source for JSONObject.lut.h
@begin jsonTable
ASSERT_CLASS_FITS_IN_CELL(JSObject);
-const ClassInfo JSObject::info = { "CallbackObject", 0, 0, 0 };
+const ClassInfo JSObject::info = { "CallbackObject", 0, 0 };
static inline void getClassPropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames, EnumerationMode mode)
{
// ------------------------------ MathObject --------------------------------
-const ClassInfo MathObject::info = { "Math", 0, 0, ExecState::mathTable };
+const ClassInfo MathObject::info = { "Math", 0, ExecState::mathTable };
/* Source for MathObject.lut.h
@begin mathTable
ASSERT_CLASS_FITS_IN_CELL(NativeErrorConstructor);
-const ClassInfo NativeErrorConstructor::info = { "Function", &InternalFunction::info, 0, 0 };
+const ClassInfo NativeErrorConstructor::info = { "Function", &InternalFunction::info, 0 };
NativeErrorConstructor::NativeErrorConstructor(ExecState* exec, NonNullPassRefPtr<Structure> structure, NativeErrorPrototype* nativeErrorPrototype)
: InternalFunction(&exec->globalData(), structure, Identifier(exec, nativeErrorPrototype->getDirect(exec->propertyNames().name).getString(exec)))
namespace JSC {
-const ClassInfo NumberConstructor::info = { "Function", &InternalFunction::info, 0, ExecState::numberTable };
+const ClassInfo NumberConstructor::info = { "Function", &InternalFunction::info, ExecState::numberTable };
/* Source for NumberConstructor.lut.h
@begin numberTable
ASSERT_CLASS_FITS_IN_CELL(NumberObject);
-const ClassInfo NumberObject::info = { "Number", 0, 0, 0 };
+const ClassInfo NumberObject::info = { "Number", 0, 0 };
NumberObject::NumberObject(NonNullPassRefPtr<Structure> structure)
: JSWrapperObject(structure)
ASSERT_CLASS_FITS_IN_CELL(RegExpConstructor);
-const ClassInfo RegExpConstructor::info = { "Function", &InternalFunction::info, 0, ExecState::regExpConstructorTable };
+const ClassInfo RegExpConstructor::info = { "Function", &InternalFunction::info, ExecState::regExpConstructorTable };
/* Source for RegExpConstructor.lut.h
@begin regExpConstructorTable
ASSERT_CLASS_FITS_IN_CELL(RegExpObject);
-const ClassInfo RegExpObject::info = { "RegExp", 0, 0, ExecState::regExpTable };
+const ClassInfo RegExpObject::info = { "RegExp", 0, ExecState::regExpTable };
/* Source for RegExpObject.lut.h
@begin regExpTable
// ECMA 15.10.5
-const ClassInfo RegExpPrototype::info = { "RegExpPrototype", 0, 0, 0 };
+const ClassInfo RegExpPrototype::info = { "RegExpPrototype", 0, 0 };
RegExpPrototype::RegExpPrototype(ExecState* exec, NonNullPassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
: JSObject(structure)
ASSERT_CLASS_FITS_IN_CELL(StringObject);
-const ClassInfo StringObject::info = { "String", 0, 0, 0 };
+const ClassInfo StringObject::info = { "String", 0, 0 };
StringObject::StringObject(ExecState* exec, NonNullPassRefPtr<Structure> structure)
: JSWrapperObject(structure)
namespace JSC {
-const ClassInfo StringPrototype::info = { "String", &StringObject::info, 0, ExecState::stringTable };
+const ClassInfo StringPrototype::info = { "String", &StringObject::info, ExecState::stringTable };
/* Source for StringPrototype.lut.h
@begin stringTable 26
namespace QScript
{
-const JSC::ClassInfo QScriptActivationObject::info = { "QScriptActivationObject", 0, 0, 0 };
+const JSC::ClassInfo QScriptActivationObject::info = { "QScriptActivationObject", 0, 0 };
QScriptActivationObject::QScriptActivationObject(JSC::ExecState *callFrame, JSC::JSObject *delegate)
: JSC::JSVariableObject(callFrame->globalData().activationStructure,
namespace QScript
{
-const JSC::ClassInfo FunctionWrapper::info = { "QtNativeFunctionWrapper", &PrototypeFunction::info, 0, 0 };
-const JSC::ClassInfo FunctionWithArgWrapper::info = { "QtNativeFunctionWithArgWrapper", &PrototypeFunction::info, 0, 0 };
+const JSC::ClassInfo FunctionWrapper::info = { "QtNativeFunctionWrapper", &PrototypeFunction::info, 0 };
+const JSC::ClassInfo FunctionWithArgWrapper::info = { "QtNativeFunctionWithArgWrapper", &PrototypeFunction::info, 0 };
FunctionWrapper::FunctionWrapper(JSC::ExecState *exec, int length, const JSC::Identifier &name,
QScriptEngine::FunctionSignature function)
QT_BEGIN_NAMESPACE
// masquerading as JSC::JSObject
-const JSC::ClassInfo QScriptObject::info = { "Object", 0, 0, 0 };
+const JSC::ClassInfo QScriptObject::info = { "Object", 0, 0 };
QScriptObject::Data::~Data()
{
meta, data->initialIndex, data->maybeOverloaded);
}
-const JSC::ClassInfo QtFunction::info = { "QtFunction", &InternalFunction::info, 0, 0 };
+const JSC::ClassInfo QtFunction::info = { "QtFunction", &InternalFunction::info, 0 };
JSC::JSValue QT_FASTCALL QtFunction::call(JSC::ExecState *exec, JSC::JSObject *callee,
JSC::JSValue thisValue, const JSC::ArgList &args)
return result.asInt32();
}
-const JSC::ClassInfo QtPropertyFunction::info = { "QtPropertyFunction", &InternalFunction::info, 0, 0 };
+const JSC::ClassInfo QtPropertyFunction::info = { "QtPropertyFunction", &InternalFunction::info, 0 };
QtPropertyFunction::QtPropertyFunction(const QMetaObject *meta, int index,
JSC::JSGlobalData *data,
this->structure()->setHasGetterSetterProperties(true);
}
-const JSC::ClassInfo QMetaObjectWrapperObject::info = { "QMetaObject", 0, 0, 0 };
+const JSC::ClassInfo QMetaObjectWrapperObject::info = { "QMetaObject", 0, 0 };
QMetaObjectWrapperObject::QMetaObjectWrapperObject(
JSC::ExecState *exec, const QMetaObject *metaObject, JSC::JSValue ctor,
\sa QScriptContext::pushScope()
*/
-const JSC::ClassInfo QScriptStaticScopeObject::info = { "QScriptStaticScopeObject", 0, 0, 0 };
+const JSC::ClassInfo QScriptStaticScopeObject::info = { "QScriptStaticScopeObject", 0, 0 };
/*!
Creates a static scope object with a fixed set of undeletable properties.