/**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing/ ** ** This file is part of the QtCore module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL21$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see http://www.qt.io/terms-conditions. For further ** information use the contact form at http://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** As a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** $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 // // W A R N I N G // ------------- // // This file is not part of the Qt API. It exists purely as an // implementation detail. This header file may change from version to // version without notice, or even be removed. // // We mean it. // 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 mustn't convert 'char * const *' into 'const char **' and we must beware of 'Bar'. */ 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; int scopeDepth = 0; while (t != e) { c = *t++; if (c == '{' || c == '(' || c == '[') ++scopeDepth; if (c == '}' || c == ')' || c == ']') --scopeDepth; if (scopeDepth == 0) { 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