Move the implementation of normalizeTypeInternal()

This function is only used in src/tools/moc/moc.cpp and
src/corelib/kernel/qmetaobject.cpp. We don't need to include the
static, non-inline declaration and definition every time
qmetaobject_p.h is included.

This also silences the related warning from clang:

../../../include/QtCore/5.0.0/QtCore/private/../../../../../src/corelib/kernel/qmetaobject_p.h:171:19: error:
      function 'normalizeTypeInternal' is not needed and will not be emitted
      [-Werror,-Wunneeded-internal-declaration]
static QByteArray normalizeTypeInternal(const char *t, const char *e, ...
                  ^

Change-Id: I6dfb2cb4d9d82a2ae7795f91169aa62f9a5f2c2f
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@nokia.com>
Reviewed-by: Bradley T. Hughes <bradley.hughes@nokia.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Robin Burchell <robin+qt@viroteck.net>

4 files changed, 211 insertions, 152 deletions

diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri
index 354bb4a9a0..532994151d 100644
--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@@ -26,6 +26,7 @@ HEADERS += \
         kernel/qobjectcleanuphandler.h \
         kernel/qvariant_p.h \
         kernel/qmetaobject_p.h \
+        kernel/qmetaobject_moc_p.h \
         kernel/qmetaobjectbuilder_p.h \
         kernel/qobject_p.h \
         kernel/qcoreglobaldata_p.h \
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 9f404f80cb..1319668c48 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -57,6 +57,9 @@
 #include "private/qobject_p.h"
 #include "private/qmetaobject_p.h"
 
+// for normalizeTypeInternal
+#include "private/qmetaobject_moc_p.h"
+
 #include <ctype.h>
 
 QT_BEGIN_NAMESPACE
diff --git a/src/corelib/kernel/qmetaobject_moc_p.h b/src/corelib/kernel/qmetaobject_moc_p.h
new file mode 100644
index 0000000000..fd4e5d25c8
--- /dev/null
+++ b/src/corelib/kernel/qmetaobject_moc_p.h
@@ -0,0 +1,201 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#if !defined(QMETAOBJECT_P_H) && !defined(UTILS_H)
+# error "Include qmetaobject_p.h (or moc's utils.h) before including this file."
+#endif
+
+QT_BEGIN_NAMESPACE
+
+// This function is shared with moc.cpp. This file should be included where needed.
+static QByteArray normalizeTypeInternal(const char *t, const char *e, bool fixScope = false, bool adjustConst = true)
+{
+    int len = e - t;
+    /*
+      Convert 'char const *' into 'const char *'. Start at index 1,
+      not 0, because 'const char *' is already OK.
+    */
+    QByteArray constbuf;
+    for (int i = 1; i < len; i++) {
+        if ( t[i] == 'c'
+             && strncmp(t + i + 1, "onst", 4) == 0
+             && (i + 5 >= len || !is_ident_char(t[i + 5]))
+             && !is_ident_char(t[i-1])
+             ) {
+            constbuf = QByteArray(t, len);
+            if (is_space(t[i-1]))
+                constbuf.remove(i-1, 6);
+            else
+                constbuf.remove(i, 5);
+            constbuf.prepend("const ");
+            t = constbuf.data();
+            e = constbuf.data() + constbuf.length();
+            break;
+        }
+        /*
+          We musn't convert 'char * const *' into 'const char **'
+          and we must beware of 'Bar<const Bla>'.
+        */
+        if (t[i] == '&' || t[i] == '*' ||t[i] == '<')
+            break;
+    }
+    if (adjustConst && e > t + 6 && strncmp("const ", t, 6) == 0) {
+        if (*(e-1) == '&') { // treat const reference as value
+            t += 6;
+            --e;
+        } else if (is_ident_char(*(e-1)) || *(e-1) == '>') { // treat const value as value
+            t += 6;
+        }
+    }
+    QByteArray result;
+    result.reserve(len);
+
+#if 1
+    // consume initial 'const '
+    if (strncmp("const ", t, 6) == 0) {
+        t+= 6;
+        result += "const ";
+    }
+#endif
+
+    // some type substitutions for 'unsigned x'
+    if (strncmp("unsigned", t, 8) == 0) {
+        // make sure "unsigned" is an isolated word before making substitutions
+        if (!t[8] || !is_ident_char(t[8])) {
+            if (strncmp(" int", t+8, 4) == 0) {
+                t += 8+4;
+                result += "uint";
+            } else if (strncmp(" long", t+8, 5) == 0) {
+                if ((strlen(t + 8 + 5) < 4 || strncmp(t + 8 + 5, " int", 4) != 0) // preserve '[unsigned] long int'
+                    && (strlen(t + 8 + 5) < 5 || strncmp(t + 8 + 5, " long", 5) != 0) // preserve '[unsigned] long long'
+                   ) {
+                    t += 8+5;
+                    result += "ulong";
+                }
+            } else if (strncmp(" short", t+8, 6) != 0  // preserve unsigned short
+                && strncmp(" char", t+8, 5) != 0) {    // preserve unsigned char
+                //  treat rest (unsigned) as uint
+                t += 8;
+                result += "uint";
+            }
+        }
+    } else {
+        // discard 'struct', 'class', and 'enum'; they are optional
+        // and we don't want them in the normalized signature
+        struct {
+            const char *keyword;
+            int len;
+        } optional[] = {
+            { "struct ", 7 },
+            { "class ", 6 },
+            { "enum ", 5 },
+            { 0, 0 }
+        };
+        int i = 0;
+        do {
+            if (strncmp(optional[i].keyword, t, optional[i].len) == 0) {
+                t += optional[i].len;
+                break;
+            }
+        } while (optional[++i].keyword != 0);
+    }
+
+    bool star = false;
+    while (t != e) {
+        char c = *t++;
+        if (fixScope && c == ':' && *t == ':' ) {
+            ++t;
+            c = *t++;
+            int i = result.size() - 1;
+            while (i >= 0 && is_ident_char(result.at(i)))
+                --i;
+            result.resize(i + 1);
+        }
+        star = star || c == '*';
+        result += c;
+        if (c == '<') {
+            //template recursion
+            const char* tt = t;
+            int templdepth = 1;
+            while (t != e) {
+                c = *t++;
+                if (c == '<')
+                    ++templdepth;
+                if (c == '>')
+                    --templdepth;
+                if (templdepth == 0 || (templdepth == 1 && c == ',')) {
+                    result += normalizeTypeInternal(tt, t-1, fixScope, false);
+                    result += c;
+                    if (templdepth == 0) {
+                        if (*t == '>')
+                            result += ' '; // avoid >>
+                        break;
+                    }
+                    tt = t;
+                }
+            }
+        }
+
+        // cv qualifers can appear after the type as well
+        if (!is_ident_char(c) && t != e && (e - t >= 5 && strncmp("const", t, 5) == 0)
+            && (e - t == 5 || !is_ident_char(t[5]))) {
+            t += 5;
+            while (t != e && is_space(*t))
+                ++t;
+            if (adjustConst && t != e && *t == '&') {
+                // treat const ref as value
+                ++t;
+            } else if (adjustConst && !star) {
+                // treat const as value
+            } else if (!star) {
+                // move const to the front (but not if const comes after a *)
+                result.prepend("const ");
+            } else {
+                // keep const after a *
+                result += "const";
+            }
+        }
+    }
+
+    return result;
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qmetaobject_p.h b/src/corelib/kernel/qmetaobject_p.h
index 5da936aab0..919273a605 100644
--- a/src/corelib/kernel/qmetaobject_p.h
+++ b/src/corelib/kernel/qmetaobject_p.h
@@ -167,159 +167,13 @@ static inline bool is_space(char s)
 }
 #endif
 
-// This code is shared with moc.cpp
-static QByteArray normalizeTypeInternal(const char *t, const char *e, bool fixScope = false, bool adjustConst = true)
-{
-    int len = e - t;
-    /*
-      Convert 'char const *' into 'const char *'. Start at index 1,
-      not 0, because 'const char *' is already OK.
-    */
-    QByteArray constbuf;
-    for (int i = 1; i < len; i++) {
-        if ( t[i] == 'c'
-             && strncmp(t + i + 1, "onst", 4) == 0
-             && (i + 5 >= len || !is_ident_char(t[i + 5]))
-             && !is_ident_char(t[i-1])
-             ) {
-            constbuf = QByteArray(t, len);
-            if (is_space(t[i-1]))
-                constbuf.remove(i-1, 6);
-            else
-                constbuf.remove(i, 5);
-            constbuf.prepend("const ");
-            t = constbuf.data();
-            e = constbuf.data() + constbuf.length();
-            break;
-        }
-        /*
-          We musn't convert 'char * const *' into 'const char **'
-          and we must beware of 'Bar<const Bla>'.
-        */
-        if (t[i] == '&' || t[i] == '*' ||t[i] == '<')
-            break;
-    }
-    if (adjustConst && e > t + 6 && strncmp("const ", t, 6) == 0) {
-        if (*(e-1) == '&') { // treat const reference as value
-            t += 6;
-            --e;
-        } else if (is_ident_char(*(e-1)) || *(e-1) == '>') { // treat const value as value
-            t += 6;
-        }
-    }
-    QByteArray result;
-    result.reserve(len);
-
-#if 1
-    // consume initial 'const '
-    if (strncmp("const ", t, 6) == 0) {
-        t+= 6;
-        result += "const ";
-    }
-#endif
-
-    // some type substitutions for 'unsigned x'
-    if (strncmp("unsigned", t, 8) == 0) {
-        // make sure "unsigned" is an isolated word before making substitutions
-        if (!t[8] || !is_ident_char(t[8])) {
-            if (strncmp(" int", t+8, 4) == 0) {
-                t += 8+4;
-                result += "uint";
-            } else if (strncmp(" long", t+8, 5) == 0) {
-                if ((strlen(t + 8 + 5) < 4 || strncmp(t + 8 + 5, " int", 4) != 0) // preserve '[unsigned] long int'
-                    && (strlen(t + 8 + 5) < 5 || strncmp(t + 8 + 5, " long", 5) != 0) // preserve '[unsigned] long long'
-                   ) {
-                    t += 8+5;
-                    result += "ulong";
-                }
-            } else if (strncmp(" short", t+8, 6) != 0  // preserve unsigned short
-                && strncmp(" char", t+8, 5) != 0) {    // preserve unsigned char
-                //  treat rest (unsigned) as uint
-                t += 8;
-                result += "uint";
-            }
-        }
-    } else {
-        // discard 'struct', 'class', and 'enum'; they are optional
-        // and we don't want them in the normalized signature
-        struct {
-            const char *keyword;
-            int len;
-        } optional[] = {
-            { "struct ", 7 },
-            { "class ", 6 },
-            { "enum ", 5 },
-            { 0, 0 }
-        };
-        int i = 0;
-        do {
-            if (strncmp(optional[i].keyword, t, optional[i].len) == 0) {
-                t += optional[i].len;
-                break;
-            }
-        } while (optional[++i].keyword != 0);
-    }
-
-    bool star = false;
-    while (t != e) {
-        char c = *t++;
-        if (fixScope && c == ':' && *t == ':' ) {
-            ++t;
-            c = *t++;
-            int i = result.size() - 1;
-            while (i >= 0 && is_ident_char(result.at(i)))
-                --i;
-            result.resize(i + 1);
-        }
-        star = star || c == '*';
-        result += c;
-        if (c == '<') {
-            //template recursion
-            const char* tt = t;
-            int templdepth = 1;
-            while (t != e) {
-                c = *t++;
-                if (c == '<')
-                    ++templdepth;
-                if (c == '>')
-                    --templdepth;
-                if (templdepth == 0 || (templdepth == 1 && c == ',')) {
-                    result += normalizeTypeInternal(tt, t-1, fixScope, false);
-                    result += c;
-                    if (templdepth == 0) {
-                        if (*t == '>')
-                            result += ' '; // avoid >>
-                        break;
-                    }
-                    tt = t;
-                }
-            }
-        }
-
-        // cv qualifers can appear after the type as well
-        if (!is_ident_char(c) && t != e && (e - t >= 5 && strncmp("const", t, 5) == 0)
-            && (e - t == 5 || !is_ident_char(t[5]))) {
-            t += 5;
-            while (t != e && is_space(*t))
-                ++t;
-            if (adjustConst && t != e && *t == '&') {
-                // treat const ref as value
-                ++t;
-            } else if (adjustConst && !star) {
-                // treat const as value
-            } else if (!star) {
-                // move const to the front (but not if const comes after a *)
-                result.prepend("const ");
-            } else {
-                // keep const after a *
-                result += "const";
-            }
-        }
-    }
-
-    return result;
-}
+/*
+    This function is shared with moc.cpp. The implementation lives in qmetaobject_moc_p.h, which
+    should be included where needed. The declaration here is not used to avoid warnings from
+    the compiler about unused functions.
 
+static QByteArray normalizeTypeInternal(const char *t, const char *e, bool fixScope = false, bool adjustConst = true);
+*/
 
 QT_END_NAMESPACE