301 lines
12 KiB
C++
301 lines
12 KiB
C++
/***************************************************************************
|
|
**
|
|
** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the utilities of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** 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 https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "legacyspecparser.h"
|
|
|
|
#include <QDebug>
|
|
#include <QFile>
|
|
#include <QRegExp>
|
|
#include <QStringList>
|
|
#include <QTextStream>
|
|
|
|
#ifdef SPECPARSER_DEBUG
|
|
#define qLegacySpecParserDebug qDebug
|
|
#else
|
|
#define qLegacySpecParserDebug QT_NO_QDEBUG_MACRO
|
|
#endif
|
|
|
|
bool LegacySpecParser::parse()
|
|
{
|
|
// Get the mapping form generic types to specific types suitable for use in C-headers
|
|
if (!parseTypeMap())
|
|
return false;
|
|
|
|
// Open up a stream on the actual OpenGL function spec file
|
|
QFile file(specFileName());
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
qWarning() << "Failed to open spec file:" << specFileName() << "Aborting";
|
|
return false;
|
|
}
|
|
|
|
QTextStream stream(&file);
|
|
|
|
// Extract the info that we need
|
|
parseFunctions(stream);
|
|
return true;
|
|
}
|
|
|
|
bool LegacySpecParser::parseTypeMap()
|
|
{
|
|
QFile file(typeMapFileName());
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
qWarning() << "Failed to open type file:" << typeMapFileName() << "Aborting";
|
|
return false;
|
|
}
|
|
|
|
QTextStream stream(&file);
|
|
|
|
static QRegExp typeMapRegExp("([^,]+)\\W+([^,]+)");
|
|
|
|
while (!stream.atEnd()) {
|
|
QString line = stream.readLine();
|
|
|
|
if (line.startsWith(QLatin1Char('#')))
|
|
continue;
|
|
|
|
if (typeMapRegExp.indexIn(line) != -1) {
|
|
QString key = typeMapRegExp.cap(1).simplified();
|
|
QString value = typeMapRegExp.cap(2).simplified();
|
|
|
|
// Special case for void
|
|
if (value == QLatin1String("*"))
|
|
value = QStringLiteral("void");
|
|
|
|
m_typeMap.insert(key, value);
|
|
qLegacySpecParserDebug() << "Found type mapping from" << key << "=>" << value;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void LegacySpecParser::parseEnums()
|
|
{
|
|
}
|
|
|
|
void LegacySpecParser::parseFunctions(QTextStream &stream)
|
|
{
|
|
static QRegExp functionRegExp("^(\\w+)\\(.*\\)");
|
|
static QRegExp returnRegExp("^\\treturn\\s+(\\S+)");
|
|
static QRegExp argumentRegExp("param\\s+(\\S+)\\s+(\\S+) (\\S+) (\\S+)");
|
|
static QRegExp versionRegExp("^\\tversion\\s+(\\S+)");
|
|
static QRegExp deprecatedRegExp("^\\tdeprecated\\s+(\\S+)");
|
|
static QRegExp categoryRegExp("^\\tcategory\\s+(\\S+)");
|
|
static QRegExp categoryVersionRegExp("VERSION_(\\d)_(\\d)");
|
|
static QRegExp extToCoreVersionRegExp("passthru:\\s/\\*\\sOpenGL\\s(\\d)\\.(\\d)\\s.*\\sextensions:");
|
|
static QRegExp extToCoreRegExp("passthru:\\s/\\*\\s(ARB_\\S*)\\s.*\\*/");
|
|
|
|
Function currentFunction;
|
|
VersionProfile currentVersionProfile;
|
|
QString currentCategory;
|
|
bool haveVersionInfo = false;
|
|
bool acceptCurrentFunctionInCore = false;
|
|
bool acceptCurrentFunctionInExtension = false;
|
|
|
|
QHash<QString, Version> extensionsNowInCore;
|
|
Version extToCoreCurrentVersion;
|
|
int functionCount = 0;
|
|
|
|
QSet<Version> versions;
|
|
|
|
while (!stream.atEnd()) {
|
|
QString line = stream.readLine();
|
|
if (line.startsWith("#"))
|
|
continue;
|
|
|
|
if (functionRegExp.indexIn(line) != -1) {
|
|
|
|
if (!currentFunction.name.isEmpty()) {
|
|
|
|
// NB - Special handling!
|
|
// Versions 4.2 and 4.3 (and probably newer) add functionality by
|
|
// subsuming extensions such as ARB_texture_storage. However, some extensions
|
|
// also include functions to interact with the EXT_direct_state_access
|
|
// extension. These functions should be added to the DSA extension rather
|
|
// than the core functionality. The core will already contain non-DSA
|
|
// versions of these functions.
|
|
if (acceptCurrentFunctionInCore && currentFunction.name.endsWith(QLatin1String("EXT"))) {
|
|
acceptCurrentFunctionInCore = false;
|
|
acceptCurrentFunctionInExtension = true;
|
|
currentCategory = QStringLiteral("EXT_direct_state_access");
|
|
}
|
|
|
|
// Finish off previous function (if any) by inserting it into the core
|
|
// functionality or extension functionality (or both)
|
|
if (acceptCurrentFunctionInCore) {
|
|
m_functions.insert(currentVersionProfile, currentFunction);
|
|
versions.insert(currentVersionProfile.version);
|
|
}
|
|
|
|
if (acceptCurrentFunctionInExtension) {
|
|
FunctionProfile fp;
|
|
fp.profile = currentVersionProfile.profile;
|
|
fp.function = currentFunction;
|
|
m_extensionFunctions.insert(currentCategory, fp);
|
|
}
|
|
}
|
|
|
|
// Start a new function
|
|
++functionCount;
|
|
haveVersionInfo = false;
|
|
acceptCurrentFunctionInCore = true;
|
|
acceptCurrentFunctionInExtension = false;
|
|
currentCategory = QString();
|
|
currentFunction = Function();
|
|
|
|
// We assume a core function unless we find a deprecated flag (see below)
|
|
currentVersionProfile = VersionProfile();
|
|
currentVersionProfile.profile = VersionProfile::CoreProfile;
|
|
|
|
// Extract the function name
|
|
QString functionName = functionRegExp.cap(1);
|
|
currentFunction.name = functionName;
|
|
qLegacySpecParserDebug() << "Found function:" << functionName;
|
|
|
|
} else if (argumentRegExp.indexIn(line) != -1) {
|
|
// Extract info about this function argument
|
|
Argument arg;
|
|
arg.name = argumentRegExp.cap(1);
|
|
|
|
QString type = argumentRegExp.cap(2); // Lookup in type map
|
|
arg.type = m_typeMap.value(type);
|
|
|
|
QString direction = argumentRegExp.cap(3);
|
|
if (direction == QLatin1String("in")) {
|
|
arg.direction = Argument::In;
|
|
} else if (direction == QLatin1String("out")) {
|
|
arg.direction = Argument::Out;
|
|
} else {
|
|
qWarning() << "Invalid argument direction found:" << direction;
|
|
acceptCurrentFunctionInCore = false;
|
|
}
|
|
|
|
QString mode = argumentRegExp.cap(4);
|
|
if (mode == QLatin1String("value")) {
|
|
arg.mode = Argument::Value;
|
|
} else if (mode == QLatin1String("array")) {
|
|
arg.mode = Argument::Array;
|
|
} else if (mode == QLatin1String("reference")) {
|
|
arg.mode = Argument::Reference;
|
|
} else {
|
|
qWarning() << "Invalid argument mode found:" << mode;
|
|
acceptCurrentFunctionInCore = false;
|
|
}
|
|
|
|
qLegacySpecParserDebug() << " argument:" << arg.type << arg.name;
|
|
currentFunction.arguments.append(arg);
|
|
|
|
} else if (returnRegExp.indexIn(line) != -1) {
|
|
// Lookup the return type from the typemap
|
|
QString returnTypeKey = returnRegExp.cap(1).simplified();
|
|
if (!m_typeMap.contains(returnTypeKey)) {
|
|
qWarning() << "Unknown return type found:" << returnTypeKey;
|
|
acceptCurrentFunctionInCore = false;
|
|
}
|
|
QString returnType = m_typeMap.value(returnTypeKey);
|
|
qLegacySpecParserDebug() << " return type:" << returnType;
|
|
currentFunction.returnType = returnType;
|
|
|
|
} else if (versionRegExp.indexIn(line) != -1 && !haveVersionInfo) { // Only use version line if no other source
|
|
// Extract the OpenGL version in which this function was introduced
|
|
QString version = versionRegExp.cap(1);
|
|
qLegacySpecParserDebug() << " version:" << version;
|
|
QStringList parts = version.split(QLatin1Char('.'));
|
|
if (parts.size() != 2) {
|
|
qWarning() << "Found invalid version number";
|
|
continue;
|
|
}
|
|
int majorVersion = parts.first().toInt();
|
|
int minorVersion = parts.last().toInt();
|
|
Version v;
|
|
v.major = majorVersion;
|
|
v.minor = minorVersion;
|
|
currentVersionProfile.version = v;
|
|
|
|
} else if (deprecatedRegExp.indexIn(line) != -1) {
|
|
// Extract the OpenGL version in which this function was deprecated.
|
|
// If it is OpenGL 3.1 then it must be a compatibility profile function
|
|
QString deprecatedVersion = deprecatedRegExp.cap(1).simplified();
|
|
if (deprecatedVersion == QLatin1String("3.1") && !inDeprecationException(currentFunction.name))
|
|
currentVersionProfile.profile = VersionProfile::CompatibilityProfile;
|
|
|
|
} else if (categoryRegExp.indexIn(line) != -1) {
|
|
// Extract the category for this function
|
|
QString category = categoryRegExp.cap(1).simplified();
|
|
qLegacySpecParserDebug() << " category:" << category;
|
|
|
|
if (categoryVersionRegExp.indexIn(category) != -1) {
|
|
// Use the version info in the category in preference to the version
|
|
// entry as this is more applicable and consistent
|
|
int majorVersion = categoryVersionRegExp.cap(1).toInt();
|
|
int minorVersion = categoryVersionRegExp.cap(2).toInt();
|
|
|
|
Version v;
|
|
v.major = majorVersion;
|
|
v.minor = minorVersion;
|
|
currentVersionProfile.version = v;
|
|
haveVersionInfo = true;
|
|
|
|
} else {
|
|
// Make a note of the extension name and tag this function as being part of an extension
|
|
qLegacySpecParserDebug() << "Found category =" << category;
|
|
currentCategory = category;
|
|
acceptCurrentFunctionInExtension = true;
|
|
|
|
// See if this category (extension) is in our set of extensions that
|
|
// have now been folded into the core feature set
|
|
if (extensionsNowInCore.contains(category)) {
|
|
currentVersionProfile.version = extensionsNowInCore.value(category);
|
|
haveVersionInfo = true;
|
|
} else {
|
|
acceptCurrentFunctionInCore = false;
|
|
}
|
|
}
|
|
|
|
} else if (extToCoreVersionRegExp.indexIn(line) != -1) {
|
|
qLegacySpecParserDebug() << line;
|
|
int majorVersion = extToCoreVersionRegExp.cap(1).toInt();
|
|
int minorVersion = extToCoreVersionRegExp.cap(2).toInt();
|
|
extToCoreCurrentVersion.major = majorVersion;
|
|
extToCoreCurrentVersion.minor = minorVersion;
|
|
|
|
} else if (extToCoreRegExp.indexIn(line) != -1) {
|
|
QString extension = extToCoreRegExp.cap(1);
|
|
extensionsNowInCore.insert(extension, extToCoreCurrentVersion);
|
|
}
|
|
}
|
|
|
|
m_versions = versions.toList();
|
|
std::sort(m_versions.begin(), m_versions.end());
|
|
}
|
|
|
|
bool LegacySpecParser::inDeprecationException(const QString &functionName) const
|
|
{
|
|
return functionName == QLatin1String("TexImage3D");
|
|
}
|