Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
#include "qv4errorobject_p.h"
#include <QtCore/qnumeric.h>
#include <QtCore/qmath.h>
#include <QtCore/QDateTime>
#include <QtCore/QStringList>
#include <QtCore/QDebug>
#include <private/qv4mm_p.h>
#include <private/qv4codegen_p.h>
#ifndef Q_OS_WIN
# include <time.h>
# ifndef Q_OS_VXWORKS
# include <sys/time.h>
# else
# include "qplatformdefs.h"
# endif
#else
# include <qt_windows.h>
#endif
using namespace QV4;
void Heap::ErrorObject::init()
{
Object::init();
stackTrace = nullptr;
Scope scope(internalClass->engine);
Scoped<QV4::ErrorObject> e(scope, this);
if (internalClass == scope.engine->internalClasses(EngineBase::Class_ErrorProto))
return;
setProperty(scope.engine, QV4::ErrorObject::Index_Stack, scope.engine->getStackFunction()->d());
setProperty(scope.engine, QV4::ErrorObject::Index_StackSetter, Value::undefinedValue());
setProperty(scope.engine, QV4::ErrorObject::Index_FileName, Value::undefinedValue());
setProperty(scope.engine, QV4::ErrorObject::Index_LineNumber, Value::undefinedValue());
}
void Heap::ErrorObject::init(const Value &message, ErrorType t)
{
Object::init();
errorType = t;
Scope scope(internalClass->engine);
Scoped<QV4::ErrorObject> e(scope, this);
setProperty(scope.engine, QV4::ErrorObject::Index_Stack, scope.engine->getStackFunction()->d());
setProperty(scope.engine, QV4::ErrorObject::Index_StackSetter, Value::undefinedValue());
e->d()->stackTrace = new StackTrace(scope.engine->stackTrace());
if (!e->d()->stackTrace->isEmpty()) {
setProperty(scope.engine, QV4::ErrorObject::Index_FileName, scope.engine->newString(e->d()->stackTrace->at(0).source));
setProperty(scope.engine, QV4::ErrorObject::Index_LineNumber, Value::fromInt32(qAbs(e->d()->stackTrace->at(0).line)));
}
if (!message.isUndefined())
setProperty(scope.engine, QV4::ErrorObject::Index_Message, message);
}
void Heap::ErrorObject::init(const Value &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
{
Q_UNUSED(fileName); // ####
Object::init();
errorType = t;
Scope scope(internalClass->engine);
Scoped<QV4::ErrorObject> e(scope, this);
setProperty(scope.engine, QV4::ErrorObject::Index_Stack, scope.engine->getStackFunction()->d());
setProperty(scope.engine, QV4::ErrorObject::Index_StackSetter, Value::undefinedValue());
e->d()->stackTrace = new StackTrace(scope.engine->stackTrace());
StackFrame frame;
frame.source = fileName;
frame.line = line;
frame.column = column;
e->d()->stackTrace->prepend(frame);
Q_ASSERT(!e->d()->stackTrace->isEmpty());
setProperty(scope.engine, QV4::ErrorObject::Index_FileName, scope.engine->newString(e->d()->stackTrace->at(0).source));
setProperty(scope.engine, QV4::ErrorObject::Index_LineNumber, Value::fromInt32(qAbs(e->d()->stackTrace->at(0).line)));
if (!message.isUndefined())
setProperty(scope.engine, QV4::ErrorObject::Index_Message, message);
}
const char *ErrorObject::className(Heap::ErrorObject::ErrorType t)
{
switch (t) {
case Heap::ErrorObject::Error:
return "Error";
case Heap::ErrorObject::EvalError:
return "EvalError";
case Heap::ErrorObject::RangeError:
return "RangeError";
case Heap::ErrorObject::ReferenceError:
return "ReferenceError";
case Heap::ErrorObject::SyntaxError:
return "SyntaxError";
case Heap::ErrorObject::TypeError:
return "TypeError";
case Heap::ErrorObject::URIError:
return "URIError";
}
Q_UNREACHABLE();
}
ReturnedValue ErrorObject::method_get_stack(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
ExecutionEngine *v4 = b->engine();
const ErrorObject *This = thisObject->as<ErrorObject>();
if (!This)
return v4->throwTypeError();
if (!This->d()->stack) {
QString trace;
for (int i = 0; i < This->d()->stackTrace->size(); ++i) {
if (i > 0)
trace += QLatin1Char('\n');
const StackFrame &frame = This->d()->stackTrace->at(i);
trace += frame.function + QLatin1Char('@') + frame.source;
if (frame.line >= 0)
trace += QLatin1Char(':') + QString::number(frame.line);
}
This->d()->stack.set(v4, v4->newString(trace));
}
return This->d()->stack->asReturnedValue();
}
DEFINE_OBJECT_VTABLE(ErrorObject);
void Heap::SyntaxErrorObject::init(const Value &msg)
{
Heap::ErrorObject::init(msg, SyntaxError);
}
void Heap::SyntaxErrorObject::init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
{
Heap::ErrorObject::init(msg, fileName, lineNumber, columnNumber, SyntaxError);
}
void Heap::EvalErrorObject::init(const Value &message)
{
Heap::ErrorObject::init(message, EvalError);
}
void Heap::RangeErrorObject::init(const Value &message)
{
Heap::ErrorObject::init(message, RangeError);
}
void Heap::ReferenceErrorObject::init(const Value &message)
{
Heap::ErrorObject::init(message, ReferenceError);
}
void Heap::ReferenceErrorObject::init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
{
Heap::ErrorObject::init(msg, fileName, lineNumber, columnNumber, ReferenceError);
}
void Heap::TypeErrorObject::init(const Value &message)
{
Heap::ErrorObject::init(message, TypeError);
}
void Heap::URIErrorObject::init(const Value &message)
{
Heap::ErrorObject::init(message, URIError);
}
DEFINE_OBJECT_VTABLE(ErrorCtor);
DEFINE_OBJECT_VTABLE(EvalErrorCtor);
DEFINE_OBJECT_VTABLE(RangeErrorCtor);
DEFINE_OBJECT_VTABLE(ReferenceErrorCtor);
DEFINE_OBJECT_VTABLE(SyntaxErrorCtor);
DEFINE_OBJECT_VTABLE(TypeErrorCtor);
DEFINE_OBJECT_VTABLE(URIErrorCtor);
void Heap::ErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("Error"));
}
void Heap::ErrorCtor::init(QV4::ExecutionEngine *engine, const QString &name)
{
Heap::FunctionObject::init(engine, name);
}
ReturnedValue ErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<ErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
ReturnedValue ErrorCtor::virtualCall(const FunctionObject *f, const Value *, const Value *argv, int argc)
{
return f->callAsConstructor(argv, argc);
}
void Heap::EvalErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("EvalError"));
}
ReturnedValue EvalErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<EvalErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void Heap::RangeErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("RangeError"));
}
ReturnedValue RangeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<RangeErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void Heap::ReferenceErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("ReferenceError"));
}
ReturnedValue ReferenceErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<ReferenceErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void Heap::SyntaxErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("SyntaxError"));
}
ReturnedValue SyntaxErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<SyntaxErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void Heap::TypeErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("TypeError"));
}
ReturnedValue TypeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<TypeErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void Heap::URIErrorCtor::init(QV4::ExecutionEngine *engine)
{
Heap::FunctionObject::init(engine, QStringLiteral("URIError"));
}
ReturnedValue URIErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
{
Value v = argc ? *argv : Value::undefinedValue();
return ErrorObject::create<URIErrorObject>(f->engine(), v, newTarget)->asReturnedValue();
}
void ErrorPrototype::init(ExecutionEngine *engine, Object *ctor, Object *obj, Heap::ErrorObject::ErrorType t)
{
Scope scope(engine);
ScopedString s(scope);
ScopedObject o(scope);
ctor->defineReadonlyProperty(engine->id_prototype(), (o = obj));
ctor->defineReadonlyConfigurableProperty(engine->id_length(), Value::fromInt32(1));
obj->setProperty(Index_Constructor, ctor->d());
obj->setProperty(Index_Message, engine->id_empty()->d());
obj->setProperty(Index_Name, engine->newString(QString::fromLatin1(ErrorObject::className(t))));
obj->defineDefaultProperty(engine->id_toString(), method_toString, 0);
}
ReturnedValue ErrorPrototype::method_toString(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
ExecutionEngine *v4 = b->engine();
const Object *o = thisObject->as<Object>();
if (!o)
return v4->throwTypeError();
Scope scope(v4);
ScopedValue name(scope, o->get(scope.engine->id_name()));
QString qname;
if (name->isUndefined())
qname = QStringLiteral("Error");
else
qname = name->toQString();
ScopedString s(scope, scope.engine->newString(QStringLiteral("message")));
ScopedValue message(scope, o->get(s));
QString qmessage;
if (!message->isUndefined())
qmessage = message->toQString();
QString str;
if (qname.isEmpty()) {
str = qmessage;
} else if (qmessage.isEmpty()) {
str = qname;
} else {
str = qname + QLatin1String(": ") + qmessage;
}
return scope.engine->newString(str)->asReturnedValue();
}