PassRefPtr<CodeBlock> ScriptExecutable::newReplacementCodeBlockFor(
CodeSpecializationKind kind)
{
if (classInfo() == EvalExecutable::info()) {
RELEASE_ASSERT(kind == CodeForCall);
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
EvalCodeBlock* baseline = static_cast<EvalCodeBlock*>(
executable->m_evalCodeBlock->baselineVersion());
RefPtr<EvalCodeBlock> result = adoptRef(new EvalCodeBlock(
CodeBlock::CopyParsedBlock, *baseline));
result->setAlternative(baseline);
return result;
}
if (classInfo() == ProgramExecutable::info()) {
RELEASE_ASSERT(kind == CodeForCall);
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
ProgramCodeBlock* baseline = static_cast<ProgramCodeBlock*>(
executable->m_programCodeBlock->baselineVersion());
RefPtr<ProgramCodeBlock> result = adoptRef(new ProgramCodeBlock(
CodeBlock::CopyParsedBlock, *baseline));
result->setAlternative(baseline);
return result;
}
RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
FunctionCodeBlock* baseline = static_cast<FunctionCodeBlock*>(
executable->codeBlockFor(kind)->baselineVersion());
RefPtr<FunctionCodeBlock> result = adoptRef(new FunctionCodeBlock(
CodeBlock::CopyParsedBlock, *baseline));
result->setAlternative(baseline);
return result;
}
void Error::newError(QScriptValueImpl *result, const QScriptValueImpl &proto,
const QString &message)
{
QScriptEnginePrivate *eng_p = engine();
if (!result->isValid())
eng_p->newObject(result, proto, classInfo());
else
result->setClassInfo(classInfo());
result->setProperty(QLatin1String("message"), QScriptValueImpl(eng_p, message));
}
RefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(
CodeSpecializationKind kind, JSFunction* function, JSScope* scope, JSObject*& exception)
{
VM* vm = scope->vm();
ASSERT(vm->heap.isDeferred());
ASSERT(startColumn() != UINT_MAX);
ASSERT(endColumn() != UINT_MAX);
if (classInfo() == EvalExecutable::info()) {
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_evalCodeBlock);
RELEASE_ASSERT(!function);
return adoptRef(new EvalCodeBlock(
executable, executable->m_unlinkedEvalCodeBlock.get(), scope,
executable->source().provider()));
}
if (classInfo() == ProgramExecutable::info()) {
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_programCodeBlock);
RELEASE_ASSERT(!function);
return adoptRef(new ProgramCodeBlock(
executable, executable->m_unlinkedProgramCodeBlock.get(), scope,
executable->source().provider(), executable->source().startColumn()));
}
RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
RELEASE_ASSERT(function);
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
RELEASE_ASSERT(!executable->codeBlockFor(kind));
JSGlobalObject* globalObject = scope->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasDebugger() ? DebuggerOn : DebuggerOff;
ProfilerMode profilerMode = globalObject->hasProfiler() ? ProfilerOn : ProfilerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock =
executable->m_unlinkedExecutable->codeBlockFor(*vm, executable->m_source, kind, debuggerMode, profilerMode, error, executable->isArrowFunction());
recordParse(executable->m_unlinkedExecutable->features(), executable->m_unlinkedExecutable->hasCapturedVariables(), firstLine(), lastLine(), startColumn(), endColumn());
if (!unlinkedCodeBlock) {
exception = vm->throwException(
globalObject->globalExec(),
error.toErrorObject(globalObject, executable->m_source));
return nullptr;
}
SourceProvider* provider = executable->source().provider();
unsigned sourceOffset = executable->source().startOffset();
unsigned startColumn = executable->source().startColumn();
return adoptRef(new FunctionCodeBlock(
executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn));
}
Enumeration::Enumeration(QScriptEnginePrivate *eng):
Ecma::Core(eng, QLatin1String("Enumeration"), QScriptClassInfo::EnumerationType)
{
classInfo()->setData(new EnumerationClassData(classInfo()));
newEnumeration(&publicPrototype, eng->newArray());
eng->newConstructor(&ctor, this, publicPrototype);
addPrototypeFunction(QLatin1String("toFront"), method_toFront, 0);
addPrototypeFunction(QLatin1String("hasNext"), method_hasNext, 0);
addPrototypeFunction(QLatin1String("next"), method_next, 0);
}
void Function::initialize()
{
QScriptEnginePrivate *eng = engine();
eng->newConstructor(&ctor, this, publicPrototype);
addPrototypeFunction(QLatin1String("toString"), method_toString, 1);
addPrototypeFunction(QLatin1String("apply"), method_apply, 1);
addPrototypeFunction(QLatin1String("call"), method_call, 1);
addPrototypeFunction(QLatin1String("connect"), method_connect, 1);
addPrototypeFunction(QLatin1String("disconnect"), method_disconnect, 1);
QExplicitlySharedDataPointer<QScriptClassData> data(new FunctionClassData(classInfo()));
classInfo()->setData(data);
}
void ExecutableBase::dump(PrintStream& out) const
{
ExecutableBase* realThis = const_cast<ExecutableBase*>(this);
if (classInfo() == NativeExecutable::info()) {
NativeExecutable* native = jsCast<NativeExecutable*>(realThis);
out.print("NativeExecutable:", RawPointer(bitwise_cast<void*>(native->function())), "/", RawPointer(bitwise_cast<void*>(native->constructor())));
return;
}
if (classInfo() == EvalExecutable::info()) {
EvalExecutable* eval = jsCast<EvalExecutable*>(realThis);
if (CodeBlock* codeBlock = eval->codeBlock())
out.print(*codeBlock);
else
out.print("EvalExecutable w/o CodeBlock");
return;
}
if (classInfo() == ProgramExecutable::info()) {
ProgramExecutable* eval = jsCast<ProgramExecutable*>(realThis);
if (CodeBlock* codeBlock = eval->codeBlock())
out.print(*codeBlock);
else
out.print("ProgramExecutable w/o CodeBlock");
return;
}
if (classInfo() == ModuleProgramExecutable::info()) {
ModuleProgramExecutable* executable = jsCast<ModuleProgramExecutable*>(realThis);
if (CodeBlock* codeBlock = executable->codeBlock())
out.print(*codeBlock);
else
out.print("ModuleProgramExecutable w/o CodeBlock");
return;
}
FunctionExecutable* function = jsCast<FunctionExecutable*>(realThis);
if (!function->eitherCodeBlock())
out.print("FunctionExecutable w/o CodeBlock");
else {
CommaPrinter comma("/");
if (function->codeBlockForCall())
out.print(comma, *function->codeBlockForCall());
if (function->codeBlockForConstruct())
out.print(comma, *function->codeBlockForConstruct());
}
}
UString JSObject::className() const
{
const ClassInfo* info = classInfo();
if (info)
return info->className;
return "Object";
}
bool QScriptValueImpl::hasInstance(const QScriptValueImpl &value) const
{
Q_ASSERT(isObject());
if (QScriptClassData *odata = classInfo()->data()) {
if (odata->implementsHasInstance(*this))
return odata->hasInstance(*this, value);
}
if (!isFunction())
return false;
// [[HasInstance] for function objects
if (!value.isObject())
return false;
QScriptEnginePrivate *eng = engine();
QScriptValueImpl proto = property(eng->idTable()->id_prototype);
if (!proto.isObject()) {
QScriptContextPrivate *ctx = eng->currentContext();
ctx->throwTypeError(QLatin1String("instanceof: 'prototype' property is not an object"));
return false;
}
QScriptObject *target = proto.m_object_value;
QScriptValueImpl v = value;
while (true) {
v = v.prototype();
if (!v.isObject())
break;
if (target == v.m_object_value)
return true;
}
return false;
}
void Boolean::execute(QScriptContextPrivate *context)
{
#ifndef Q_SCRIPT_NO_EVENT_NOTIFY
engine()->notifyFunctionEntry(context);
#endif
bool value;
if (context->argumentCount() > 0)
value = context->argument(0).toBoolean();
else
value = false;
QScriptValueImpl boolean(engine(), value);
if (!context->isCalledAsConstructor()) {
context->setReturnValue(boolean);
} else {
QScriptValueImpl &obj = context->m_thisObject;
obj.setClassInfo(classInfo());
obj.setInternalValue(boolean);
obj.setPrototype(publicPrototype);
context->setReturnValue(obj);
}
#ifndef Q_SCRIPT_NO_EVENT_NOTIFY
engine()->notifyFunctionExit(context);
#endif
}
EXPORT
UString JSObject::className() const
{
const ClassInfo *ci = classInfo();
if ( ci )
return ci->className;
return "Object";
}
void FunctionClassData::mark(const QScriptValueImpl &object, int generation)
{
if (object.classInfo() != classInfo())
return;
QScriptFunction *fun = object.toFunction();
QScriptEnginePrivate *eng = QScriptEnginePrivate::get(object.engine());
fun->mark(eng, generation);
}
CodeBlock* ScriptExecutable::newReplacementCodeBlockFor(
CodeSpecializationKind kind)
{
if (classInfo() == EvalExecutable::info()) {
RELEASE_ASSERT(kind == CodeForCall);
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
EvalCodeBlock* baseline = static_cast<EvalCodeBlock*>(
executable->m_evalCodeBlock->baselineVersion());
EvalCodeBlock* result = EvalCodeBlock::create(vm(),
CodeBlock::CopyParsedBlock, *baseline);
result->setAlternative(*vm(), baseline);
return result;
}
if (classInfo() == ProgramExecutable::info()) {
RELEASE_ASSERT(kind == CodeForCall);
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
ProgramCodeBlock* baseline = static_cast<ProgramCodeBlock*>(
executable->m_programCodeBlock->baselineVersion());
ProgramCodeBlock* result = ProgramCodeBlock::create(vm(),
CodeBlock::CopyParsedBlock, *baseline);
result->setAlternative(*vm(), baseline);
return result;
}
if (classInfo() == ModuleProgramExecutable::info()) {
RELEASE_ASSERT(kind == CodeForCall);
ModuleProgramExecutable* executable = jsCast<ModuleProgramExecutable*>(this);
ModuleProgramCodeBlock* baseline = static_cast<ModuleProgramCodeBlock*>(
executable->m_moduleProgramCodeBlock->baselineVersion());
ModuleProgramCodeBlock* result = ModuleProgramCodeBlock::create(vm(),
CodeBlock::CopyParsedBlock, *baseline);
result->setAlternative(*vm(), baseline);
return result;
}
RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
FunctionCodeBlock* baseline = static_cast<FunctionCodeBlock*>(
executable->codeBlockFor(kind)->baselineVersion());
FunctionCodeBlock* result = FunctionCodeBlock::create(vm(),
CodeBlock::CopyParsedBlock, *baseline);
result->setAlternative(*vm(), baseline);
return result;
}
void RegExp::newRegExp(QScriptValueImpl *result, const QString &pattern, int flags)
{
#ifndef QT_NO_REGEXP
QRegExp rx = toRegExp(pattern, flags);
newRegExp_helper(result, rx, flags);
#else
engine()->newObject(result, publicPrototype, classInfo());
initRegExp(result, pattern, flags);
#endif // QT_NO_REGEXP
}
bool QScriptValueImpl::implementsHasInstance() const
{
Q_ASSERT(isObject());
if (isFunction())
return true;
if (QScriptClassData *odata = classInfo()->data()) {
return odata->implementsHasInstance(*this);
}
return false;
}
const HashEntry* JSObject::findPropertyHashEntry(const Identifier& propertyName) const
{
for (const ClassInfo *info = classInfo(); info; info = info->parentClass) {
if (const HashTable *propHashTable = info->propHashTable) {
if (const HashEntry *e = Lookup::findEntry(propHashTable, propertyName))
return e;
}
}
return 0;
}
const HashEntry* JSObject::findPropertyHashEntry(ExecState* exec, const Identifier& propertyName) const
{
for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
if (const HashTable* propHashTable = info->propHashTable(exec)) {
if (const HashEntry* entry = propHashTable->entry(exec, propertyName))
return entry;
}
}
return 0;
}
void ExecutableBase::clearCode()
{
#if ENABLE(JIT)
m_jitCodeForCall = nullptr;
m_jitCodeForConstruct = nullptr;
m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();
#endif
m_numParametersForCall = NUM_PARAMETERS_NOT_COMPILED;
m_numParametersForConstruct = NUM_PARAMETERS_NOT_COMPILED;
if (classInfo() == FunctionExecutable::info()) {
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
executable->m_codeBlockForCall.clear();
executable->m_codeBlockForConstruct.clear();
return;
}
if (classInfo() == EvalExecutable::info()) {
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
executable->m_evalCodeBlock.clear();
executable->m_unlinkedEvalCodeBlock.clear();
return;
}
if (classInfo() == ProgramExecutable::info()) {
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
executable->m_programCodeBlock.clear();
executable->m_unlinkedProgramCodeBlock.clear();
return;
}
if (classInfo() == ModuleProgramExecutable::info()) {
ModuleProgramExecutable* executable = jsCast<ModuleProgramExecutable*>(this);
executable->m_moduleProgramCodeBlock.clear();
executable->m_unlinkedModuleProgramCodeBlock.clear();
executable->m_moduleEnvironmentSymbolTable.clear();
return;
}
ASSERT(classInfo() == NativeExecutable::info());
}
void Variant::newVariant(QScriptValueImpl *result, const QVariant &value)
{
Instance *instance;
if (!result->isValid()) {
engine()->newObject(result, publicPrototype, classInfo());
instance = new Instance();
result->setObjectData(instance);
} else {
Q_ASSERT(result->isObject());
if (result->classInfo() != classInfo()) {
result->destroyObjectData();
result->setClassInfo(classInfo());
instance = new Instance();
result->setObjectData(instance);
} else {
instance = Instance::get(*result, classInfo());
}
}
instance->value = value;
}
void EnumerationClassData::mark(const QScriptValueImpl &object, int generation)
{
Q_ASSERT(object.isValid());
QScriptEnginePrivate *eng = object.engine();
if (Enumeration::Instance *instance = Enumeration::Instance::get(object, classInfo())) {
eng->markObject(instance->object, generation);
if (instance->it)
eng->markObject(instance->it->object(), generation);
}
}
void Enumeration::newEnumeration(QScriptValueImpl *result, const QScriptValueImpl &object)
{
Instance *instance = new Instance();
instance->object = object;
if (object.isObject()) {
instance->it = new QScriptValueIteratorImpl(object);
instance->it->setIgnoresDontEnum(false);
instance->it->setEnumeratePrototype(true);
} else {
instance->it = 0;
}
engine()->newObject(result, publicPrototype, classInfo());
result->setObjectData(instance);
}
/*
@begin DOMCSSRuleTable 4
type DOMCSSRule::Type DontDelete|ReadOnly
cssText DOMCSSRule::CssText DontDelete|ReadOnly
parentStyleSheet DOMCSSRule::ParentStyleSheet DontDelete|ReadOnly
parentRule DOMCSSRule::ParentRule DontDelete|ReadOnly
@end
@begin DOMCSSStyleRuleTable 2
selectorText DOMCSSRule::Style_SelectorText DontDelete
style DOMCSSRule::Style_Style DontDelete|ReadOnly
@end
@begin DOMCSSMediaRuleTable 4
media DOMCSSRule::Media_Media DontDelete|ReadOnly
cssRules DOMCSSRule::Media_CssRules DontDelete|ReadOnly
insertRule DOMCSSRule::Media_InsertRule DontDelete|Function 2
deleteRule DOMCSSRule::Media_DeleteRule DontDelete|Function 1
@end
@begin DOMCSSFontFaceRuleTable 1
style DOMCSSRule::FontFace_Style DontDelete|ReadOnly
@end
@begin DOMCSSPageRuleTable 2
selectorText DOMCSSRule::Page_SelectorText DontDelete
style DOMCSSRule::Page_Style DontDelete|ReadOnly
@end
@begin DOMCSSImportRuleTable 3
href DOMCSSRule::Import_Href DontDelete|ReadOnly
media DOMCSSRule::Import_Media DontDelete|ReadOnly
styleSheet DOMCSSRule::Import_StyleSheet DontDelete|ReadOnly
@end
@begin DOMCSSCharsetRuleTable 1
encoding DOMCSSRule::Charset_Encoding DontDelete
@end
*/
Value DOMCSSRule::tryGet(ExecState *exec, const Identifier &propertyName) const
{
#ifdef KJS_VERBOSE
kdDebug(6070) << "DOMCSSRule::tryGet " << propertyName.qstring() << endl;
#endif
const HashTable* table = classInfo()->propHashTable; // get the right hashtable
const HashEntry* entry = Lookup::findEntry(table, propertyName);
if (entry) {
if (entry->attr & Function)
return lookupOrCreateFunction<DOMCSSRuleFunc>(exec, propertyName, this, entry->value, entry->params, entry->attr);
return getValueProperty(exec, entry->value);
}
// Base CSSRule stuff or parent class forward, as usual
return DOMObjectLookupGet<DOMCSSRuleFunc, DOMCSSRule, DOMObject>(exec, propertyName, &DOMCSSRuleTable, this);
}
void JSObject::getOwnPropertyNames(ExecState* /*exec*/, PropertyNameArray& propertyNames, PropertyMap::PropertyMode mode)
{
_prop.getPropertyNames(propertyNames, mode);
// Add properties from the static hashtable of properties
const ClassInfo *info = classInfo();
while (info) {
if (info->propHashTable) {
int size = info->propHashTable->size;
const HashEntry *e = info->propHashTable->entries;
for (int i = 0; i < size; ++i, ++e) {
if (e->s && PropertyMap::checkEnumerable(e->attr, mode))
propertyNames.add(e->s);
}
}
info = info->parentClass;
}
}
void DOMCSSRule::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
{
const HashTable* table = classInfo()->propHashTable; // get the right hashtable
const HashEntry* entry = Lookup::findEntry(table, propertyName);
if (entry) {
if (entry->attr & Function) // function: put as override property
{
ObjectImp::put(exec, propertyName, value, attr);
return;
}
else if ((entry->attr & ReadOnly) == 0) // let DOMObjectLookupPut print the warning if not
{
putValueProperty(exec, entry->value, value, attr);
return;
}
}
DOMObjectLookupPut<DOMCSSRule, DOMObject>(exec, propertyName, value, attr, &DOMCSSRuleTable, this);
}
bool FunctionClassData::get(const QScriptValueImpl &object, const Member &member,
QScriptValueImpl *result)
{
if (object.classInfo() != classInfo())
return false;
QScriptEnginePrivate *eng = QScriptEnginePrivate::get(object.engine());
if (! member.isNativeProperty())
return false;
if (member.nameId() == eng->idTable()->id_length) {
eng->newNumber(result, object.toFunction()->length);
return true;
} else if (member.nameId() == eng->idTable()->id_arguments) {
eng->newNull(result);
return true;
}
return false;
}
EXPORT
void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
{
_prop.getEnumerablePropertyNames(propertyNames);
// Add properties from the static hashtable of properties
const ClassInfo *info = classInfo();
while (info) {
if (info->propHashTable) {
int size = info->propHashTable->size;
const HashEntry *e = info->propHashTable->entries;
for (int i = 0; i < size; ++i, ++e) {
if (e->s && !(e->attr & DontEnum))
propertyNames.add(e->s);
}
}
info = info->parentClass;
}
if (_proto->isObject())
static_cast<JSObject*>(_proto)->getPropertyNames(exec, propertyNames);
}
bool FunctionClassData::resolve(const QScriptValueImpl &object,
QScriptNameIdImpl *nameId,
QScript::Member *member, QScriptValueImpl *base)
{
if (object.classInfo() != classInfo())
return false;
QScriptEnginePrivate *eng = QScriptEnginePrivate::get(object.engine());
if ((nameId == eng->idTable()->id_length)
|| (nameId == eng->idTable()->id_arguments)) {
member->native(nameId, /*id=*/ 0,
QScriptValue::Undeletable
| QScriptValue::ReadOnly
| QScriptValue::SkipInEnumeration);
*base = object;
return true;
}
return false;
}
void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
{
m_structureID->propertyMap().getEnumerablePropertyNames(propertyNames);
// Add properties from the static hashtables of properties
for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
const HashTable* table = info->propHashTable(exec);
if (!table)
continue;
table->initializeIfNeeded(exec);
ASSERT(table->table);
int hashSizeMask = table->hashSizeMask;
const HashEntry* entry = table->table;
for (int i = 0; i <= hashSizeMask; ++i, ++entry) {
if (entry->key && !(entry->attributes & DontEnum))
propertyNames.add(entry->key);
}
}
if (prototype()->isObject())
static_cast<JSObject*>(prototype())->getPropertyNames(exec, propertyNames);
}
bool QScriptValueImpl::resolve_helper(QScriptNameIdImpl *nameId, QScript::Member *member,
QScriptValueImpl *object, QScriptValue::ResolveFlags mode,
QScript::AccessMode access) const
{
QScriptObject *object_data = m_object_value;
QScriptEnginePrivate *eng_p = engine();
if (nameId == eng_p->idTable()->id___proto__) {
member->native(nameId, /*id=*/0, QScriptValue::Undeletable);
*object = *this;
return true;
}
// If not found anywhere else, search in the extra members.
if (QScriptClassData *odata = classInfo()->data()) {
*object = *this;
if (odata->resolve(*this, nameId, member, object, access))
return true;
}
if (mode & QScriptValue::ResolvePrototype) {
// For values and other non object based types, search in class's prototype
const QScriptValueImpl &proto = object_data->m_prototype;
if (proto.isObject()
&& proto.resolve(nameId, member, object, mode, access)) {
return true;
}
}
if ((mode & QScriptValue::ResolveScope) && object_data->m_scope.isValid())
return object_data->m_scope.resolve(nameId, member, object, mode, access);
return false;
}
Error::Error(QScriptEnginePrivate *eng):
Core(eng, QLatin1String("Error"), QScriptClassInfo::ErrorType)
{
eng->newFunction(&ctor, this);
newErrorPrototype(&publicPrototype, QScriptValueImpl(), ctor, QLatin1String("Error"));
addPrototypeFunction(QLatin1String("backtrace"), method_backtrace, 0);
addPrototypeFunction(QLatin1String("toString"), method_toString, 0);
// native errors
evalErrorCtor = eng->createFunction(method_EvalError, 3,
classInfo(), QLatin1String("EvalError"));
rangeErrorCtor = eng->createFunction(method_RangeError, 3,
classInfo(), QLatin1String("RangeError"));
referenceErrorCtor = eng->createFunction(method_ReferenceError, 3,
classInfo(), QLatin1String("ReferenceError"));
syntaxErrorCtor = eng->createFunction(method_SyntaxError, 3,
classInfo(), QLatin1String("SyntaxError"));
typeErrorCtor = eng->createFunction(method_TypeError, 3,
classInfo(), QLatin1String("TypeError"));
uriErrorCtor = eng->createFunction(method_UriError, 3,
classInfo(), QLatin1String("URIError"));
newErrorPrototype(&evalErrorPrototype, publicPrototype,
evalErrorCtor, QLatin1String("EvalError"));
newErrorPrototype(&rangeErrorPrototype, publicPrototype,
rangeErrorCtor, QLatin1String("RangeError"));
newErrorPrototype(&referenceErrorPrototype, publicPrototype,
referenceErrorCtor, QLatin1String("ReferenceError"));
newErrorPrototype(&syntaxErrorPrototype, publicPrototype,
syntaxErrorCtor, QLatin1String("SyntaxError"));
newErrorPrototype(&typeErrorPrototype, publicPrototype,
typeErrorCtor, QLatin1String("TypeError"));
newErrorPrototype(&uriErrorPrototype, publicPrototype,
uriErrorCtor, QLatin1String("URIError"));
}
void Boolean::newBoolean(QScriptValueImpl *result, bool value)
{
engine()->newObject(result, publicPrototype, classInfo());
}
