Merge branch 'master' of scm.dev.nokia.troll.no:qt/qt into earth-master

Conflicts:
	src/network/access/qnetworkreplyimpl.cpp
	tests/auto/moc/tst_moc.cpp

8 files changed, 141 insertions, 14 deletions

diff --git a/src/tools/moc/generator.cpp b/src/tools/moc/generator.cpp
index 222e5f6..4df7ae5 100644
--- a/src/tools/moc/generator.cpp
+++ b/src/tools/moc/generator.cpp
@@ -181,10 +181,14 @@ void Generator::generateCode()
     int methodCount = cdef->signalList.count() + cdef->slotList.count() + cdef->methodList.count();
     fprintf(out, "    %4d, %4d, // methods\n", methodCount, methodCount ? index : 0);
     index += methodCount * 5;
+    if (cdef->revisionedMethods)
+        index += methodCount;
     fprintf(out, "    %4d, %4d, // properties\n", cdef->propertyList.count(), cdef->propertyList.count() ? index : 0);
     index += cdef->propertyList.count() * 3;
     if(cdef->notifyableProperties)
         index += cdef->propertyList.count();
+    if (cdef->revisionedProperties)
+        index += cdef->propertyList.count();
     fprintf(out, "    %4d, %4d, // enums/sets\n", cdef->enumList.count(), cdef->enumList.count() ? index : 0);
 
     int enumsIndex = index;
@@ -217,6 +221,14 @@ void Generator::generateCode()
 //
     generateFunctions(cdef->methodList, "method", MethodMethod);
 
+//
+// Build method version arrays
+//
+    if (cdef->revisionedMethods) {
+        generateFunctionRevisions(cdef->signalList, "signal");
+        generateFunctionRevisions(cdef->slotList, "slot");
+        generateFunctionRevisions(cdef->methodList, "method");
+    }
 
 //
 // Build property array
@@ -456,7 +468,7 @@ void Generator::generateFunctions(QList<FunctionDef>& list, const char *functype
         }
         sig += ')';
 
-        char flags = type;
+        unsigned char flags = type;
         if (f.access == FunctionDef::Private)
             flags |= AccessPrivate;
         else if (f.access == FunctionDef::Public)
@@ -475,11 +487,23 @@ void Generator::generateFunctions(QList<FunctionDef>& list, const char *functype
             flags |= MethodCloned;
         if (f.isScriptable)
             flags |= MethodScriptable;
+        if (f.revision > 0)
+            flags |= MethodRevisioned;
         fprintf(out, "    %4d, %4d, %4d, %4d, 0x%02x,\n", strreg(sig),
                 strreg(arguments), strreg(f.normalizedType), strreg(f.tag), flags);
     }
 }
 
+void Generator::generateFunctionRevisions(QList<FunctionDef>& list, const char *functype)
+{
+    if (list.count())
+        fprintf(out, "\n // %ss: revision\n", functype);
+    for (int i = 0; i < list.count(); ++i) {
+        const FunctionDef &f = list.at(i);
+        fprintf(out, "    %4d,\n", f.revision);
+    }
+}
+
 void Generator::generateProperties()
 {
     //
@@ -537,6 +561,9 @@ void Generator::generateProperties()
         if (p.notifyId != -1)
             flags |= Notify;
 
+        if (p.revision > 0)
+            flags |= Revisioned;
+
         if (p.constant)
             flags |= Constant;
         if (p.final)
@@ -562,6 +589,13 @@ void Generator::generateProperties()
                         p.notifyId);
         }
     }
+    if (cdef->revisionedProperties) {
+        fprintf(out, "\n // properties: revision\n");
+        for (int i = 0; i < cdef->propertyList.count(); ++i) {
+            const PropertyDef &p = cdef->propertyList.at(i);
+            fprintf(out, "    %4d,\n", p.revision);
+        }
+    }
 }
 
 void Generator::generateEnums(int index)
diff --git a/src/tools/moc/generator.h b/src/tools/moc/generator.h
index 63605eb..ed0980e 100644
--- a/src/tools/moc/generator.h
+++ b/src/tools/moc/generator.h
@@ -58,6 +58,7 @@ public:
 private:
     void generateClassInfos();
     void generateFunctions(QList<FunctionDef> &list, const char *functype, int type);
+    void generateFunctionRevisions(QList<FunctionDef>& list, const char *functype);
     void generateEnums(int index);
     void generateProperties();
     void generateMetacall();
diff --git a/src/tools/moc/keywords.cpp b/src/tools/moc/keywords.cpp
index 0eca110..9a8aa41 100644
--- a/src/tools/moc/keywords.cpp
+++ b/src/tools/moc/keywords.cpp
@@ -43,12 +43,12 @@
 // DO NOT EDIT.
 
 static const short keyword_trans[][128] = {
-    {0,0,0,0,0,0,0,0,0,533,530,0,0,0,0,0,
+    {0,0,0,0,0,0,0,0,0,541,538,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-     533,252,531,534,0,38,239,532,25,26,236,234,30,235,27,237,
+     541,252,539,542,0,38,239,540,25,26,236,234,30,235,27,237,
      22,22,22,22,22,22,22,22,22,22,34,41,23,39,24,43,
      0,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-     8,21,8,8,8,8,8,8,8,8,8,31,535,32,238,8,
+     8,21,8,8,8,8,8,8,8,8,8,31,543,32,238,8,
      0,1,2,3,4,5,6,7,8,9,8,8,10,11,12,13,
      14,8,15,16,17,18,19,20,8,8,8,36,245,37,248,0},
     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -190,7 +190,7 @@ static const short keyword_trans[][128] = {
     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,42,0,0,0,28,0,
-     538,538,538,538,538,538,538,538,538,538,0,0,0,0,0,0,
+     546,546,546,546,546,546,546,546,546,546,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -349,7 +349,7 @@ static const short keyword_trans[][128] = {
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-     0,0,0,0,0,0,0,0,0,0,537,0,0,0,0,536,
+     0,0,0,0,0,0,0,0,0,0,545,0,0,0,0,544,
      0,0,0,0,0,0,0,0,0,0,0,0,0,258,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -392,7 +392,7 @@ static const short keyword_trans[][128] = {
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,439,388,378,383,364,0,448,0,0,0,0,0,358,
-     370,0,0,436,0,0,0,0,0,0,0,0,0,0,0,0,
+     370,0,530,436,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -983,6 +983,14 @@ static const struct
     {CHARACTER, 0, 84, 528, CHARACTER},
     {CHARACTER, 0, 89, 529, CHARACTER},
     {Q_PRIVATE_PROPERTY_TOKEN, 0, 0, 0, CHARACTER},
+    {CHARACTER, 0, 69, 531, CHARACTER},
+    {CHARACTER, 0, 86, 532, CHARACTER},
+    {CHARACTER, 0, 73, 533, CHARACTER},
+    {CHARACTER, 0, 83, 534, CHARACTER},
+    {CHARACTER, 0, 73, 535, CHARACTER},
+    {CHARACTER, 0, 79, 536, CHARACTER},
+    {CHARACTER, 0, 78, 537, CHARACTER},
+    {Q_REVISION_TOKEN, 0, 0, 0, CHARACTER},
     {NEWLINE, 0, 0, 0, NOTOKEN},
     {QUOTE, 0, 0, 0, NOTOKEN},
     {SINGLEQUOTE, 0, 0, 0, NOTOKEN},
diff --git a/src/tools/moc/moc.cpp b/src/tools/moc/moc.cpp
index 5e8b2b8..74b1ace 100644
--- a/src/tools/moc/moc.cpp
+++ b/src/tools/moc/moc.cpp
@@ -335,6 +335,23 @@ bool Moc::testFunctionAttribute(Token tok, FunctionDef *def)
     return false;
 }
 
+bool Moc::testFunctionRevision(FunctionDef *def)
+{
+    if (test(Q_REVISION_TOKEN)) {
+        next(LPAREN);
+        QByteArray revision = lexemUntil(RPAREN);
+        revision.remove(0, 1);
+        revision.chop(1);
+        bool ok = false;
+        def->revision = revision.toInt(&ok);
+        if (!ok || def->revision < 0)
+            error("Invalid revision");
+        return true;
+    }
+
+    return false;
+}
+
 // returns false if the function should be ignored
 bool Moc::parseFunction(FunctionDef *def, bool inMacro)
 {
@@ -342,7 +359,7 @@ bool Moc::parseFunction(FunctionDef *def, bool inMacro)
     //skip modifiers and attributes
     while (test(INLINE) || test(STATIC) ||
         (test(VIRTUAL) && (def->isVirtual = true)) //mark as virtual
-        || testFunctionAttribute(def)) {}
+        || testFunctionAttribute(def) || testFunctionRevision(def)) {}
     bool templateFunction = (lookup() == TEMPLATE);
     def->type = parseType();
     if (def->type.name.isEmpty()) {
@@ -433,7 +450,7 @@ bool Moc::parseMaybeFunction(const ClassDef *cdef, FunctionDef *def)
     //skip modifiers and attributes
     while (test(EXPLICIT) || test(INLINE) || test(STATIC) ||
         (test(VIRTUAL) && (def->isVirtual = true)) //mark as virtual
-        || testFunctionAttribute(def)) {}
+        || testFunctionAttribute(def) || testFunctionRevision(def)) {}
     bool tilde = test(TILDE);
     def->type = parseType();
     if (def->type.name.isEmpty())
@@ -697,6 +714,8 @@ void Moc::parse()
                                     funcDef.arguments.removeLast();
                                     def.slotList += funcDef;
                                 }
+                                if (funcDef.revision > 0)
+                                    ++def.revisionedMethods;
                             } else if (funcDef.isSignal) {
                                 def.signalList += funcDef;
                                 while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
@@ -704,6 +723,8 @@ void Moc::parse()
                                     funcDef.arguments.removeLast();
                                     def.signalList += funcDef;
                                 }
+                                if (funcDef.revision > 0)
+                                    ++def.revisionedMethods;
                             } else if (funcDef.isInvokable) {
                                 def.methodList += funcDef;
                                 while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
@@ -711,6 +732,8 @@ void Moc::parse()
                                     funcDef.arguments.removeLast();
                                     def.methodList += funcDef;
                                 }
+                                if (funcDef.revision > 0)
+                                    ++def.revisionedMethods;
                             }
                         }
                     } else {
@@ -809,6 +832,18 @@ QList<QMetaObject*> Moc::generate(bool ignoreProperties)
 
 void Moc::parseSlots(ClassDef *def, FunctionDef::Access access)
 {
+    int defaultRevision = -1;
+    if (test(Q_REVISION_TOKEN)) {
+        next(LPAREN);
+        QByteArray revision = lexemUntil(RPAREN);
+        revision.remove(0, 1);
+        revision.chop(1);
+        bool ok = false;
+        defaultRevision = revision.toInt(&ok);
+        if (!ok || defaultRevision < 0)
+            error("Invalid revision");
+    }
+
     next(COLON);
     while (inClass(def) && hasNext()) {
         switch (next()) {
@@ -834,6 +869,12 @@ void Moc::parseSlots(ClassDef *def, FunctionDef::Access access)
         funcDef.access = access;
         if (!parseFunction(&funcDef))
             continue;
+        if (funcDef.revision > 0) {
+            ++def->revisionedMethods;
+        } else if (defaultRevision != -1) {
+            funcDef.revision = defaultRevision;
+            ++def->revisionedMethods;
+        }
         def->slotList += funcDef;
         while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
             funcDef.wasCloned = true;
@@ -845,6 +886,18 @@ void Moc::parseSlots(ClassDef *def, FunctionDef::Access access)
 
 void Moc::parseSignals(ClassDef *def)
 {
+    int defaultRevision = -1;
+    if (test(Q_REVISION_TOKEN)) {
+        next(LPAREN);
+        QByteArray revision = lexemUntil(RPAREN);
+        revision.remove(0, 1);
+        revision.chop(1);
+        bool ok = false;
+        defaultRevision = revision.toInt(&ok);
+        if (!ok || defaultRevision < 0)
+            error("Invalid revision");
+    }
+
     next(COLON);
     while (inClass(def) && hasNext()) {
         switch (next()) {
@@ -872,6 +925,12 @@ void Moc::parseSignals(ClassDef *def)
             warning("Signals cannot be declared virtual");
         if (funcDef.inlineCode)
             error("Not a signal declaration");
+        if (funcDef.revision > 0) {
+            ++def->revisionedMethods;
+        } else if (defaultRevision != -1) {
+            funcDef.revision = defaultRevision;
+            ++def->revisionedMethods;
+        }
         def->signalList += funcDef;
         while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
             funcDef.wasCloned = true;
@@ -914,7 +973,6 @@ void Moc::createPropertyDef(PropertyDef &propDef)
     propDef.name = lexem();
     while (test(IDENTIFIER)) {
         QByteArray l = lexem();
-
         if (l[0] == 'C' && l == "CONSTANT") {
             propDef.constant = true;
             continue;
@@ -926,6 +984,10 @@ void Moc::createPropertyDef(PropertyDef &propDef)
         QByteArray v, v2;
         if (test(LPAREN)) {
             v = lexemUntil(RPAREN);
+        } else if (test(INTEGER_LITERAL)) {
+            v = lexem();
+            if (l != "REVISION")
+                error(1);
         } else {
             next(IDENTIFIER);
             v = lexem();
@@ -940,7 +1002,12 @@ void Moc::createPropertyDef(PropertyDef &propDef)
                 propDef.read = v;
             else if (l == "RESET")
                 propDef.reset = v + v2;
-            else
+            else if (l == "REVISION") {
+                bool ok = false;
+                propDef.revision = v.toInt(&ok);
+                if (!ok || propDef.revision < 0)
+                    error(1);
+            } else
                 error(2);
             break;
         case 'S':
@@ -1005,6 +1072,8 @@ void Moc::parseProperty(ClassDef *def)
 
     if(!propDef.notify.isEmpty())
         def->notifyableProperties++;
+    if (propDef.revision > 0)
+        ++def->revisionedProperties;
     def->propertyList += propDef;
 }
 
@@ -1031,6 +1100,8 @@ void Moc::parsePrivateProperty(ClassDef *def)
 
     if(!propDef.notify.isEmpty())
         def->notifyableProperties++;
+    if (propDef.revision > 0)
+        ++def->revisionedProperties;
 
     def->propertyList += propDef;
 }
@@ -1180,6 +1251,9 @@ void Moc::parseSlotInPrivate(ClassDef *def, FunctionDef::Access access)
         funcDef.arguments.removeLast();
         def->slotList += funcDef;
     }
+    if (funcDef.revision > 0)
+        ++def->revisionedMethods;
+
 }
 
 QByteArray Moc::lexemUntil(Token target)
diff --git a/src/tools/moc/moc.h b/src/tools/moc/moc.h
index 9543a05..38c3917 100644
--- a/src/tools/moc/moc.h
+++ b/src/tools/moc/moc.h
@@ -86,7 +86,7 @@ struct FunctionDef
     FunctionDef(): returnTypeIsVolatile(false), access(Private), isConst(false), isVirtual(false),
                    inlineCode(false), wasCloned(false), isCompat(false), isInvokable(false),
                    isScriptable(false), isSlot(false), isSignal(false),
-                   isConstructor(false), isDestructor(false), isAbstract(false) {}
+                   isConstructor(false), isDestructor(false), isAbstract(false), revision(0) {}
     Type type;
     QByteArray normalizedType;
     QByteArray tag;
@@ -111,11 +111,13 @@ struct FunctionDef
     bool isConstructor;
     bool isDestructor;
     bool isAbstract;
+
+    int revision;
 };
 
 struct PropertyDef
 {
-    PropertyDef():notifyId(-1), constant(false), final(false), gspec(ValueSpec){}
+    PropertyDef():notifyId(-1), constant(false), final(false), gspec(ValueSpec), revision(0){}
     QByteArray name, type, read, write, reset, designable, scriptable, editable, stored, user, notify, inPrivateClass;
     int notifyId;
     bool constant;
@@ -128,6 +130,7 @@ struct PropertyDef
         s += name.mid(1);
         return (s == write);
     }
+    int revision;
 };
 
 
@@ -139,7 +142,8 @@ struct ClassInfoDef
 
 struct ClassDef {
     ClassDef():
-        hasQObject(false), hasQGadget(false), notifyableProperties(0), begin(0), end(0){}
+        hasQObject(false), hasQGadget(false), notifyableProperties(0)
+        , revisionedMethods(0), revisionedProperties(0), begin(0), end(0){}
     QByteArray classname;
     QByteArray qualified;
     QList<QPair<QByteArray, FunctionDef::Access> > superclassList;
@@ -164,6 +168,8 @@ struct ClassDef {
     QMap<QByteArray, bool> enumDeclarations;
     QList<EnumDef> enumList;
     QMap<QByteArray, QByteArray> flagAliases;
+    int revisionedMethods;
+    int revisionedProperties;
 
     int begin;
     int end;
@@ -236,6 +242,7 @@ public:
     // in FunctionDef accordingly
     bool testFunctionAttribute(FunctionDef *def);
     bool testFunctionAttribute(Token tok, FunctionDef *def);
+    bool testFunctionRevision(FunctionDef *def);
 
     void checkSuperClasses(ClassDef *def);
     void checkProperties(ClassDef* cdef);
diff --git a/src/tools/moc/token.cpp b/src/tools/moc/token.cpp
index 733a17e..9d07c48 100644
--- a/src/tools/moc/token.cpp
+++ b/src/tools/moc/token.cpp
@@ -180,6 +180,7 @@ const char *tokenTypeName(Token t)
         case Q_SLOT_TOKEN: return "Q_SLOT_TOKEN";
         case Q_PRIVATE_SLOT_TOKEN: return "Q_PRIVATE_SLOT_TOKEN";
         case Q_PRIVATE_PROPERTY_TOKEN: return "Q_PRIVATE_PROPERTY_TOKEN";
+        case Q_REVISION_TOKEN: return "Q_REVISION_TOKEN";
         case SPECIAL_TREATMENT_MARK: return "SPECIAL_TREATMENT_MARK";
         case MOC_INCLUDE_BEGIN: return "MOC_INCLUDE_BEGIN";
         case MOC_INCLUDE_END: return "MOC_INCLUDE_END";
diff --git a/src/tools/moc/token.h b/src/tools/moc/token.h
index edbb567..95f17c2 100644
--- a/src/tools/moc/token.h
+++ b/src/tools/moc/token.h
@@ -186,6 +186,7 @@ enum Token {
     Q_INVOKABLE_TOKEN,
     Q_SCRIPTABLE_TOKEN,
     Q_PRIVATE_PROPERTY_TOKEN,
+    Q_REVISION_TOKEN,
     Q_META_TOKEN_END,
     SPECIAL_TREATMENT_MARK = Q_META_TOKEN_END,
     MOC_INCLUDE_BEGIN,
diff --git a/src/tools/moc/util/generate_keywords.cpp b/src/tools/moc/util/generate_keywords.cpp
index 777bf3f..26f7a19 100644
--- a/src/tools/moc/util/generate_keywords.cpp
+++ b/src/tools/moc/util/generate_keywords.cpp
@@ -249,6 +249,7 @@ static const Keyword keywords[] = {
     { "Q_SLOT", "Q_SLOT_TOKEN" },
     { "Q_SCRIPTABLE", "Q_SCRIPTABLE_TOKEN" },
     { "Q_PRIVATE_PROPERTY", "Q_PRIVATE_PROPERTY_TOKEN" },
+    { "Q_REVISION", "Q_REVISION_TOKEN" },
     { "\n", "NEWLINE" },
     { "\"", "QUOTE" },
     { "\'", "SINGLEQUOTE" },