Beginning of a new qml parser

The goal is to parse QML and JavaScript binding expressions/functions in one
go and generate data structures that allow for the parsing to happen in a thread
and the instantiation of the object tree in another thread, just reading from
the generated data structures. This will replace qqmlcompiler and the VME.

This new way of loading QML is currently hidden behind the QML_NEW_COMPILER=1
environment variable. There's lots of work left to fill in the gaps in object
construction, Component support, Component.onComplete, error messages, etc. etc.

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

1 files changed, 116 insertions, 25 deletions

diff --git a/src/qml/compiler/qv4compileddata_p.h b/src/qml/compiler/qv4compileddata_p.h
index 237cdf7d62..50ed39f0d8 100644
--- a/src/qml/compiler/qv4compileddata_p.h
+++ b/src/qml/compiler/qv4compileddata_p.h
@@ -178,9 +178,9 @@ struct Unit
         return reinterpret_cast<const JSClassMember*>(ptr + sizeof(JSClass));
     }
 
-    static int calculateSize(uint nStrings, uint nFunctions, uint nRegExps,
+    static int calculateSize(uint headerSize, uint nStrings, uint nFunctions, uint nRegExps,
                              uint nLookups, uint nClasses) {
-        return (sizeof(Unit)
+        return (headerSize
                 + (nStrings + nFunctions + nClasses) * sizeof(uint)
                 + nRegExps * RegExp::calculateSize()
                 + nLookups * Lookup::calculateSize()
@@ -225,77 +225,168 @@ struct Function
 
 struct Value
 {
-    quint32 type; // Invalid, Boolean, Number, String, Function, Object, ListOfObjects
+    enum ValueType {
+        Type_Invalid,
+        Type_Boolean,
+        Type_Number,
+        Type_String,
+        Type_Script,
+        Type_Object
+    };
+
+    quint32 type;
     union {
         bool b;
-        int i;
         double d;
-        quint32 offsetToString;
-        quint32 offsetToFunction;
-        quint32 offsetToObject;
+        quint32 compiledScriptIndex; // used when Type_Script
+        quint32 objectIndex;
     };
+    quint32 stringIndex; // Set for Type_String and Type_Script (the latter because of script strings)
 };
 
 struct Binding
 {
-    quint32 offsetToPropertyName;
+    quint32 propertyNameIndex;
     Value value;
 };
 
 struct Parameter
 {
-    quint32 offsetToName;
+    quint32 nameIndex;
     quint32 type;
-    quint32 offsetToCustomTypeName;
+    quint32 customTypeNameIndex;
     quint32 reserved;
 };
 
 struct Signal
 {
-    quint32 offsetToName;
+    quint32 nameIndex;
     quint32 nParameters;
-    Parameter parameters[1];
+    // Parameter parameters[1];
+
+    const Parameter *parameterAt(int idx) const {
+        return reinterpret_cast<const Parameter*>(this + 1) + idx;
+    }
+
+    static int calculateSize(int nParameters) {
+        return (sizeof(Signal)
+                + nParameters * sizeof(Parameter)
+                + 7) & ~0x7;
+    }
 };
 
 struct Property
 {
-    quint32 offsetToName;
+    enum Type { Var = 0, Variant, Int, Bool, Real, String, Url, Color,
+                Font, Time, Date, DateTime, Rect, Point, Size,
+                Vector2D, Vector3D, Vector4D, Matrix4x4, Quaternion,
+                Alias, Custom, CustomList };
+
+    enum Flags {
+        IsReadOnly = 0x1
+    };
+
+    quint32 nameIndex;
     quint32 type;
-    quint32 offsetToCustomTypeName;
-    quint32 flags; // default, readonly
-    Value value;
+    quint32 customTypeNameIndex;
+    quint32 flags; // readonly
 };
 
 struct Object
 {
-    quint32 offsetToInheritedTypeName;
-    quint32 offsetToId;
-    quint32 offsetToDefaultProperty;
+    quint32 inheritedTypeNameIndex;
+    quint32 idIndex;
+    quint32 indexOfDefaultProperty;
     quint32 nFunctions;
     quint32 offsetToFunctions;
     quint32 nProperties;
     quint32 offsetToProperties;
     quint32 nSignals;
-    quint32 offsetToSignals;
+    quint32 offsetToSignals; // which in turn will be a table with offsets to variable-sized Signal objects
     quint32 nBindings;
     quint32 offsetToBindings;
 //    Function[]
 //    Property[]
 //    Signal[]
 //    Binding[]
+
+    static int calculateSizeExcludingSignals(int nFunctions, int nProperties, int nSignals, int nBindings)
+    {
+        return ( sizeof(Object)
+                 + nFunctions * sizeof(quint32)
+                 + nProperties * sizeof(Property)
+                 + nSignals * sizeof(quint32)
+                 + nBindings * sizeof(Binding)
+                 + 0x7
+               ) & ~0x7;
+    }
+
+    const quint32 *functionOffsetTable() const
+    {
+        return reinterpret_cast<const quint32*>(reinterpret_cast<const char *>(this) + offsetToFunctions);
+    }
+
+    const Property *propertyTable() const
+    {
+        return reinterpret_cast<const Property*>(reinterpret_cast<const char *>(this) + offsetToProperties);
+    }
+
+    const Binding *bindingTable() const
+    {
+        return reinterpret_cast<const Binding*>(reinterpret_cast<const char *>(this) + offsetToBindings);
+    }
+
+    const Signal *signalAt(int idx) const
+    {
+        const uint *offsetTable = reinterpret_cast<const uint*>((reinterpret_cast<const char *>(this)) + offsetToSignals);
+        const uint offset = offsetTable[idx];
+        return reinterpret_cast<const Signal*>(reinterpret_cast<const char*>(this) + offset);
+    }
 };
 
-struct Imports
+struct Location
 {
+    int line;
+    int column;
+};
+
+struct Import
+{
+    enum ImportType {
+        ImportLibrary = 0x1,
+        ImportFile = 0x2,
+        ImportScript = 0x3
+    };
+    quint32 type;
+
+    quint32 uriIndex;
+    quint32 qualifierIndex;
+
+    qint32 majorVersion;
+    qint32 minorVersion;
+
+    Location location;
 };
 
 
 struct QmlUnit
 {
     Unit header;
-    int offsetToTypeName;
-    Imports imports;
-    Object object;
+    quint32 nImports;
+    quint32 offsetToImports;
+    quint32 nObjects;
+    quint32 offsetToObjects;
+    quint32 indexOfRootObject;
+
+    const Import *importAt(int idx) const {
+        return reinterpret_cast<const Import*>((reinterpret_cast<const char *>(this)) + offsetToImports + idx * sizeof(Import));
+    }
+
+    const Object *objectAt(int idx) const {
+        const uint *offsetTable = reinterpret_cast<const uint*>((reinterpret_cast<const char *>(this)) + offsetToObjects);
+        const uint offset = offsetTable[idx];
+        return reinterpret_cast<const Object*>(reinterpret_cast<const char*>(this) + offset);
+    }
 };
 
 // This is how this hooks into the existing structures:
@@ -304,7 +395,7 @@ struct QmlUnit
 //    CompilationUnit * (for functions that need to clean up)
 //    CompiledData::Function *compiledFunction
 
-struct CompilationUnit
+struct Q_QML_EXPORT CompilationUnit
 {
     CompilationUnit()
         : refCount(0)