From 75f2b5b706fc919a4186dc8d9571488841025793 Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Tue, 29 Jan 2013 14:31:42 +0100 Subject: [PATCH] Remove the virtual Object::className() Change-Id: I70ecf244792c1c22b57ba7bdfed64b4b5b055e8c Reviewed-by: Simon Hausmann --- qmljs_runtime.cpp | 2 +- qv4argumentsobject.h | 1 - qv4dateobject.h | 1 - qv4errorobject.cpp | 11 ++++++++ qv4errorobject.h | 18 ++++++++----- qv4functionobject.h | 1 - qv4jsonobject.cpp | 1 + qv4jsonobject.h | 1 - qv4managed.cpp | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++ qv4managed.h | 10 +++++-- qv4mathobject.cpp | 2 ++ qv4object.h | 6 ----- qv4regexpobject.h | 1 - qv4stringobject.h | 1 - 14 files changed, 108 insertions(+), 22 deletions(-) diff --git a/qmljs_runtime.cpp b/qmljs_runtime.cpp index 3caf61b..682f025 100644 --- a/qmljs_runtime.cpp +++ b/qmljs_runtime.cpp @@ -640,7 +640,7 @@ Value __qmljs_foreach_next_property_name(Value foreach_iterator) assert(foreach_iterator.isObject()); ForEachIteratorObject *it = static_cast(foreach_iterator.objectValue()); - assert(it->className() == QLatin1String("__ForEachIteratorObject")); + assert(it->asForeachIteratorObject()); return it->nextPropertyName(); } diff --git a/qv4argumentsobject.h b/qv4argumentsobject.h index 2785ccb..adbaf5d 100644 --- a/qv4argumentsobject.h +++ b/qv4argumentsobject.h @@ -72,7 +72,6 @@ struct ArgumentsObject: Object { ExecutionContext *context; QVector mappedArguments; ArgumentsObject(ExecutionContext *context, int formalParameterCount, int actualParameterCount); - virtual QString className() { return QStringLiteral("Arguments"); } bool defineOwnProperty(ExecutionContext *ctx, uint index, const PropertyDescriptor *desc); diff --git a/qv4dateobject.h b/qv4dateobject.h index 0cc2928..ede4473 100644 --- a/qv4dateobject.h +++ b/qv4dateobject.h @@ -51,7 +51,6 @@ namespace VM { struct DateObject: Object { Value value; DateObject(const Value &value): value(value) { type = Type_DateObject; } - virtual QString className() { return QStringLiteral("Date"); } }; struct DateCtor: FunctionObject diff --git a/qv4errorobject.cpp b/qv4errorobject.cpp index f10ee40..9d4a067 100644 --- a/qv4errorobject.cpp +++ b/qv4errorobject.cpp @@ -74,6 +74,7 @@ using namespace QQmlJS::VM; ErrorObject::ErrorObject(ExecutionEngine* engine, const Value &message) + : errorType(Error) { type = Type_ErrorObject; @@ -90,6 +91,7 @@ SyntaxErrorObject::SyntaxErrorObject(ExecutionContext *ctx, DiagnosticMessage *m : ErrorObject(ctx->engine, message ? Value::fromString(message->buildFullMessage(ctx)) : ctx->argument(0)) , msg(message) { + errorType = SyntaxError; prototype = ctx->engine->syntaxErrorPrototype; setNameProperty(ctx); } @@ -99,6 +101,7 @@ SyntaxErrorObject::SyntaxErrorObject(ExecutionContext *ctx, DiagnosticMessage *m EvalErrorObject::EvalErrorObject(ExecutionContext *ctx) : ErrorObject(ctx->engine, ctx->argument(0)) { + errorType = EvalError; setNameProperty(ctx); prototype = ctx->engine->evalErrorPrototype; } @@ -106,6 +109,7 @@ EvalErrorObject::EvalErrorObject(ExecutionContext *ctx) RangeErrorObject::RangeErrorObject(ExecutionContext *ctx) : ErrorObject(ctx->engine, ctx->argument(0)) { + errorType = RangeError; setNameProperty(ctx); prototype = ctx->engine->rangeErrorPrototype; } @@ -113,6 +117,7 @@ RangeErrorObject::RangeErrorObject(ExecutionContext *ctx) RangeErrorObject::RangeErrorObject(ExecutionContext *ctx, const QString &msg) : ErrorObject(ctx->engine, Value::fromString(ctx,msg)) { + errorType = RangeError; setNameProperty(ctx); prototype = ctx->engine->rangeErrorPrototype; } @@ -120,6 +125,7 @@ RangeErrorObject::RangeErrorObject(ExecutionContext *ctx, const QString &msg) ReferenceErrorObject::ReferenceErrorObject(ExecutionContext *ctx) : ErrorObject(ctx->engine, ctx->argument(0)) { + errorType = ReferenceError; setNameProperty(ctx); prototype = ctx->engine->referenceErrorPrototype; } @@ -127,6 +133,7 @@ ReferenceErrorObject::ReferenceErrorObject(ExecutionContext *ctx) ReferenceErrorObject::ReferenceErrorObject(ExecutionContext *ctx, const QString &msg) : ErrorObject(ctx->engine, Value::fromString(ctx,msg)) { + errorType = ReferenceError; setNameProperty(ctx); prototype = ctx->engine->referenceErrorPrototype; } @@ -134,6 +141,7 @@ ReferenceErrorObject::ReferenceErrorObject(ExecutionContext *ctx, const QString TypeErrorObject::TypeErrorObject(ExecutionContext *ctx) : ErrorObject(ctx->engine, ctx->argument(0)) { + errorType = TypeError; setNameProperty(ctx); prototype = ctx->engine->typeErrorPrototype; } @@ -141,6 +149,7 @@ TypeErrorObject::TypeErrorObject(ExecutionContext *ctx) TypeErrorObject::TypeErrorObject(ExecutionContext *ctx, const QString &msg) : ErrorObject(ctx->engine, Value::fromString(ctx,msg)) { + errorType = TypeError; setNameProperty(ctx); prototype = ctx->engine->typeErrorPrototype; } @@ -148,6 +157,7 @@ TypeErrorObject::TypeErrorObject(ExecutionContext *ctx, const QString &msg) URIErrorObject::URIErrorObject(ExecutionContext *ctx) : ErrorObject(ctx->engine, ctx->argument(0)) { + errorType = URIError; setNameProperty(ctx); prototype = ctx->engine->uRIErrorPrototype; } @@ -155,6 +165,7 @@ URIErrorObject::URIErrorObject(ExecutionContext *ctx) URIErrorObject::URIErrorObject(ExecutionContext *ctx, Value msg) : ErrorObject(ctx->engine, msg) { + errorType = URIError; setNameProperty(ctx); prototype = ctx->engine->uRIErrorPrototype; } diff --git a/qv4errorobject.h b/qv4errorobject.h index 74dc62b..d2d2340 100644 --- a/qv4errorobject.h +++ b/qv4errorobject.h @@ -48,8 +48,18 @@ namespace QQmlJS { namespace VM { struct ErrorObject: Object { + enum ErrorType { + Error, + EvalError, + RangeError, + ReferenceError, + SyntaxError, + TypeError, + URIError + }; + ErrorType errorType; + ErrorObject(ExecutionEngine* engine, const Value &message); - virtual QString className() { return QStringLiteral("Error"); } virtual struct SyntaxErrorObject *asSyntaxError() { return 0; } @@ -59,25 +69,21 @@ protected: struct EvalErrorObject: ErrorObject { EvalErrorObject(ExecutionContext *ctx); - virtual QString className() { return QStringLiteral("EvalError"); } }; struct RangeErrorObject: ErrorObject { RangeErrorObject(ExecutionContext *ctx); RangeErrorObject(ExecutionContext *ctx, const QString &msg); - virtual QString className() { return QStringLiteral("RangeError"); } }; struct ReferenceErrorObject: ErrorObject { ReferenceErrorObject(ExecutionContext *ctx); ReferenceErrorObject(ExecutionContext *ctx, const QString &msg); - virtual QString className() { return QStringLiteral("ReferenceError"); } }; struct SyntaxErrorObject: ErrorObject { SyntaxErrorObject(ExecutionContext *ctx, DiagnosticMessage *msg); ~SyntaxErrorObject() { delete msg; } - virtual QString className() { return QStringLiteral("SyntaxError"); } virtual SyntaxErrorObject *asSyntaxError() { return this; } DiagnosticMessage *message() { return msg; } @@ -89,13 +95,11 @@ private: struct TypeErrorObject: ErrorObject { TypeErrorObject(ExecutionContext *ctx); TypeErrorObject(ExecutionContext *ctx, const QString &msg); - virtual QString className() { return QStringLiteral("TypeError"); } }; struct URIErrorObject: ErrorObject { URIErrorObject(ExecutionContext *ctx); URIErrorObject(ExecutionContext *ctx, Value); - virtual QString className() { return QStringLiteral("URIError"); } }; struct ErrorCtor: FunctionObject diff --git a/qv4functionobject.h b/qv4functionobject.h index f554456..b70ff1a 100644 --- a/qv4functionobject.h +++ b/qv4functionobject.h @@ -141,7 +141,6 @@ struct FunctionObject: Object { FunctionObject(ExecutionContext *scope); - virtual QString className() { return QStringLiteral("Function"); } virtual bool hasInstance(ExecutionContext *ctx, const Value &value); virtual Value construct(ExecutionContext *context, Value *args, int argc); diff --git a/qv4jsonobject.cpp b/qv4jsonobject.cpp index a12c4a5..fa39476 100644 --- a/qv4jsonobject.cpp +++ b/qv4jsonobject.cpp @@ -865,6 +865,7 @@ QString Stringify::JA(ArrayObject *a) JsonObject::JsonObject(ExecutionContext *context) : Object() { + type = Type_JSONObject; prototype = context->engine->objectPrototype; defineDefaultProperty(context, QStringLiteral("parse"), method_parse, 2); diff --git a/qv4jsonobject.h b/qv4jsonobject.h index 6626471..7c1df7c 100644 --- a/qv4jsonobject.h +++ b/qv4jsonobject.h @@ -48,7 +48,6 @@ namespace VM { struct JsonObject : Object { JsonObject(ExecutionContext *context); - virtual QString className() { return QStringLiteral("JSON"); } static Value method_parse(ExecutionContext *ctx); static Value method_stringify(ExecutionContext *ctx); diff --git a/qv4managed.cpp b/qv4managed.cpp index a48b989..8156878 100644 --- a/qv4managed.cpp +++ b/qv4managed.cpp @@ -41,6 +41,7 @@ #include "qv4managed.h" #include "qv4mm.h" +#include "qv4errorobject.h" using namespace QQmlJS::VM; @@ -65,3 +66,76 @@ void Managed::operator delete(void *ptr) Managed *m = static_cast(ptr); m->~Managed(); } + + +QString Managed::className() const +{ + const char *s = 0; + switch (Type(type)) { + case Type_Invalid: + case Type_String: + return QString(); + case Type_Object: + s = "Object"; + break; + case Type_ArrayObject: + s = "Array"; + break; + case Type_FunctionObject: + s = "Function"; + break; + case Type_BooleanObject: + s = "Boolean"; + break; + case Type_NumberObject: + s = "Number"; + break; + case Type_StringObject: + s = "String"; + break; + case Type_DateObject: + s = "Date"; + break; + case Type_RegExpObject: + s = "RegExp"; + break; + case Type_ErrorObject: + switch (static_cast(this)->errorType) { + case ErrorObject::Error: + s = "Error"; + break; + case ErrorObject::EvalError: + s = "EvalError"; + break; + case ErrorObject::RangeError: + s = "RangeError"; + break; + case ErrorObject::ReferenceError: + s = "ReferenceError"; + break; + case ErrorObject::SyntaxError: + s = "SyntaxError"; + break; + case ErrorObject::TypeError: + s = "TypeError"; + break; + case ErrorObject::URIError: + s = "URIError"; + break; + } + break; + case Type_ArgumentsObject: + s = "Arguments"; + break; + case Type_JSONObject: + s = "JSON"; + break; + case Type_MathObject: + s = "Math"; + break; + case Type_ForeachIteratorObject: + s = "__ForeachIterator"; + break; + } + return QString::fromLatin1(s); +} diff --git a/qv4managed.h b/qv4managed.h index ab75826..7b6768d 100644 --- a/qv4managed.h +++ b/qv4managed.h @@ -66,6 +66,7 @@ struct FunctionObject; struct RegExpObject; struct ErrorObject; struct ArgumentsObject; +struct JSONObject; struct ForeachIteratorObject; struct Managed @@ -116,6 +117,8 @@ public: Type_RegExpObject, Type_ErrorObject, Type_ArgumentsObject, + Type_JSONObject, + Type_MathObject, Type_ForeachIteratorObject }; @@ -130,11 +133,14 @@ public: RegExpObject *asRegExpObject() { return type == Type_RegExpObject ? reinterpret_cast(this) : 0; } ErrorObject *asErrorObject() { return type == Type_ErrorObject ? reinterpret_cast(this) : 0; } ArgumentsObject *asArgumentsObject() { return type == Type_ArgumentsObject ? reinterpret_cast(this) : 0; } + JSONObject *asJSONObject() { return type == Type_JSONObject ? reinterpret_cast(this) : 0; } ForeachIteratorObject *asForeachIteratorObject() { return type == Type_ForeachIteratorObject ? reinterpret_cast(this) : 0; } bool isArrayObject() const { return type == Type_ArrayObject; } bool isStringObject() const { return type == Type_StringObject; } + QString className() const; + protected: virtual void markObjects() {} @@ -149,8 +155,8 @@ protected: quintptr needsActivation : 1; // used by FunctionObject quintptr usesArgumentsObject : 1; // used by FunctionObject quintptr strictMode : 1; // used by FunctionObject - quintptr type : 4; - quintptr unused : 20; + quintptr type : 8; + quintptr unused : 16; mutable quintptr stringHash : 32; }; }; diff --git a/qv4mathobject.cpp b/qv4mathobject.cpp index 2eefb51..8076e16 100644 --- a/qv4mathobject.cpp +++ b/qv4mathobject.cpp @@ -51,6 +51,8 @@ static const double qt_PI = 2.0 * ::asin(1.0); MathObject::MathObject(ExecutionContext *ctx) { + type = Type_MathObject; + defineReadonlyProperty(ctx->engine, QStringLiteral("E"), Value::fromDouble(::exp(1.0))); defineReadonlyProperty(ctx->engine, QStringLiteral("LN2"), Value::fromDouble(::log(2.0))); defineReadonlyProperty(ctx->engine, QStringLiteral("LN10"), Value::fromDouble(::log(10.0))); diff --git a/qv4object.h b/qv4object.h index 0a2ac60..362cd15 100644 --- a/qv4object.h +++ b/qv4object.h @@ -110,8 +110,6 @@ struct Object: Managed { virtual ~Object(); - virtual QString className() { return QStringLiteral("Object"); } - PropertyDescriptor *__getOwnProperty__(ExecutionContext *ctx, String *name); PropertyDescriptor *__getOwnProperty__(ExecutionContext *ctx, uint index); PropertyDescriptor *__getPropertyDescriptor__(ExecutionContext *ctx, String *name); @@ -162,7 +160,6 @@ struct ForEachIteratorObject: Object { ObjectIterator it; ForEachIteratorObject(ExecutionContext *ctx, Object *o) : it(ctx, o, ObjectIterator::EnumberableOnly|ObjectIterator::WithProtoChain) { type = Type_ForeachIteratorObject; } - virtual QString className() { return QStringLiteral("__ForEachIteratorObject"); } Value nextPropertyName() { return it.nextPropertyNameAsString(); } @@ -173,20 +170,17 @@ protected: struct BooleanObject: Object { Value value; BooleanObject(const Value &value): value(value) { type = Type_BooleanObject; } - virtual QString className() { return QStringLiteral("Boolean"); } }; struct NumberObject: Object { Value value; NumberObject(const Value &value): value(value) { type = Type_NumberObject; } - virtual QString className() { return QStringLiteral("Number"); } }; struct ArrayObject: Object { ArrayObject(ExecutionContext *ctx) { init(ctx); } ArrayObject(ExecutionContext *ctx, const Array &value): Object(value) { init(ctx); array.setLengthUnchecked(array.length()); } void init(ExecutionContext *context); - virtual QString className() { return QStringLiteral("Array"); } }; diff --git a/qv4regexpobject.h b/qv4regexpobject.h index 9655374..50241f2 100644 --- a/qv4regexpobject.h +++ b/qv4regexpobject.h @@ -70,7 +70,6 @@ struct RegExpObject: Object { PropertyDescriptor *lastIndexProperty; bool global; RegExpObject(ExecutionEngine *engine, PassRefPtr value, bool global); - virtual QString className() { return QStringLiteral("RegExp"); } }; diff --git a/qv4stringobject.h b/qv4stringobject.h index d131e94..7e62e29 100644 --- a/qv4stringobject.h +++ b/qv4stringobject.h @@ -52,7 +52,6 @@ struct StringObject: Object { Value value; PropertyDescriptor tmpProperty; StringObject(ExecutionContext *ctx, const Value &value); - virtual QString className() { return QStringLiteral("String"); } PropertyDescriptor *getIndex(ExecutionContext *ctx, uint index); -- 2.7.4