Revert "Simplify JS bindings generation"

This reverts commit f227c3392beda68beb2792eb9fec467d9a0794da.

Conflicts:
	src/qml/qml/v4/qv4object_p.h
	src/qml/qml/v4/v4.pri
	src/qml/qml/v4/v4classgen

Change-Id: I8aba402878a460ac612c853d14650efc6cb21761
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

7 files changed, 99 insertions, 372 deletions

diff --git a/.gitignore b/.gitignore
index c5cbc02951..fa221a5ede 100644
--- a/.gitignore
+++ b/.gitignore
@@ -274,5 +274,3 @@ src/qml/RegExpJitTables.h
 src/qml/udis86_itab.c
 src/qml/udis86_itab.h
 
-# Generated V4 JS bindings
-*_jsclass.cpp
diff --git a/src/qml/qml/v4/qv4dateobject.cpp b/src/qml/qml/v4/qv4dateobject.cpp
index 30a0548cf2..8f2bd737ab 100644
--- a/src/qml/qml/v4/qv4dateobject.cpp
+++ b/src/qml/qml/v4/qv4dateobject.cpp
@@ -651,7 +651,15 @@ QDateTime DateObject::toQDateTime() const
     return ToDateTime(value.asDouble(), Qt::LocalTime);
 }
 
-Value DatePrototype::ctor_method_construct(Managed *, ExecutionContext *ctx, Value *args, int argc)
+DEFINE_MANAGED_VTABLE(DateCtor);
+
+DateCtor::DateCtor(ExecutionContext *scope)
+    : FunctionObject(scope, scope->engine->newIdentifier(QStringLiteral("Date")))
+{
+    vtbl = &static_vtbl;
+}
+
+Value DateCtor::construct(Managed *, ExecutionContext *ctx, Value *args, int argc)
 {
     double t = 0;
 
@@ -689,7 +697,7 @@ Value DatePrototype::ctor_method_construct(Managed *, ExecutionContext *ctx, Val
     return Value::fromObject(d);
 }
 
-Value DatePrototype::ctor_method_call(Managed *, ExecutionContext *ctx, const Value &, Value *, int)
+Value DateCtor::call(Managed *, ExecutionContext *ctx, const Value &, Value *, int)
 {
     double t = currentTime();
     return Value::fromString(ctx, ToString(t));
@@ -697,9 +705,61 @@ Value DatePrototype::ctor_method_call(Managed *, ExecutionContext *ctx, const Va
 
 void DatePrototype::init(ExecutionContext *ctx, const Value &ctor)
 {
+    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(7));
     LocalTZA = getLocalTZA();
 
-    initClass(ctx->engine, ctor);
+    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("parse"), method_parse, 1);
+    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("UTC"), method_UTC, 7);
+    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("now"), method_now, 0);
+
+    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toDateString"), method_toDateString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toTimeString"), method_toTimeString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toLocaleString"), method_toLocaleString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toLocaleDateString"), method_toLocaleDateString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getTime"), method_getTime, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getYear"), method_getYear, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getFullYear"), method_getFullYear, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCFullYear"), method_getUTCFullYear, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getMonth"), method_getMonth, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCMonth"), method_getUTCMonth, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getDate"), method_getDate, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCDate"), method_getUTCDate, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getDay"), method_getDay, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCDay"), method_getUTCDay, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getHours"), method_getHours, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCHours"), method_getUTCHours, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getMinutes"), method_getMinutes, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCMinutes"), method_getUTCMinutes, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getSeconds"), method_getSeconds, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCSeconds"), method_getUTCSeconds, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getMilliseconds"), method_getMilliseconds, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getUTCMilliseconds"), method_getUTCMilliseconds, 0);
+    defineDefaultProperty(ctx, QStringLiteral("getTimezoneOffset"), method_getTimezoneOffset, 0);
+    defineDefaultProperty(ctx, QStringLiteral("setTime"), method_setTime, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setMilliseconds"), method_setMilliseconds, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCMilliseconds"), method_setUTCMilliseconds, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setSeconds"), method_setSeconds, 2);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCSeconds"), method_setUTCSeconds, 2);
+    defineDefaultProperty(ctx, QStringLiteral("setMinutes"), method_setMinutes, 3);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCMinutes"), method_setUTCMinutes, 3);
+    defineDefaultProperty(ctx, QStringLiteral("setHours"), method_setHours, 4);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCHours"), method_setUTCHours, 4);
+    defineDefaultProperty(ctx, QStringLiteral("setDate"), method_setDate, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCDate"), method_setUTCDate, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setMonth"), method_setMonth, 2);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCMonth"), method_setUTCMonth, 2);
+    defineDefaultProperty(ctx, QStringLiteral("setYear"), method_setYear, 1);
+    defineDefaultProperty(ctx, QStringLiteral("setFullYear"), method_setFullYear, 3);
+    defineDefaultProperty(ctx, QStringLiteral("setUTCFullYear"), method_setUTCFullYear, 3);
+    defineDefaultProperty(ctx, QStringLiteral("toUTCString"), method_toUTCString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toGMTString"), method_toUTCString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toISOString"), method_toISOString, 0);
+    defineDefaultProperty(ctx, QStringLiteral("toJSON"), method_toJSON, 1);
 }
 
 double DatePrototype::getThisDate(ExecutionContext *ctx)
@@ -712,12 +772,12 @@ double DatePrototype::getThisDate(ExecutionContext *ctx)
     }
 }
 
-Value DatePrototype::ctor_method_parse(SimpleCallContext *ctx)
+Value DatePrototype::method_parse(SimpleCallContext *ctx)
 {
     return Value::fromDouble(ParseString(ctx->argument(0).toString(ctx)->toQString()));
 }
 
-Value DatePrototype::ctor_method_UTC(SimpleCallContext *ctx)
+Value DatePrototype::method_UTC(SimpleCallContext *ctx)
 {
     const int numArgs = ctx->argumentCount;
     if (numArgs >= 2) {
@@ -737,7 +797,7 @@ Value DatePrototype::ctor_method_UTC(SimpleCallContext *ctx)
     return Value::undefinedValue();
 }
 
-Value DatePrototype::ctor_method_now(SimpleCallContext *ctx)
+Value DatePrototype::method_now(SimpleCallContext *ctx)
 {
     Q_UNUSED(ctx);
     double t = currentTime();
@@ -1248,5 +1308,3 @@ Value DatePrototype::method_toJSON(SimpleCallContext *ctx)
 
     return toIso->call(ctx, ctx->thisObject, 0, 0);
 }
-
-#include "qv4dateobject_p_jsclass.cpp"
diff --git a/src/qml/qml/v4/qv4dateobject_p.h b/src/qml/qml/v4/qv4dateobject_p.h
index ecb7384d99..629dfa57e7 100644
--- a/src/qml/qml/v4/qv4dateobject_p.h
+++ b/src/qml/qml/v4/qv4dateobject_p.h
@@ -59,23 +59,27 @@ struct DateObject: Object {
     QDateTime toQDateTime() const;
 };
 
-struct QV4_JS_CLASS(DatePrototype): DateObject
+struct DateCtor: FunctionObject
 {
-    QV4_ANNOTATE(argc 7)
+    DateCtor(ExecutionContext *scope);
 
+    static Value construct(Managed *, ExecutionContext *context, Value *args, int argc);
+    static Value call(Managed *that, ExecutionContext *, const Value &, Value *, int);
+
+protected:
+    static const ManagedVTable static_vtbl;
+};
+
+struct DatePrototype: DateObject
+{
     DatePrototype(ExecutionEngine *engine): DateObject(engine, Value::fromDouble(qSNaN())) {}
     void init(ExecutionContext *ctx, const Value &ctor);
-    void initClass(ExecutionEngine *ctx, const Value &ctor);
-    static Object *newConstructor(ExecutionContext *scope);
 
     static double getThisDate(ExecutionContext *ctx);
 
-    static Value ctor_method_construct(Managed *, ExecutionContext *context, Value *args, int argc);
-    static Value ctor_method_call(Managed *that, ExecutionContext *, const Value &, Value *, int);
-
-    static Value ctor_method_parse(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value ctor_method_UTC(SimpleCallContext *ctx) QV4_ARGC(7);
-    static Value ctor_method_now(SimpleCallContext *ctx);
+    static Value method_parse(SimpleCallContext *ctx);
+    static Value method_UTC(SimpleCallContext *ctx);
+    static Value method_now(SimpleCallContext *ctx);
 
     static Value method_toString(SimpleCallContext *ctx);
     static Value method_toDateString(SimpleCallContext *ctx);
@@ -103,25 +107,25 @@ struct QV4_JS_CLASS(DatePrototype): DateObject
     static Value method_getMilliseconds(SimpleCallContext *ctx);
     static Value method_getUTCMilliseconds(SimpleCallContext *ctx);
     static Value method_getTimezoneOffset(SimpleCallContext *ctx);
-    static Value method_setTime(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setMilliseconds(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setUTCMilliseconds(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setSeconds(SimpleCallContext *ctx) QV4_ARGC(2);
-    static Value method_setUTCSeconds(SimpleCallContext *ctx) QV4_ARGC(2);
-    static Value method_setMinutes(SimpleCallContext *ctx) QV4_ARGC(3);
-    static Value method_setUTCMinutes(SimpleCallContext *ctx) QV4_ARGC(3);
-    static Value method_setHours(SimpleCallContext *ctx) QV4_ARGC(4);
-    static Value method_setUTCHours(SimpleCallContext *ctx) QV4_ARGC(4);
-    static Value method_setDate(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setUTCDate(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setMonth(SimpleCallContext *ctx) QV4_ARGC(2);
-    static Value method_setUTCMonth(SimpleCallContext *ctx) QV4_ARGC(2);
-    static Value method_setYear(SimpleCallContext *ctx) QV4_ARGC(1);
-    static Value method_setFullYear(SimpleCallContext *ctx) QV4_ARGC(3);
-    static Value method_setUTCFullYear(SimpleCallContext *ctx) QV4_ARGC(3);
-    static Value method_toUTCString(SimpleCallContext *ctx) QV4_ANNOTATE(alias toGMTString);
+    static Value method_setTime(SimpleCallContext *ctx);
+    static Value method_setMilliseconds(SimpleCallContext *ctx);
+    static Value method_setUTCMilliseconds(SimpleCallContext *ctx);
+    static Value method_setSeconds(SimpleCallContext *ctx);
+    static Value method_setUTCSeconds(SimpleCallContext *ctx);
+    static Value method_setMinutes(SimpleCallContext *ctx);
+    static Value method_setUTCMinutes(SimpleCallContext *ctx);
+    static Value method_setHours(SimpleCallContext *ctx);
+    static Value method_setUTCHours(SimpleCallContext *ctx);
+    static Value method_setDate(SimpleCallContext *ctx);
+    static Value method_setUTCDate(SimpleCallContext *ctx);
+    static Value method_setMonth(SimpleCallContext *ctx);
+    static Value method_setUTCMonth(SimpleCallContext *ctx);
+    static Value method_setYear(SimpleCallContext *ctx);
+    static Value method_setFullYear(SimpleCallContext *ctx);
+    static Value method_setUTCFullYear(SimpleCallContext *ctx);
+    static Value method_toUTCString(SimpleCallContext *ctx);
     static Value method_toISOString(SimpleCallContext *ctx);
-    static Value method_toJSON(SimpleCallContext *ctx) QV4_ARGC(1);
+    static Value method_toJSON(SimpleCallContext *ctx);
 };
 
 }
diff --git a/src/qml/qml/v4/qv4engine.cpp b/src/qml/qml/v4/qv4engine.cpp
index c0119a7412..f0ceaf79fc 100644
--- a/src/qml/qml/v4/qv4engine.cpp
+++ b/src/qml/qml/v4/qv4engine.cpp
@@ -182,7 +182,7 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory)
     booleanCtor = Value::fromObject(new (memoryManager) BooleanCtor(rootContext));
     arrayCtor = Value::fromObject(new (memoryManager) ArrayCtor(rootContext));
     functionCtor = Value::fromObject(new (memoryManager) FunctionCtor(rootContext));
-    dateCtor = Value::fromObject(DatePrototype::newConstructor(rootContext));
+    dateCtor = Value::fromObject(new (memoryManager) DateCtor(rootContext));
     regExpCtor = Value::fromObject(new (memoryManager) RegExpCtor(rootContext));
     errorCtor = Value::fromObject(new (memoryManager) ErrorCtor(rootContext));
     evalErrorCtor = Value::fromObject(new (memoryManager) EvalErrorCtor(rootContext));
diff --git a/src/qml/qml/v4/qv4object_p.h b/src/qml/qml/v4/qv4object_p.h
index d21f33de85..85faf8f420 100644
--- a/src/qml/qml/v4/qv4object_p.h
+++ b/src/qml/qml/v4/qv4object_p.h
@@ -433,11 +433,6 @@ inline void Object::setArrayLengthUnchecked(uint l)
     }
 }
 
-// Macros used for JS class annotation
-#define QV4_JS_CLASS(ClassName) ClassName
-#define QV4_ANNOTATE(...)
-#define QV4_ARGC(...)
-
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/v4/v4.pri b/src/qml/qml/v4/v4.pri
index 28910f4979..3538e0fc60 100644
--- a/src/qml/qml/v4/v4.pri
+++ b/src/qml/qml/v4/v4.pri
@@ -107,19 +107,6 @@ HEADERS += \
     $$PWD/qv4include_p.h \
     $$PWD/qv4qobjectwrapper_p.h
 
-OTHER_FILES += \
-    $$PWD/v4classgen
-
-JS_CLASS_SOURCES += $$PWD/qv4dateobject_p.h
-
-js_class_bindings.output = ${QMAKE_FILE_BASE}_jsclass.cpp
-js_class_bindings.input = JS_CLASS_SOURCES
-js_class_bindings.script = $$PWD/v4classgen
-js_class_bindings.commands = python $$js_class_bindings.script ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
-js_class_bindings.depends += $$js_class_bindings.script $$PWD/qv4managed_p.h
-js_class_bindings.CONFIG += no_link
-QMAKE_EXTRA_COMPILERS += js_class_bindings
-
 llvm-libs {
 
 SOURCES += \
diff --git a/src/qml/qml/v4/v4classgen b/src/qml/qml/v4/v4classgen
deleted file mode 100755
index 82d6dbf7f0..0000000000
--- a/src/qml/qml/v4/v4classgen
+++ /dev/null
@@ -1,315 +0,0 @@
-#!/usr/bin/python
-
-import re, sys, os
-
-class ParsedMethod():
-    def __init__(self, name, methodPrefix, static):
-        self.name = name
-        self.methodPrefix = methodPrefix
-        self.options = {}
-        self.static = static
-
-    def isClassMethod(self):
-        return self.static
-
-    def isGetter(self):
-        return self.name.startswith("get_")
-
-    def isSetter(self):
-        return self.name.startswith("set_")
-
-    def isAccessor(self):
-        return self.isGetter() or self.isSetter()
-
-    def nameWithoutGetterSetterPrefix(self):
-        return self.name[4:]
-
-    def fullMethodName(self):
-        return self.methodPrefix + "_" + self.name
-
-    def generateBinding(self, out, objectPrefix = ""):
-        length = 0
-
-        methodName = self.methodPrefix + "_" + self.name
-        if not self.isClassMethod():
-            methodName = "wrap_" + methodName
-
-        if "argc" in self.options:
-            length = self.options["argc"]
-        out.write("    %sdefineDefaultProperty(engine, QStringLiteral(\"%s\"), %s, %s);\n" % (objectPrefix, self.name, methodName, length))
-        if "alias" in self.options:
-            out.write("    %sdefineDefaultProperty(engine, QStringLiteral(\"%s\"), %s, %s);\n" % (objectPrefix, self.options["alias"], methodName, length))
-
-    def generateMemberFunctionWrapper(self, out, parsedClass):
-        out.write("static QV4::Value wrap_%s_%s(QV4::SimpleCallContext *ctx)\n" % (self.methodPrefix, self.name))
-        out.write("{\n")
-        out.write("    QV4::Object *thatObject = ctx->thisObject.asObject();\n")
-        out.write("    if (!thatObject)\n")
-        out.write("        ctx->throwTypeError();\n")
-        out.write("    %s *o = thatObject->as%s();\n" % (parsedClass.name, parsedClass.managedTypeName()))
-        out.write("    if (!o)\n")
-        out.write("        ctx->throwTypeError();\n")
-        out.write("    return o->%s_%s(ctx);\n" % (self.methodPrefix, self.name))
-        out.write("}\n")
-        out.write("\n")
-
-class ParsedClass():
-    def __init__(self, name):
-        self.name = name
-        self.options = {}
-        self.methods = {}
-        self.ctor_methods = {}
-        self.accessors = {}
-
-    def needsConstructor(self):
-        return len(self.ctor_methods) > 0
-
-    def managedTypeName(self):
-        if "managedTypeName" in self.options:
-            return self.options["managedTypeName"]
-        return self.name
-
-    def option(self, name):
-        if name in self.options:
-            return self.options[name]
-        return None
-
-class Accessor():
-    def __init__(self, name):
-        self.name = name
-        self.getter = None
-        self.setter = None
-
-    def generateBinding(self, out, parsedClass, obj):
-        managedType = "type"
-        if len(obj) > 0:
-            managedType = obj + "internalType()"
-
-        getter = "0"
-        if self.getter:
-            getter = "%s::%s" % (parsedClass.name, self.getter.fullMethodName())
-        setter = "0"
-        if self.setter:
-            setter = "%s::%s" % (parsedClass.name, self.setter.fullMethodName())
-
-        out.write("    %sdefineAccessorProperty(engine, QStringLiteral(\"%s\"), %s, %s);\n" % (obj, self.name, getter, setter))
-
-def parseOptions(options):
-    options = options.split(" ")
-    result = {}
-    for opt in [options[i : i + 2] for i in range(0, len(options), 2)]:
-        result[opt[0]] = opt[1]
-    return result
-
-def parseMethod(line, match, methodPrefix):
-    annotatePattern = re.compile(r".*QV4_ANNOTATE\((?P<Options>.+)\).*")
-    argcPattern = re.compile(r".*QV4_ARGC\((?P<count>\d+)\).*")
-
-    method = ParsedMethod(match.group("MethodName"), methodPrefix, line.find("static") == 0)
-
-    annotateMatch = annotatePattern.match(line)
-    if annotateMatch:
-        method.options = parseOptions(annotateMatch.group("Options"))
-
-    argcMatch = argcPattern.match(line)
-    if argcMatch:
-        method.options["argc"] = argcMatch.group("count")
-
-    return method
-
-def parse(lines):
-    classes = []
-    currentClass = None
-    classPattern = re.compile(r".*QV4_JS_CLASS\((?P<ClassName>\w+)\).*")
-    annotatePattern = re.compile(r".*QV4_ANNOTATE\((?P<Options>.+)\).*")
-    methodPattern = re.compile(r".*\smethod_(?P<MethodName>\w+)\(.*\).*;?")
-    ctorMethodPattern = re.compile(r".*\sctor_method_(?P<MethodName>\w+)\(.*\).*;")
-
-    for line in lines:
-        if line == "};" and currentClass != None:
-            classes.append(currentClass)
-            currentClass = None
-            continue
-        line = line.strip()
-        classMatch = classPattern.match(line)
-        if classMatch:
-            name = classMatch.group("ClassName")
-            if currentClass != None:
-                classes.append(currentClass)
-            currentClass = ParsedClass(name)
-            continue
-
-        if currentClass == None:
-            continue
-
-        methodMatch = methodPattern.match(line)
-        if methodMatch:
-            method = parseMethod(line, methodMatch, "method")
-            if method.isAccessor():
-                name = method.nameWithoutGetterSetterPrefix()
-                acc = currentClass.accessors.setdefault(name, Accessor(name))
-                if method.isSetter():
-                    acc.setter = method
-                else:
-                    acc.getter = method
-            else:
-                currentClass.methods[method.name] = method
-            continue
-
-        ctorMethodMatch = ctorMethodPattern.match(line)
-        if ctorMethodMatch:
-            method = parseMethod(line, ctorMethodMatch, "ctor_method")
-            currentClass.ctor_methods[method.name] = method
-            continue
-
-        annotateMatch = annotatePattern.match(line)
-        if annotateMatch:
-            currentClass.options = parseOptions(annotateMatch.group("Options"))
-            continue
-
-    return classes
-
-def generateBinding(out, parsedClass, vtableEntries):
-    if parsedClass.needsConstructor():
-        ctorClass = parsedClass.name.replace("Prototype", "Ctor")
-
-        out.write("class %s: public QV4::FunctionObject {\n" % ctorClass);
-        out.write("public:\n");
-        out.write("    %s(QV4::ExecutionContext *scope)\n" % ctorClass);
-        out.write("        : QV4::FunctionObject(scope, scope->engine->newIdentifier(QStringLiteral(\"%s\")))\n" % ctorClass.replace("Ctor", ""));
-        out.write("    { vtbl = &static_vtbl; }\n");
-        out.write("\n");
-        out.write("protected:\n");
-        out.write("    static const QV4::ManagedVTable static_vtbl;\n");
-        out.write("};\n\n");
-        out.write("const QV4::ManagedVTable %s::static_vtbl = {\n" % ctorClass);
-
-        ctorOverrides = set(parsedClass.ctor_methods.keys())
-
-        for method in vtableEntries:
-            entry = "FunctionObject::" + method
-            if method in ctorOverrides:
-                entry = parsedClass.name + "::ctor_method_" + method
-            out.write("    " + entry + ",\n")
-        out.write("    \"%s\"\n" % parsedClass.name.replace("Prototype", "Ctor"));
-        out.write("};\n\n")
-
-        out.write("QV4::Object *%s::newConstructor(QV4::ExecutionContext *scope)\n" % parsedClass.name)
-        out.write("{\n")
-        out.write("    return new (scope->engine->memoryManager) %s(scope);\n" % ctorClass)
-        out.write("}\n\n")
-
-    for method in parsedClass.methods.values():
-        if not method.isClassMethod():
-            method.generateMemberFunctionWrapper(out, parsedClass)
-
-    for method in parsedClass.ctor_methods.values():
-        if not method.isClassMethod():
-            method.generateMemberFunctionWrapper(out, parsedClass)
-
-    ctorSignature = ""
-    if parsedClass.needsConstructor():
-        ctorSignature = ", const QV4::Value &ctor"
-
-    obj = ""
-    objSignature = ""
-    if parsedClass.option("staticInitClass") == "true":
-        objSignature = ", const QV4::Value &obj"
-        obj = "obj.objectValue()->"
-
-    out.write("void %s::initClass(QV4::ExecutionEngine *engine%s%s)\n" % (parsedClass.name, objSignature, ctorSignature))
-    out.write("{\n")
-
-    if parsedClass.needsConstructor():
-        ctor = "ctor.objectValue()->"
-        ctorLength = 0
-        if "argc" in parsedClass.options:
-            ctorLength = parsedClass.options["argc"]
-
-        out.write("    %sdefineReadonlyProperty(engine->id_prototype, QV4::Value::fromObject(this));\n" % ctor)
-        out.write("    %sdefineReadonlyProperty(engine->id_length, QV4::Value::fromInt32(%s));\n" % (ctor, ctorLength))
-        out.write("\n")
-
-        for method in parsedClass.ctor_methods.values():
-            if method.name == "construct" or method.name == "call":
-                continue
-            method.generateBinding(out, ctor);
-
-        out.write("\n")
-        out.write("    defineDefaultProperty(engine, QStringLiteral(\"constructor\"), ctor);\n");
-
-        out.write("\n")
-
-    for method in parsedClass.methods.values():
-        method.generateBinding(out, obj)
-
-    for accessor in parsedClass.accessors.values():
-        accessor.generateBinding(out, parsedClass, obj)
-
-    out.write("}\n")
-
-def extractManagedVTableLayout(basePath):
-    def VTableDefintionIterator(lines):
-        i = 0
-        while i < len(lines):
-            if lines[i].strip().startswith("#define DEFINE_MANAGED_VTABLE(classname)"):
-                break;
-            i = i + 1
-        if i >= len(lines):
-            return
-        i = i + 1
-        if not lines[i].strip().startswith("const QV4::ManagedVTable classname::static_vtbl ="):
-            print("Expected static_vtbl definition at line %s" % i)
-            return
-        i = i + 1
-        if not lines[i].strip().startswith("{"):
-            print("Expected static_vtbl definition at line %s" % i)
-            return
-        i = i + 1
-        while i < len(lines):
-            line = lines[i].strip()
-            if "#classname" in line:
-                break
-            yield line.split(",")[0]
-            i = i + 1
-        return
-
-    qv4managedHeader = basePath + "/qv4managed_p.h"
-    fields = []
-    try:
-        header = open(qv4managedHeader, "r")
-        it = VTableDefintionIterator(header.read().splitlines())
-        for entry in it:
-            fields.append(entry)
-        header.close()
-    except IOError:
-        print("Could not open qv4managed_p.h at %s" % qv4managedHeader)
-        sys.exit(1)
-    return fields
-
-if len(sys.argv) != 3 and len(sys.argv) != 2:
-    print("Usage: v4classgen input-file [output-file]\n")
-    sys.exit(1)
-
-vtableEntries = extractManagedVTableLayout(os.path.dirname(__file__))
-if len(vtableEntries) ==  0:
-    print("Could not parse vtable layout from qv4managed_p.h")
-    sys.exit(1)
-
-f = open(sys.argv[1])
-
-out = sys.stdout
-if len(sys.argv) == 3:
-    out = open(sys.argv[2], 'w')
-
-lines = f.read().splitlines()
-classes = parse(lines)
-f.close()
-
-out.write("/* Generated file, do not edit */\n")
-
-for parsedClass in classes:
-    out.write("\n")
-    generateBinding(out, parsedClass, vtableEntries)
-
-out.close()