Fix run-time string handling with regards to the new heap

Changed runtimeStrings to be an array of Heap::String pointers instead of
indirect String pointers. Later that member along with other GC related members
will go into a managed subclass. Meanwhile the generated code no more loads
String pointers directly but just passes the index into the run-time strings to
the run-time functions, which in turn will load the heap string into a scoped
string.

Also replaced the template<T> Value::operator=(T *m) with a non-template
overload that takes a Managed *, in order to help the compiler choose the
non-template operator=(Heap::Base *) overload. This allows removing a bunch
of Value::fromHeapObject calls.

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

1 files changed, 5 insertions, 4 deletions

diff --git a/src/qml/jsruntime/qv4function.cpp b/src/qml/jsruntime/qv4function.cpp
index aedbff21be..37e19c559b 100644
--- a/src/qml/jsruntime/qv4function.cpp
+++ b/src/qml/jsruntime/qv4function.cpp
@@ -56,9 +56,9 @@ Function::Function(ExecutionEngine *engine, CompiledData::CompilationUnit *unit,
     const quint32 *formalsIndices = compiledFunction->formalsTable();
     // iterate backwards, so we get the right ordering for duplicate names
     Scope scope(engine);
-    ScopedString s(scope);
+    ScopedString arg(scope);
     for (int i = static_cast<int>(compiledFunction->nFormals - 1); i >= 0; --i) {
-        String *arg = compilationUnit->runtimeStrings[formalsIndices[i]];
+        arg = compilationUnit->runtimeStrings[formalsIndices[i]];
         while (1) {
             InternalClass *newClass = internalClass->addMember(arg, Attr_NotConfigurable);
             if (newClass != internalClass) {
@@ -66,13 +66,14 @@ Function::Function(ExecutionEngine *engine, CompiledData::CompilationUnit *unit,
                 break;
             }
             // duplicate arguments, need some trick to store them
-            arg = (s = engine->memoryManager->alloc<String>(engine, arg->d(), engine->newString(QString(0xfffe)))).getPointer();
+            arg = engine->memoryManager->alloc<String>(engine, arg->d(), engine->newString(QString(0xfffe)));
         }
     }
 
     const quint32 *localsIndices = compiledFunction->localsTable();
+    ScopedString local(scope);
     for (quint32 i = 0; i < compiledFunction->nLocals; ++i) {
-        String *local = compilationUnit->runtimeStrings[localsIndices[i]];
+        local = compilationUnit->runtimeStrings[localsIndices[i]];
         internalClass = internalClass->addMember(local, Attr_NotConfigurable);
     }
 }