set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1")

set(QT_EXTRA_INTERNAL_TARGET_DEFINES "QT_NO_AS_CONST=1")

list(APPEND optional_components AxContainer)

endif()

find_package(Qt6 ${PROJECT_VERSION} QUIET CONFIG OPTIONAL_COMPONENTS

Sql PrintSupport OpenGL OpenGLWidgets ${optional_components})

qt_internal_project_setup()

find_package(Clang CONFIG)

if(__qt_wrap_clang_backup_prefix)

set(CMAKE_PREFIX_PATH "${__qt_wrap_clang_backup_prefix}")

unset(__qt_wrap_clang_backup_prefix)

qt_feature("assistant" PRIVATE

LABEL "Qt Assistant"

PURPOSE "Qt Assistant is a tool for viewing on-line documentation in Qt help file format."

)

qt_feature("clang" PRIVATE

LABEL "QDoc"

qt_feature("designer" PRIVATE

LABEL "Qt Designer"

PURPOSE "Qt Designer is the Qt tool for designing and building graphical user interfaces (GUIs) with Qt Widgets. You can compose and customize your windows or dialogs in a what-you-see-is-what-you-get (WYSIWYG) manner, and test them using different styles and resolutions."

)

qt_feature("distancefieldgenerator" PRIVATE

LABEL "Qt Distance Field Generator"

qt_feature("linguist" PRIVATE

LABEL "Qt Linguist"

PURPOSE "Qt Linguist can be used by translator to translate text in Qt applications."

)

qt_feature("pixeltool" PRIVATE

LABEL "pixeltool"

You will need to set the FEATURE_clangcpp CMake variable to ON to re-evaluate this check."

CONDITION NOT QT_FEATURE_clangcpp

)

dependencies:

../tqtc-qtactiveqt:

required: false

../tqtc-qtbase:

required: true

../tqtc-qtdeclarative:

required: false

../../../shared/qtpropertybrowser

)

if(NOT QT_BUILD_SHARED_LIBS)

# Resources:

set(qtpropertybrowser_resource_files

installed Qt, you can start \QL in the same way as any other application on

the development host.

To address issues that arise from the subtleties and complexities of

human language, translators and developers may need to:

}

static QStringList getSources(const ProFileEvaluator &visitor, const QString &projectDir,

{

QStringList baseVPaths;

baseVPaths += visitor.absolutePathValues(QLatin1String("VPATH"), projectDir);

sourceFiles.removeDuplicates();

sourceFiles.sort();

return sourceFiles;

}

if (!subResults.isEmpty())

setValue(result, "subProjects", subResults);

} else {

setValue(result, "includePaths",

visitor.absolutePathValues(QLatin1String("INCLUDEPATH"), proPath));

setValue(result, "sources", sourceFiles);

}

return result;

#include <translator.h>

#include <QtCore/QBitArray>

#include <QtCore/QTextStream>

#include <QtCore/QRegularExpression>

QBitArray m_ba;

};

class CppParser : private CppParserState {

public:

Functions for processing include files.

*/

IncludeCycleHash &CppFiles::includeCycles()

{

static IncludeCycleHash cycles;

return blacklisted;

}

{

if (cycle)

return cycle->results;

return QSet<const ParseResults *>();

}

{

if (!cycle) {

cycle = new IncludeCycle;

}

cycle->results.insert(results);

}

blacklistedFiles().insert(cleanFile);

}

{

IncludeCycle * const cycle = new IncludeCycle;

cycle->fileNames = fileNames;

QSet<IncludeCycle *> intersectingCycles;

for (const QString &fileName : fileNames) {

if (intersectingCycle && !intersectingCycles.contains(intersectingCycle)) {

intersectingCycles.insert(intersectingCycle);

qDeleteAll(intersectingCycles);

for (const QString &fileName : std::as_const(cycle->fileNames))

}

static bool isHeader(const QString &name)

{

QString cleanFile = QDir::cleanPath(file);

if (rx.match(cleanFile).hasMatch())

return;

}

const int index = includeStack.indexOf(cleanFile);

if (index != -1) {

return;

}

// or is not a header file (stdc++ extensionless or *.h*), then really include

// it. Otherwise it is safe to process it stand-alone and re-use the parsed

// namespace data for inclusion into other files.

bool isIndirect = false;

&& isHeader(cleanFile)) {

if (!res.isEmpty()) {

results->includes.unite(res);

return;

results->fileId = nextFileId++;

pr = results;

}

return pr;

} else {

delete results;

QStringConverter::Encoding e = cd.m_sourceIsUtf16 ? QStringConverter::Utf16 : QStringConverter::Utf8;

for (const QString &filename : filenames) {

continue;

QFile file(filename);

#include "lupdate.h"

#include <QtCore/QSet>

#include <iostream>

QSet<const ParseResults *> results;

};

typedef QHash<QString, const Translator *> TranslatorHash;

class CppFiles {

public:

static const Translator *getTranslator(const QString &cleanFile);

static void setTranslator(const QString &cleanFile, const Translator *results);

static bool isBlacklisted(const QString &cleanFile);

static void setBlacklisted(const QString &cleanFile);

private:

static IncludeCycleHash &includeCycles();

{

FileSignificanceCheck::create();

auto cleanup = qScopeGuard(FileSignificanceCheck::destroy);

if (cd.m_rootDirs.size() > 0)

FileSignificanceCheck::the()->setRootDirectories(cd.m_rootDirs);

else

#include "filesignificancecheck.h"

QT_BEGIN_NAMESPACE

FileSignificanceCheck *FileSignificanceCheck::m_instance = nullptr;

m_rootDirs[i].setPath(paths.at(i));

}

{

}

/*

bool FileSignificanceCheck::isFileSignificant(const std::string &filePath) const

{

// cache lookup

// cache miss

QString file = QString::fromUtf8(filePath);

QString cleanFile = QDir::cleanPath(file);

for (const QRegularExpression &rx : m_exclusionRegExes) {

#define FILESIGNIFICANCECHECK_H

#include <QtCore/qdir.h>

#include <QtCore/qregularexpression.h>

#include <QtCore/qstringlist.h>

#include <string>

#include <unordered_map>

#include <vector>

}

void setRootDirectories(const QStringList &paths);

bool isFileSignificant(const std::string &filePath) const;

private:

static FileSignificanceCheck *m_instance;

std::vector<QDir> m_rootDirs;

mutable std::unordered_map<std::string, bool> m_cache;

};

namespace LupdatePrivate {

#include <QtCore/QFile>

#include <QtCore/QFileInfo>

#include <QtCore/QLibraryInfo>

#include <QtCore/QString>

#include <QtCore/QStringList>

#include <QtCore/QTranslator>

return true;

}

static QStringList getResources(const QString &resourceFile)

{

if (!QFile::exists(resourceFile))

.arg(projectDescriptionFile));

return 1;

}

for (Project &project : projectDescription)

expandQrcFiles(project);

}

#include "lupdate.h"

#include <QtCore/qhash.h>

#include <QtCore/qstring.h>

#include <QtCore/qtextstream.h>

#include <QtCore/qstack.h>

static int yyLineNo;

static int yyCurLineNo;

QHash<QByteArray, Token> tokens = {

{"None", Tok_None},

case '#':

switch (getChar()) {

case ':':

break;

case '=':

break;

case EOF:

return Tok_Eof;

return false;

}

{

}

}

static void parse(Translator &tor, ConversionData &cd,

yyTok = getToken();

break;

case Tok_tr:

utf8 = true;

yyTok = getToken();

if (match(Tok_LeftParen) && matchString(&text)) {

comment.clear();

bool plural = false;

QString::fromUtf8(comment),

{}, yyFileName, yyLineNo,

{}, TranslatorMessage::Unfinished, plural);

tor.extend(message, cd);

}

}

break;

case Tok_translate: {

bool plural{};

if (parseTranslate(&text, &context, &comment, &utf8, &plural)

&& !text.isEmpty()) {

TranslatorMessage message(QString::fromUtf8(context),

QString::fromUtf8(comment),

{}, yyFileName, yyLineNo,

{}, TranslatorMessage::Unfinished, plural);

tor.extend(message, cd);

}

}

QLocale::Friulian,

QLocale::WesternFrisian,

QLocale::Galician,

QLocale::Georgian,

QLocale::German,

QLocale::Greek,

#include <functional>

using std::placeholders::_1;

class Validator

{

result.filePath = stringValue(obj, QLatin1String("projectFile"));

result.compileCommands = stringValue(obj, QLatin1String("compileCommands"));

result.codec = stringValue(obj, QLatin1String("codec"));

result.includePaths = stringListValue(obj, QLatin1String("includePaths"));

result.sources = stringListValue(obj, QLatin1String("sources"));

if (obj.contains(QLatin1String("translations")))

return QStringLiteral("unknown");

}

QString stringValue(const QJsonObject &obj, const QString &key)

{

if (!m_errorString.isEmpty())

#ifndef PROJECTDESCRIPTIONREADER_H

#define PROJECTDESCRIPTIONREADER_H

#include <QtCore/qstring.h>

#include <QtCore/qstringlist.h>

#include <optional>

#include <vector>

QString filePath;

QString compileCommands;

QString codec;

QStringList includePaths;

QStringList sources;

Projects subProjects;

#include <QtCore/QFile>

#include <QtCore/QFileInfo>

#include <QtCore/QLocale>

#include <QtCore/QTextStream>

#include <private/qtranslator_p.h>

{

QLocale::Language language = QLocale::AnyLanguage;

QLocale::Territory territory = QLocale::AnyTerritory;

} else {

language = QLocale::codeToLanguage(languageCode);

territory = QLocale(language).territory();

#include <QList>

#include <QLocale>

#include <QMultiHash>

#include <QString>

#include <QSet>

QT_BEGIN_NAMESPACE

QString m_sourceFileName;

QString m_targetFileName;

QString m_compilationDatabaseDir;

QDir m_sourceDir;

QDir m_targetDir; // FIXME: TS specific

QSet<QString> m_projectRoots;

The \\qmltype command is for documenting a QML type. The command

has one argument, which is the name of the QML type.

\badcode *

/\1!

\1/

\endcode

always include a \l {since-command} {\\since} command, because all

QML types are new. It should also include a \l{brief-command}

{\\brief} description. If a QML type is a member of a QML type group,

\target instantiates-command

\section1 \\instantiates

\badcode *

/\1!

\endcode

Here, the \e{\\qmltype} comment includes \l{instantiates-command}

\target typealias-command

\section1 \\typealias

obj.insert(u"Version"_s, package.version);

obj.insert(u"DownloadLocation"_s, package.downloadLocation);

obj.insert(u"License"_s, package.license);

obj.insert(u"LicenseId"_s, package.licenseId);

if (package.licenseFiles.isEmpty())

QString copyrightFile; // Path to file containing copyright owners. Optional.

QString copyrightFileContents;

QString packageComment; // Further comments about the package. Optional.

};

&& package.licenseId != "NONE"_L1) {

out << "\\l{https://spdx.org/licenses/" << package.licenseId << ".html}"

<< "{" << package.license << "}.\n\n";

} else {

out << package.license << ".\n\n";

}

return success;

}

// Transforms a JSON object into a Package object

static std::optional<Package> readPackage(const QJsonObject &object, const QString &filePath,

Checks checks, LogLevel logLevel)

if (!iter.value().isString() && key != "QtParts"_L1 && key != "SecurityCritical"_L1

&& key != "Files"_L1 && key != "LicenseFiles"_L1 && key != "Comment"_L1

if (logLevel != SilentLog)

std::cerr << qPrintable(tr("File %1: Expected JSON string as value of %2.").arg(

QDir::toNativeSeparators(filePath), key)) << std::endl;

p.copyright = value;

} else {

if (logLevel != SilentLog) {

"string as value of %2.").arg(

QDir::toNativeSeparators(filePath), key)) << std::endl;

validPackage = false;

continue;

}

}

} else if (key == "CopyrightFile"_L1) {

p.copyrightFile = QDir(directory).absoluteFilePath(value);

} else if (key == "PackageComment"_L1) {

msg = self.tr(r"A raw strin\g""continued\\")

msg = self.tr(r"A raw string with escaped quote\"bla")

if __name__ == '__main__':

app = QApplication(sys.argv)

<translation type="unfinished"></translation>

</message>

<message>

<source>A raw string with escaped quote&quot;bla</source>

<translation type="unfinished"></translation>

</message>

</context>

</TS>

#include <QtCore/QDebug>

#include <QtCore/QDir>

#include <QtCore/QFile>

#include <QtCore/private/qconfig_p.h>

#include <QtCore/QSet>

using namespace Qt::Literals::StringLiterals;

class tst_lupdate : public QObject

{

Q_OBJECT

tst_lupdate();

private slots:

void good_data();

void good();

#if CHECK_SIMTEXTH

private:

QString m_cmdLupdate;

QString m_basePath;

void doCompare(QStringList actual, const QString &expectedFn, bool err);

void doCompare(const QString &actualFn, const QString &expectedFn, bool err);

tst_lupdate::tst_lupdate()

{

QString binPath = QLibraryInfo::path(QLibraryInfo::BinariesPath);

m_cmdLupdate = binPath + QLatin1String("/lupdate");

m_basePath = QFINDTESTDATA("testdata/");

}

static bool prepareMatch(const QString &expect, QString *tmpl, int *require, int *accept)

{

if (expect.startsWith(QLatin1Char('\\'))) {

#endif

}

void tst_lupdate::good()

{

QFETCH(QString, directory);

QProcess proc;

proc.setWorkingDirectory(workDir);

proc.setProcessChannelMode(QProcess::MergedChannels);

proc.start(m_cmdLupdate, lupdateArguments, QIODevice::ReadWrite | QIODevice::Text);

// If the file expectedoutput.txt exists, compare the

// console output with the content of that file

QFile outfile(dir + "/expectedoutput.txt");

if (outfile.exists()) {

doCompare(errslist, outfile.fileName(), true);

if (QTest::currentTestFailed())

return;

Usage",

"Homepage": "www.qt.io",

"Version": "1.0",

"DownloadLocation": "www.qt.io/1.0",

"SecurityCritical": true,

"LicenseId": "xxx",

[

{

"Copyright": "",

"CopyrightFile": "",

"Description": "Hello world!\nLine 2",

"LicenseFile": "",

"LicenseId": "",

"Name": "Test",

"PackageComment": "",

"Path": "%{PWD}/chromium",

"QDocModule": "qtwebengine",

"Version": ""

},

{

"Copyright": "Copyright",

"CopyrightFile": "",

"Description": "Multi\nLine\nDescription",

"LicenseFile": "%{PWD}/complete/../../../../../../LICENSES/BSD-3-Clause.txt",

"LicenseId": "xxx",

"Name": "Complete",

"PackageComment": "just a test package",

"Path": "%{PWD}/complete",

"QDocModule": "qtest",

"Version": "1.0"

},

{

"Copyright": "Copyright",

"CopyrightFile": "",

"Description": "",

"LicenseFile": "%{LICENSES_DIR}/BSD-3-Clause.txt",

"LicenseId": "BSD-3-Clause",

"Name": "LicensesDir",

"PackageComment": "",

"Path": "%{PWD}/licenses-dir",

"QDocModule": "qtest",

"Version": ""

},

{

"Copyright": "Copyright",

"CopyrightFile": "",

"Description": "",

"LicenseFile": "",

"LicenseId": "",

"Name": "Minimal",

"PackageComment": "",

"Path": "%{PWD}/minimal",

"QDocModule": "qtest",

"Version": ""

},

{

"Copyright": "",

"CopyrightFile": "%{PWD}/variants/COPYRIGHT.txt",

"Description": "",

],

"LicenseId": "",

"Name": "Variants Test",

"PackageComment": "",

"Path": "%{PWD}/variants",

"QDocModule": "qtest",

[

{

"Copyright": "Copyright",

"CopyrightFile": "",

"Description": "",

"LicenseFile": "%{LICENSES_DIR}/BSD-3-Clause.txt",

"LicenseId": "BSD-3-Clause",

"Name": "LicensesDir",

"PackageComment": "",

"Path": "%{PWD}",

"QDocModule": "qtest",

[

{

"Copyright": "Copyright",

"CopyrightFile": "",

"Description": "",

"LicenseFile": "",

"LicenseId": "",

"Name": "Minimal",

"PackageComment": "",

"Path": "%{PWD}",

"QDocModule": "qtest",

"QDocModule": "qtest",

"QtUsage": "Usage",

"License": "License",

}

[

{

"Copyright": "",

"CopyrightFile": "%{PWD}/COPYRIGHT.txt",

"Description": "",

],

"LicenseId": "",

"Name": "Variants Test",

"PackageComment": "",

"Path": "%{PWD}",

"QDocModule": "qtest",