1// Copyright (C) 2018 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
3
4#include <profileevaluator.h>
5#include <profileutils.h>
6#include <qmakeparser.h>
7#include <qmakevfs.h>
8#include <qrcreader.h>
9
10#include <QtCore/QCoreApplication>
11#include <QtCore/QDebug>
12#include <QtCore/QDir>
13#include <QtCore/QDirIterator>
14#include <QtCore/QFile>
15#include <QtCore/QFileInfo>
16#include <QtCore/QLibraryInfo>
17#include <QtCore/QRegularExpression>
18#include <QtCore/QString>
19#include <QtCore/QStringList>
20
21#include <QtCore/QJsonArray>
22#include <QtCore/QJsonDocument>
23#include <QtCore/QJsonObject>
24
25#include <iostream>
26
27using namespace Qt::StringLiterals;
28
29static void printOut(const QString &out)
30{
31 std::cout << qPrintable(out);
32}
33
34static void printErr(const QString &out)
35{
36 std::cerr << qPrintable(out);
37}
38
39static QJsonValue toJsonValue(const QJsonValue &v)
40{
41 return v;
42}
43
44static QJsonValue toJsonValue(const QString &s)
45{
46 return QJsonValue(s);
47}
48
49static QJsonValue toJsonValue(const QStringList &lst)
50{
51 return QJsonArray::fromStringList(list: lst);
52}
53
54template <class T>
55void setValue(QJsonObject &obj, const char *key, T value)
56{
57 obj[QLatin1String(key)] = toJsonValue(value);
58}
59
60static void printUsage()
61{
62 printOut(out: uR"(Usage:
63 lprodump [options] project-file...
64lprodump is part of Qt's Linguist tool chain. It extracts information
65from qmake projects to a .json file. This file can be passed to
66lupdate/lrelease using the -project option.
67
68Options:
69 -help Display this information and exit.
70 -silent
71 Do not explain what is being done.
72 -pro <filename>
73 Name of a .pro file. Useful for files with .pro file syntax but
74 different file suffix. Projects are recursed into and merged.
75 -pro-out <directory>
76 Virtual output directory for processing subsequent .pro files.
77 -pro-debug
78 Trace processing .pro files. Specify twice for more verbosity.
79 -out <filename>
80 Name of the output file.
81 -translations-variables <variable_1>[,<variable_2>,...]
82 Comma-separated list of QMake variables containing .ts files.
83 -version
84 Display the version of lprodump and exit.
85)"_s);
86}
87
88static void print(const QString &fileName, int lineNo, const QString &msg)
89{
90 if (lineNo > 0)
91 printErr(out: QString::fromLatin1(ba: "WARNING: %1:%2: %3\n").arg(args: fileName, args: QString::number(lineNo), args: msg));
92 else if (lineNo)
93 printErr(out: QString::fromLatin1(ba: "WARNING: %1: %2\n").arg(args: fileName, args: msg));
94 else
95 printErr(out: QString::fromLatin1(ba: "WARNING: %1\n").arg(a: msg));
96}
97
98class EvalHandler : public QMakeHandler {
99public:
100 void message(int type, const QString &msg, const QString &fileName, int lineNo) override
101 {
102 if (verbose && !(type & CumulativeEvalMessage) && (type & CategoryMask) == ErrorMessage)
103 print(fileName, lineNo, msg);
104 }
105
106 void fileMessage(int type, const QString &msg) override
107 {
108 if (verbose && !(type & CumulativeEvalMessage) && (type & CategoryMask) == ErrorMessage) {
109 // "Downgrade" errors, as we don't really care for them
110 printErr(out: "WARNING: "_L1 + msg + u'\n');
111 }
112 }
113
114 void aboutToEval(ProFile *, ProFile *, EvalFileType) override {}
115 void doneWithEval(ProFile *) override {}
116
117 bool verbose = true;
118};
119
120static EvalHandler evalHandler;
121
122static QStringList getResources(const QString &resourceFile, QMakeVfs *vfs)
123{
124 Q_ASSERT(vfs);
125 if (!vfs->exists(fn: resourceFile, flags: QMakeVfs::VfsCumulative))
126 return QStringList();
127 QString content;
128 QString errStr;
129 if (vfs->readFile(id: vfs->idForFileName(fn: resourceFile, flags: QMakeVfs::VfsCumulative),
130 contents: &content, errStr: &errStr) != QMakeVfs::ReadOk) {
131 printErr(QStringLiteral("lprodump error: Cannot read %1: %2\n").arg(args: resourceFile, args&: errStr));
132 return QStringList();
133 }
134 const ReadQrcResult rqr = readQrcFile(resourceFile, content);
135 if (rqr.hasError()) {
136 printErr(QStringLiteral("lprodump error: %1:%2: %3\n")
137 .arg(args: resourceFile, args: QString::number(rqr.line), args: rqr.errorString));
138 }
139 return rqr.files;
140}
141
142static QStringList getSources(const char *var, const char *vvar, const QStringList &baseVPaths,
143 const QString &projectDir, const ProFileEvaluator &visitor)
144{
145 QStringList vPaths = visitor.absolutePathValues(variable: QLatin1String(vvar), baseDirectory: projectDir);
146 vPaths += baseVPaths;
147 vPaths.removeDuplicates();
148 return visitor.absoluteFileValues(variable: QLatin1String(var), baseDirectory: projectDir, searchDirs: vPaths, pro: 0);
149}
150
151static QStringList getSources(const ProFileEvaluator &visitor, const QString &projectDir,
152 QMakeVfs *vfs)
153{
154 QStringList baseVPaths;
155 baseVPaths += visitor.absolutePathValues(variable: "VPATH"_L1, baseDirectory: projectDir);
156 baseVPaths << projectDir; // QMAKE_ABSOLUTE_SOURCE_PATH
157 baseVPaths.removeDuplicates();
158
159 QStringList sourceFiles;
160
161 // app/lib template
162 sourceFiles += getSources(var: "SOURCES", vvar: "VPATH_SOURCES", baseVPaths, projectDir, visitor);
163 sourceFiles += getSources(var: "HEADERS", vvar: "VPATH_HEADERS", baseVPaths, projectDir, visitor);
164
165 sourceFiles += getSources(var: "FORMS", vvar: "VPATH_FORMS", baseVPaths, projectDir, visitor);
166
167 const QStringList resourceFiles = getSources(var: "RESOURCES", vvar: "VPATH_RESOURCES", baseVPaths, projectDir, visitor);
168 for (const QString &resource : resourceFiles)
169 sourceFiles += getResources(resourceFile: resource, vfs);
170
171 QStringList installs = visitor.values(variableName: "INSTALLS"_L1) + visitor.values(variableName: "DEPLOYMENT"_L1);
172 installs.removeDuplicates();
173 QDir baseDir(projectDir);
174 for (const QString &inst : std::as_const(t&: installs)) {
175 for (const QString &file : visitor.values(variableName: inst + ".files"_L1)) {
176 QFileInfo info(file);
177 if (!info.isAbsolute())
178 info.setFile(baseDir.absoluteFilePath(fileName: file));
179 QStringList nameFilter;
180 QString searchPath;
181 if (info.isDir()) {
182 nameFilter << "*"_L1;
183 searchPath = info.filePath();
184 } else {
185 nameFilter << info.fileName();
186 searchPath = info.path();
187 }
188
189 QDirIterator iterator(searchPath, nameFilter,
190 QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks,
191 QDirIterator::Subdirectories);
192 while (iterator.hasNext()) {
193 iterator.next();
194 QFileInfo cfi = iterator.fileInfo();
195 if (isSupportedExtension(ext: cfi.suffix()))
196 sourceFiles << cfi.filePath();
197 }
198 }
199 }
200
201 sourceFiles.removeDuplicates();
202 sourceFiles.sort();
203 return sourceFiles;
204}
205
206QStringList getExcludes(const ProFileEvaluator &visitor, const QString &projectDirPath)
207{
208 const QStringList trExcludes = visitor.values(variableName: "TR_EXCLUDE"_L1);
209 QStringList excludes;
210 excludes.reserve(asize: trExcludes.size());
211 const QDir projectDir(projectDirPath);
212 for (const QString &ex : trExcludes)
213 excludes << QDir::cleanPath(path: projectDir.absoluteFilePath(fileName: ex));
214 return excludes;
215}
216
217static void excludeProjects(const ProFileEvaluator &visitor, QStringList *subProjects)
218{
219 for (const QString &ex : visitor.values(variableName: "TR_EXCLUDE"_L1)) {
220 QRegularExpression rx(QRegularExpression::wildcardToRegularExpression(str: ex));
221 for (auto it = subProjects->begin(); it != subProjects->end(); ) {
222 if (rx.match(subject: *it).hasMatch())
223 it = subProjects->erase(pos: it);
224 else
225 ++it;
226 }
227 }
228}
229
230static QJsonArray processProjects(bool topLevel, const QStringList &proFiles,
231 const QStringList &translationsVariables,
232 const QHash<QString, QString> &outDirMap,
233 ProFileGlobals *option, QMakeVfs *vfs, QMakeParser *parser,
234 bool *fail);
235
236static QJsonObject processProject(const QString &proFile, const QStringList &translationsVariables,
237 ProFileGlobals *option, QMakeVfs *vfs,
238 QMakeParser *parser, ProFileEvaluator &visitor)
239{
240 QJsonObject result;
241 QStringList tmp = visitor.values(variableName: "CODECFORSRC"_L1);
242 if (!tmp.isEmpty())
243 result[QStringLiteral("codec")] = tmp.last();
244 QString proPath = QFileInfo(proFile).path();
245 if (visitor.templateType() == ProFileEvaluator::TT_Subdirs) {
246 QStringList subProjects = visitor.values(variableName: "SUBDIRS"_L1);
247 excludeProjects(visitor, subProjects: &subProjects);
248 QStringList subProFiles;
249 QDir proDir(proPath);
250 for (const QString &subdir : std::as_const(t&: subProjects)) {
251 QString realdir = visitor.value(variableName: subdir + ".subdir"_L1);
252 if (realdir.isEmpty())
253 realdir = visitor.value(variableName: subdir + ".file"_L1);
254 if (realdir.isEmpty())
255 realdir = subdir;
256 QString subPro = QDir::cleanPath(path: proDir.absoluteFilePath(fileName: realdir));
257 QFileInfo subInfo(subPro);
258 if (subInfo.isDir()) {
259 subProFiles << (subPro + u'/' + subInfo.fileName() + ".pro"_L1);
260 } else {
261 subProFiles << subPro;
262 }
263 }
264 QJsonArray subResults = processProjects(topLevel: false, proFiles: subProFiles, translationsVariables,
265 outDirMap: QHash<QString, QString>(), option, vfs, parser,
266 fail: nullptr);
267 if (!subResults.isEmpty())
268 setValue(obj&: result, key: "subProjects", value: subResults);
269 } else {
270 const QStringList sourceFiles = getSources(visitor, projectDir: proPath, vfs);
271 setValue(obj&: result, key: "includePaths", value: visitor.absolutePathValues(variable: "INCLUDEPATH"_L1, baseDirectory: proPath));
272 setValue(obj&: result, key: "excluded", value: getExcludes(visitor, projectDirPath: proPath));
273 setValue(obj&: result, key: "sources", value: sourceFiles);
274 }
275 return result;
276}
277
278static QJsonArray processProjects(bool topLevel, const QStringList &proFiles,
279 const QStringList &translationsVariables,
280 const QHash<QString, QString> &outDirMap,
281 ProFileGlobals *option, QMakeVfs *vfs, QMakeParser *parser, bool *fail)
282{
283 QJsonArray result;
284 for (const QString &proFile : proFiles) {
285 if (!outDirMap.isEmpty())
286 option->setDirectories(input_dir: QFileInfo(proFile).path(), output_dir: outDirMap[proFile]);
287
288 ProFile *pro;
289 if (!(pro = parser->parsedProFile(fileName: proFile, flags: topLevel ? QMakeParser::ParseReportMissing
290 : QMakeParser::ParseDefault))) {
291 if (topLevel)
292 *fail = true;
293 continue;
294 }
295 ProFileEvaluator visitor(option, parser, vfs, &evalHandler);
296 visitor.setCumulative(true);
297 visitor.setOutputDir(option->shadowedPath(fileName: pro->directoryName()));
298 if (!visitor.accept(pro)) {
299 if (topLevel)
300 *fail = true;
301 pro->deref();
302 continue;
303 }
304
305 QJsonObject prj = processProject(proFile, translationsVariables, option, vfs, parser,
306 visitor);
307 setValue(obj&: prj, key: "projectFile", value: proFile);
308 QStringList tsFiles;
309 for (const QString &varName : translationsVariables) {
310 if (!visitor.contains(variableName: varName))
311 continue;
312 QDir proDir(QFileInfo(proFile).path());
313 const QStringList translations = visitor.values(variableName: varName);
314 for (const QString &tsFile : translations)
315 tsFiles << proDir.filePath(fileName: tsFile);
316 }
317 if (!tsFiles.isEmpty())
318 setValue(obj&: prj, key: "translations", value: tsFiles);
319 if (visitor.contains(variableName: "LUPDATE_COMPILE_COMMANDS_PATH"_L1)) {
320 const QStringList thepathjson = visitor.values(variableName: "LUPDATE_COMPILE_COMMANDS_PATH"_L1);
321 setValue(obj&: prj, key: "compileCommands", value: thepathjson.value(i: 0));
322 }
323 result.append(value: prj);
324 pro->deref();
325 }
326 return result;
327}
328
329int main(int argc, char **argv)
330{
331 QCoreApplication app(argc, argv);
332 QStringList args = app.arguments();
333 QStringList proFiles;
334 QStringList translationsVariables = { u"TRANSLATIONS"_s };
335 QString outDir = QDir::currentPath();
336 QHash<QString, QString> outDirMap;
337 QString outputFilePath;
338 int proDebug = 0;
339
340 for (int i = 1; i < args.size(); ++i) {
341 QString arg = args.at(i);
342 if (arg == "-help"_L1 || arg == "--help"_L1 || arg == "-h"_L1) {
343 printUsage();
344 return 0;
345 } else if (arg == "-out"_L1) {
346 ++i;
347 if (i == argc) {
348 printErr(out: u"The option -out requires a parameter.\n"_s);
349 return 1;
350 }
351 outputFilePath = args[i];
352 } else if (arg == "-silent"_L1) {
353 evalHandler.verbose = false;
354 } else if (arg == "-pro-debug"_L1) {
355 proDebug++;
356 } else if (arg == "-version"_L1) {
357 printOut(QStringLiteral("lprodump version %1\n").arg(a: QLatin1String(QT_VERSION_STR)));
358 return 0;
359 } else if (arg == "-pro"_L1) {
360 ++i;
361 if (i == argc) {
362 printErr(QStringLiteral("The -pro option should be followed by a filename of .pro file.\n"));
363 return 1;
364 }
365 QString file = QDir::cleanPath(path: QFileInfo(args[i]).absoluteFilePath());
366 proFiles += file;
367 outDirMap[file] = outDir;
368 } else if (arg == "-pro-out"_L1) {
369 ++i;
370 if (i == argc) {
371 printErr(QStringLiteral("The -pro-out option should be followed by a directory name.\n"));
372 return 1;
373 }
374 outDir = QDir::cleanPath(path: QFileInfo(args[i]).absoluteFilePath());
375 } else if (arg == u"-translations-variables"_s) {
376 ++i;
377 if (i == argc) {
378 printErr(out: u"The -translations-variables option must be followed by a "_s
379 u"comma-separated list of variable names.\n"_s);
380 return 1;
381 }
382 translationsVariables = args.at(i).split(sep: u',');
383 } else if (arg.startsWith(s: "-"_L1) && arg != "-"_L1) {
384 printErr(QStringLiteral("Unrecognized option '%1'.\n").arg(a: arg));
385 return 1;
386 } else {
387 QFileInfo fi(arg);
388 if (!fi.exists()) {
389 printErr(QStringLiteral("lprodump error: File '%1' does not exist.\n").arg(a: arg));
390 return 1;
391 }
392 if (!isProOrPriFile(filePath: arg)) {
393 printErr(QStringLiteral("lprodump error: '%1' is neither a .pro nor a .pri file.\n")
394 .arg(a: arg));
395 return 1;
396 }
397 QString cleanFile = QDir::cleanPath(path: fi.absoluteFilePath());
398 proFiles << cleanFile;
399 outDirMap[cleanFile] = outDir;
400 }
401 } // for args
402
403 if (proFiles.isEmpty()) {
404 printUsage();
405 return 1;
406 }
407
408 bool fail = false;
409 ProFileGlobals option;
410 option.qmake_abslocation = QString::fromLocal8Bit(ba: qgetenv(varName: "QMAKE"));
411 if (option.qmake_abslocation.isEmpty()) {
412 option.qmake_abslocation = QLibraryInfo::path(p: QLibraryInfo::BinariesPath) + "/qmake"_L1;
413 }
414 option.debugLevel = proDebug;
415 option.initProperties();
416 option.setCommandLineArguments(pwd: QDir::currentPath(), args: { "CONFIG+=lupdate_run"_L1 });
417 QMakeVfs vfs;
418 QMakeParser parser(0, &vfs, &evalHandler);
419
420 QJsonArray results = processProjects(topLevel: true, proFiles, translationsVariables, outDirMap, option: &option,
421 vfs: &vfs, parser: &parser, fail: &fail);
422 if (fail)
423 return 1;
424
425 const QByteArray output = QJsonDocument(results).toJson(format: QJsonDocument::Compact);
426 if (outputFilePath.isEmpty()) {
427 puts(s: output.constData());
428 } else {
429 QFile f(outputFilePath);
430 if (!f.open(flags: QIODevice::WriteOnly)) {
431 printErr(QStringLiteral("lprodump error: Cannot open %1 for writing.\n").arg(a: outputFilePath));
432 return 1;
433 }
434 f.write(data: output);
435 f.write(data: "\n");
436 }
437 return 0;
438}
439

source code of qttools/src/linguist/lprodump/main.cpp