1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the Qt Linguist of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
21 | ** included in the packaging of this file. Please review the following |
22 | ** information to ensure the GNU General Public License requirements will |
23 | ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
24 | ** |
25 | ** $QT_END_LICENSE$ |
26 | ** |
27 | ****************************************************************************/ |
28 | |
29 | #include "qmakeevaluator.h" |
30 | |
31 | #include "qmakeevaluator_p.h" |
32 | #include "qmakeglobals.h" |
33 | #include "qmakeparser.h" |
34 | #include "qmakevfs.h" |
35 | #include "ioutils.h" |
36 | |
37 | #include <qbytearray.h> |
38 | #include <qdir.h> |
39 | #include <qfile.h> |
40 | #include <qfileinfo.h> |
41 | #include <qlist.h> |
42 | #include <qregexp.h> |
43 | #include <qset.h> |
44 | #include <qstringlist.h> |
45 | #include <qtextstream.h> |
46 | #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) |
47 | # include <qjsondocument.h> |
48 | # include <qjsonobject.h> |
49 | # include <qjsonarray.h> |
50 | #endif |
51 | #ifdef PROEVALUATOR_THREAD_SAFE |
52 | # include <qthreadpool.h> |
53 | #endif |
54 | #include <qversionnumber.h> |
55 | |
56 | #include <algorithm> |
57 | |
58 | #ifdef Q_OS_UNIX |
59 | #include <time.h> |
60 | #include <errno.h> |
61 | #include <unistd.h> |
62 | #include <signal.h> |
63 | #include <sys/wait.h> |
64 | #include <sys/stat.h> |
65 | #include <sys/utsname.h> |
66 | #else |
67 | #include <windows.h> |
68 | #endif |
69 | #include <stdio.h> |
70 | #include <stdlib.h> |
71 | |
72 | #ifdef Q_OS_WIN32 |
73 | #define QT_POPEN _popen |
74 | #define QT_POPEN_READ "rb" |
75 | #define QT_PCLOSE _pclose |
76 | #else |
77 | #define QT_POPEN popen |
78 | #define QT_POPEN_READ "r" |
79 | #define QT_PCLOSE pclose |
80 | #endif |
81 | |
82 | using namespace QMakeInternal; |
83 | |
84 | QT_BEGIN_NAMESPACE |
85 | |
86 | #define fL1S(s) QString::fromLatin1(s) |
87 | |
88 | enum ExpandFunc { |
89 | E_INVALID = 0, E_MEMBER, E_STR_MEMBER, E_FIRST, E_TAKE_FIRST, E_LAST, E_TAKE_LAST, |
90 | E_SIZE, E_STR_SIZE, E_CAT, E_FROMFILE, E_EVAL, E_LIST, E_SPRINTF, E_FORMAT_NUMBER, |
91 | E_NUM_ADD, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION, |
92 | E_FIND, E_SYSTEM, E_UNIQUE, E_SORTED, E_REVERSE, E_QUOTE, E_ESCAPE_EXPAND, |
93 | E_UPPER, E_LOWER, E_TITLE, E_FILES, E_PROMPT, E_RE_ESCAPE, E_VAL_ESCAPE, |
94 | E_REPLACE, E_SORT_DEPENDS, E_RESOLVE_DEPENDS, E_ENUMERATE_VARS, |
95 | E_SHADOWED, E_ABSOLUTE_PATH, E_RELATIVE_PATH, E_CLEAN_PATH, |
96 | E_SYSTEM_PATH, E_SHELL_PATH, E_SYSTEM_QUOTE, E_SHELL_QUOTE, E_GETENV |
97 | }; |
98 | |
99 | enum TestFunc { |
100 | T_INVALID = 0, T_REQUIRES, T_GREATERTHAN, T_LESSTHAN, T_EQUALS, |
101 | T_VERSION_AT_LEAST, T_VERSION_AT_MOST, |
102 | T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM, |
103 | T_DEFINED, T_DISCARD_FROM, T_CONTAINS, T_INFILE, |
104 | T_COUNT, T_ISEMPTY, T_PARSE_JSON, T_INCLUDE, T_LOAD, T_DEBUG, T_LOG, T_MESSAGE, T_WARNING, T_ERROR, T_IF, |
105 | T_MKPATH, T_WRITE_FILE, T_TOUCH, T_CACHE, T_RELOAD_PROPERTIES |
106 | }; |
107 | |
108 | QMakeBuiltin::QMakeBuiltin(const QMakeBuiltinInit &d) |
109 | : index(d.func), minArgs(qMax(a: 0, b: d.min_args)), maxArgs(d.max_args) |
110 | { |
111 | static const char * const nstr[6] = { "no" , "one" , "two" , "three" , "four" , "five" }; |
112 | // For legacy reasons, there is actually no such thing as "no arguments" |
113 | // - there is only "empty first argument", which needs to be mapped back. |
114 | // -1 means "one, which may be empty", which is effectively zero, except |
115 | // for the error message if there are too many arguments. |
116 | int dmin = qAbs(t: d.min_args); |
117 | int dmax = d.max_args; |
118 | if (dmax == QMakeBuiltinInit::VarArgs) { |
119 | Q_ASSERT_X(dmin < 2, "init" , d.name); |
120 | if (dmin == 1) { |
121 | Q_ASSERT_X(d.args != nullptr, "init" , d.name); |
122 | usage = fL1S("%1(%2) requires at least one argument." ) |
123 | .arg(fL1S(d.name), fL1S(d.args)); |
124 | } |
125 | return; |
126 | } |
127 | int arange = dmax - dmin; |
128 | Q_ASSERT_X(arange >= 0, "init" , d.name); |
129 | Q_ASSERT_X(d.args != nullptr, "init" , d.name); |
130 | usage = arange > 1 |
131 | ? fL1S("%1(%2) requires %3 to %4 arguments." ) |
132 | .arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmin]), fL1S(nstr[dmax])) |
133 | : arange > 0 |
134 | ? fL1S("%1(%2) requires %3 or %4 arguments." ) |
135 | .arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmin]), fL1S(nstr[dmax])) |
136 | : dmax != 1 |
137 | ? fL1S("%1(%2) requires %3 arguments." ) |
138 | .arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmax])) |
139 | : fL1S("%1(%2) requires one argument." ) |
140 | .arg(fL1S(d.name), fL1S(d.args)); |
141 | } |
142 | |
143 | void QMakeEvaluator::initFunctionStatics() |
144 | { |
145 | static const QMakeBuiltinInit expandInits[] = { |
146 | { .name: "member" , .func: E_MEMBER, .min_args: 1, .max_args: 3, .args: "var, [start, [end]]" }, |
147 | { .name: "str_member" , .func: E_STR_MEMBER, .min_args: -1, .max_args: 3, .args: "str, [start, [end]]" }, |
148 | { .name: "first" , .func: E_FIRST, .min_args: 1, .max_args: 1, .args: "var" }, |
149 | { .name: "take_first" , .func: E_TAKE_FIRST, .min_args: 1, .max_args: 1, .args: "var" }, |
150 | { .name: "last" , .func: E_LAST, .min_args: 1, .max_args: 1, .args: "var" }, |
151 | { .name: "take_last" , .func: E_TAKE_LAST, .min_args: 1, .max_args: 1, .args: "var" }, |
152 | { .name: "size" , .func: E_SIZE, .min_args: 1, .max_args: 1, .args: "var" }, |
153 | { .name: "str_size" , .func: E_STR_SIZE, .min_args: -1, .max_args: 1, .args: "str" }, |
154 | { .name: "cat" , .func: E_CAT, .min_args: 1, .max_args: 2, .args: "file, [mode=true|blob|lines]" }, |
155 | { .name: "fromfile" , .func: E_FROMFILE, .min_args: 2, .max_args: 2, .args: "file, var" }, |
156 | { .name: "eval" , .func: E_EVAL, .min_args: 1, .max_args: 1, .args: "var" }, |
157 | { .name: "list" , .func: E_LIST, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
158 | { .name: "sprintf" , .func: E_SPRINTF, .min_args: 1, .max_args: QMakeBuiltinInit::VarArgs, .args: "format, ..." }, |
159 | { .name: "format_number" , .func: E_FORMAT_NUMBER, .min_args: 1, .max_args: 2, .args: "number, [options...]" }, |
160 | { .name: "num_add" , .func: E_NUM_ADD, .min_args: 1, .max_args: QMakeBuiltinInit::VarArgs, .args: "num, ..." }, |
161 | { .name: "join" , .func: E_JOIN, .min_args: 1, .max_args: 4, .args: "var, [glue, [before, [after]]]" }, |
162 | { .name: "split" , .func: E_SPLIT, .min_args: 1, .max_args: 2, .args: "var, sep" }, |
163 | { .name: "basename" , .func: E_BASENAME, .min_args: 1, .max_args: 1, .args: "var" }, |
164 | { .name: "dirname" , .func: E_DIRNAME, .min_args: 1, .max_args: 1, .args: "var" }, |
165 | { .name: "section" , .func: E_SECTION, .min_args: 3, .max_args: 4, .args: "var, sep, begin, [end]" }, |
166 | { .name: "find" , .func: E_FIND, .min_args: 2, .max_args: 2, .args: "var, str" }, |
167 | { .name: "system" , .func: E_SYSTEM, .min_args: 1, .max_args: 3, .args: "command, [mode], [stsvar]" }, |
168 | { .name: "unique" , .func: E_UNIQUE, .min_args: 1, .max_args: 1, .args: "var" }, |
169 | { .name: "sorted" , .func: E_SORTED, .min_args: 1, .max_args: 1, .args: "var" }, |
170 | { .name: "reverse" , .func: E_REVERSE, .min_args: 1, .max_args: 1, .args: "var" }, |
171 | { .name: "quote" , .func: E_QUOTE, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
172 | { .name: "escape_expand" , .func: E_ESCAPE_EXPAND, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
173 | { .name: "upper" , .func: E_UPPER, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
174 | { .name: "lower" , .func: E_LOWER, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
175 | { .name: "title" , .func: E_TITLE, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
176 | { .name: "re_escape" , .func: E_RE_ESCAPE, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
177 | { .name: "val_escape" , .func: E_VAL_ESCAPE, .min_args: 1, .max_args: 1, .args: "var" }, |
178 | { .name: "files" , .func: E_FILES, .min_args: 1, .max_args: 2, .args: "pattern, [recursive=false]" }, |
179 | { .name: "prompt" , .func: E_PROMPT, .min_args: 1, .max_args: 2, .args: "question, [decorate=true]" }, |
180 | { .name: "replace" , .func: E_REPLACE, .min_args: 3, .max_args: 3, .args: "var, before, after" }, |
181 | { .name: "sort_depends" , .func: E_SORT_DEPENDS, .min_args: 1, .max_args: 4, .args: "var, [prefix, [suffixes, [prio-suffix]]]" }, |
182 | { .name: "resolve_depends" , .func: E_RESOLVE_DEPENDS, .min_args: 1, .max_args: 4, .args: "var, [prefix, [suffixes, [prio-suffix]]]" }, |
183 | { .name: "enumerate_vars" , .func: E_ENUMERATE_VARS, .min_args: 0, .max_args: 0, .args: "" }, |
184 | { .name: "shadowed" , .func: E_SHADOWED, .min_args: 1, .max_args: 1, .args: "path" }, |
185 | { .name: "absolute_path" , .func: E_ABSOLUTE_PATH, .min_args: -1, .max_args: 2, .args: "path, [base]" }, |
186 | { .name: "relative_path" , .func: E_RELATIVE_PATH, .min_args: -1, .max_args: 2, .args: "path, [base]" }, |
187 | { .name: "clean_path" , .func: E_CLEAN_PATH, .min_args: -1, .max_args: 1, .args: "path" }, |
188 | { .name: "system_path" , .func: E_SYSTEM_PATH, .min_args: -1, .max_args: 1, .args: "path" }, |
189 | { .name: "shell_path" , .func: E_SHELL_PATH, .min_args: -1, .max_args: 1, .args: "path" }, |
190 | { .name: "system_quote" , .func: E_SYSTEM_QUOTE, .min_args: -1, .max_args: 1, .args: "arg" }, |
191 | { .name: "shell_quote" , .func: E_SHELL_QUOTE, .min_args: -1, .max_args: 1, .args: "arg" }, |
192 | { .name: "getenv" , .func: E_GETENV, .min_args: 1, .max_args: 1, .args: "arg" }, |
193 | }; |
194 | statics.expands.reserve(asize: (int)(sizeof(expandInits)/sizeof(expandInits[0]))); |
195 | for (unsigned i = 0; i < sizeof(expandInits)/sizeof(expandInits[0]); ++i) |
196 | statics.expands.insert(akey: ProKey(expandInits[i].name), avalue: QMakeBuiltin(expandInits[i])); |
197 | |
198 | static const QMakeBuiltinInit testInits[] = { |
199 | { .name: "requires" , .func: T_REQUIRES, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
200 | { .name: "greaterThan" , .func: T_GREATERTHAN, .min_args: 2, .max_args: 2, .args: "var, val" }, |
201 | { .name: "lessThan" , .func: T_LESSTHAN, .min_args: 2, .max_args: 2, .args: "var, val" }, |
202 | { .name: "equals" , .func: T_EQUALS, .min_args: 2, .max_args: 2, .args: "var, val" }, |
203 | { .name: "isEqual" , .func: T_EQUALS, .min_args: 2, .max_args: 2, .args: "var, val" }, |
204 | { .name: "versionAtLeast" , .func: T_VERSION_AT_LEAST, .min_args: 2, .max_args: 2, .args: "var, version" }, |
205 | { .name: "versionAtMost" , .func: T_VERSION_AT_MOST, .min_args: 2, .max_args: 2, .args: "var, version" }, |
206 | { .name: "exists" , .func: T_EXISTS, .min_args: 1, .max_args: 1, .args: "file" }, |
207 | { .name: "export" , .func: T_EXPORT, .min_args: 1, .max_args: 1, .args: "var" }, |
208 | { .name: "clear" , .func: T_CLEAR, .min_args: 1, .max_args: 1, .args: "var" }, |
209 | { .name: "unset" , .func: T_UNSET, .min_args: 1, .max_args: 1, .args: "var" }, |
210 | { .name: "eval" , .func: T_EVAL, .min_args: 0, .max_args: QMakeBuiltinInit::VarArgs, .args: nullptr }, |
211 | { .name: "CONFIG" , .func: T_CONFIG, .min_args: 1, .max_args: 2, .args: "config, [mutuals]" }, |
212 | { .name: "if" , .func: T_IF, .min_args: 1, .max_args: 1, .args: "condition" }, |
213 | { .name: "isActiveConfig" , .func: T_CONFIG, .min_args: 1, .max_args: 2, .args: "config, [mutuals]" }, |
214 | { .name: "system" , .func: T_SYSTEM, .min_args: 1, .max_args: 1, .args: "exec" }, |
215 | { .name: "discard_from" , .func: T_DISCARD_FROM, .min_args: 1, .max_args: 1, .args: "file" }, |
216 | { .name: "defined" , .func: T_DEFINED, .min_args: 1, .max_args: 2, .args: "object, [\"test\"|\"replace\"|\"var\"]" }, |
217 | { .name: "contains" , .func: T_CONTAINS, .min_args: 2, .max_args: 3, .args: "var, val, [mutuals]" }, |
218 | { .name: "infile" , .func: T_INFILE, .min_args: 2, .max_args: 3, .args: "file, var, [values]" }, |
219 | { .name: "count" , .func: T_COUNT, .min_args: 2, .max_args: 3, .args: "var, count, [op=operator]" }, |
220 | { .name: "isEmpty" , .func: T_ISEMPTY, .min_args: 1, .max_args: 1, .args: "var" }, |
221 | #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) |
222 | { .name: "parseJson" , .func: T_PARSE_JSON, .min_args: 2, .max_args: 2, .args: "var, into" }, |
223 | #endif |
224 | { .name: "load" , .func: T_LOAD, .min_args: 1, .max_args: 2, .args: "feature, [ignore_errors=false]" }, |
225 | { .name: "include" , .func: T_INCLUDE, .min_args: 1, .max_args: 3, .args: "file, [into, [silent]]" }, |
226 | { .name: "debug" , .func: T_DEBUG, .min_args: 2, .max_args: 2, .args: "level, message" }, |
227 | { .name: "log" , .func: T_LOG, .min_args: 1, .max_args: 1, .args: "message" }, |
228 | { .name: "message" , .func: T_MESSAGE, .min_args: 1, .max_args: 1, .args: "message" }, |
229 | { .name: "warning" , .func: T_WARNING, .min_args: 1, .max_args: 1, .args: "message" }, |
230 | { .name: "error" , .func: T_ERROR, .min_args: 0, .max_args: 1, .args: "message" }, |
231 | { .name: "mkpath" , .func: T_MKPATH, .min_args: 1, .max_args: 1, .args: "path" }, |
232 | { .name: "write_file" , .func: T_WRITE_FILE, .min_args: 1, .max_args: 3, .args: "name, [content var, [append] [exe]]" }, |
233 | { .name: "touch" , .func: T_TOUCH, .min_args: 2, .max_args: 2, .args: "file, reffile" }, |
234 | { .name: "cache" , .func: T_CACHE, .min_args: 0, .max_args: 3, .args: "[var], [set|add|sub] [transient] [super|stash], [srcvar]" }, |
235 | { .name: "reload_properties" , .func: T_RELOAD_PROPERTIES, .min_args: 0, .max_args: 0, .args: "" }, |
236 | }; |
237 | statics.functions.reserve(asize: (int)(sizeof(testInits)/sizeof(testInits[0]))); |
238 | for (unsigned i = 0; i < sizeof(testInits)/sizeof(testInits[0]); ++i) |
239 | statics.functions.insert(akey: ProKey(testInits[i].name), avalue: QMakeBuiltin(testInits[i])); |
240 | } |
241 | |
242 | static bool isTrue(const ProString &str) |
243 | { |
244 | return !str.compare(sub: statics.strtrue, cs: Qt::CaseInsensitive) || str.toInt(); |
245 | } |
246 | |
247 | bool |
248 | QMakeEvaluator::getMemberArgs(const ProKey &func, int srclen, const ProStringList &args, |
249 | int *start, int *end) |
250 | { |
251 | *start = 0, *end = 0; |
252 | if (args.count() >= 2) { |
253 | bool ok = true; |
254 | const ProString &start_str = args.at(i: 1); |
255 | *start = start_str.toInt(ok: &ok); |
256 | if (!ok) { |
257 | if (args.count() == 2) { |
258 | int dotdot = start_str.indexOf(s: statics.strDotDot); |
259 | if (dotdot != -1) { |
260 | *start = start_str.left(len: dotdot).toInt(ok: &ok); |
261 | if (ok) |
262 | *end = start_str.mid(off: dotdot+2).toInt(ok: &ok); |
263 | } |
264 | } |
265 | if (!ok) { |
266 | ProStringRoUser u1(func, m_tmp1); |
267 | ProStringRoUser u2(start_str, m_tmp2); |
268 | evalError(fL1S("%1() argument 2 (start) '%2' invalid." ).arg(args&: u1.str(), args&: u2.str())); |
269 | return false; |
270 | } |
271 | } else { |
272 | *end = *start; |
273 | if (args.count() == 3) |
274 | *end = args.at(i: 2).toInt(ok: &ok); |
275 | if (!ok) { |
276 | ProStringRoUser u1(func, m_tmp1); |
277 | ProStringRoUser u2(args.at(i: 2), m_tmp2); |
278 | evalError(fL1S("%1() argument 3 (end) '%2' invalid." ).arg(args&: u1.str(), args&: u2.str())); |
279 | return false; |
280 | } |
281 | } |
282 | } |
283 | if (*start < 0) |
284 | *start += srclen; |
285 | if (*end < 0) |
286 | *end += srclen; |
287 | if (*start < 0 || *start >= srclen || *end < 0 || *end >= srclen) |
288 | return false; |
289 | return true; |
290 | } |
291 | |
292 | QString |
293 | QMakeEvaluator::quoteValue(const ProString &val) |
294 | { |
295 | QString ret; |
296 | ret.reserve(asize: val.size()); |
297 | const QChar *chars = val.constData(); |
298 | bool quote = val.isEmpty(); |
299 | bool escaping = false; |
300 | for (int i = 0, l = val.size(); i < l; i++) { |
301 | QChar c = chars[i]; |
302 | ushort uc = c.unicode(); |
303 | if (uc < 32) { |
304 | if (!escaping) { |
305 | escaping = true; |
306 | ret += QLatin1String("$$escape_expand(" ); |
307 | } |
308 | switch (uc) { |
309 | case '\r': |
310 | ret += QLatin1String("\\\\r" ); |
311 | break; |
312 | case '\n': |
313 | ret += QLatin1String("\\\\n" ); |
314 | break; |
315 | case '\t': |
316 | ret += QLatin1String("\\\\t" ); |
317 | break; |
318 | default: |
319 | ret += QString::fromLatin1(str: "\\\\x%1" ).arg(a: uc, fieldWidth: 2, base: 16, fillChar: QLatin1Char('0')); |
320 | break; |
321 | } |
322 | } else { |
323 | if (escaping) { |
324 | escaping = false; |
325 | ret += QLatin1Char(')'); |
326 | } |
327 | switch (uc) { |
328 | case '\\': |
329 | ret += QLatin1String("\\\\" ); |
330 | break; |
331 | case '"': |
332 | ret += QLatin1String("\\\"" ); |
333 | break; |
334 | case '\'': |
335 | ret += QLatin1String("\\'" ); |
336 | break; |
337 | case '$': |
338 | ret += QLatin1String("\\$" ); |
339 | break; |
340 | case '#': |
341 | ret += QLatin1String("$${LITERAL_HASH}" ); |
342 | break; |
343 | case 32: |
344 | quote = true; |
345 | Q_FALLTHROUGH(); |
346 | default: |
347 | ret += c; |
348 | break; |
349 | } |
350 | } |
351 | } |
352 | if (escaping) |
353 | ret += QLatin1Char(')'); |
354 | if (quote) { |
355 | ret.prepend(c: QLatin1Char('"')); |
356 | ret.append(c: QLatin1Char('"')); |
357 | } |
358 | return ret; |
359 | } |
360 | |
361 | #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) |
362 | static void addJsonValue(const QJsonValue &value, const QString &keyPrefix, ProValueMap *map); |
363 | |
364 | static void insertJsonKeyValue(const QString &key, const QStringList &values, ProValueMap *map) |
365 | { |
366 | map->insert(akey: ProKey(key), avalue: ProStringList(values)); |
367 | } |
368 | |
369 | static void addJsonArray(const QJsonArray &array, const QString &keyPrefix, ProValueMap *map) |
370 | { |
371 | QStringList keys; |
372 | const int size = array.count(); |
373 | keys.reserve(alloc: size); |
374 | for (int i = 0; i < size; ++i) { |
375 | const QString number = QString::number(i); |
376 | keys.append(t: number); |
377 | addJsonValue(value: array.at(i), keyPrefix: keyPrefix + number, map); |
378 | } |
379 | insertJsonKeyValue(key: keyPrefix + QLatin1String("_KEYS_" ), values: keys, map); |
380 | } |
381 | |
382 | static void addJsonObject(const QJsonObject &object, const QString &keyPrefix, ProValueMap *map) |
383 | { |
384 | QStringList keys; |
385 | keys.reserve(alloc: object.size()); |
386 | for (auto it = object.begin(), end = object.end(); it != end; ++it) { |
387 | const QString key = it.key(); |
388 | keys.append(t: key); |
389 | addJsonValue(value: it.value(), keyPrefix: keyPrefix + key, map); |
390 | } |
391 | insertJsonKeyValue(key: keyPrefix + QLatin1String("_KEYS_" ), values: keys, map); |
392 | } |
393 | |
394 | static void addJsonValue(const QJsonValue &value, const QString &keyPrefix, ProValueMap *map) |
395 | { |
396 | switch (value.type()) { |
397 | case QJsonValue::Bool: |
398 | insertJsonKeyValue(key: keyPrefix, values: QStringList() << (value.toBool() ? QLatin1String("true" ) : QLatin1String("false" )), map); |
399 | break; |
400 | case QJsonValue::Double: |
401 | insertJsonKeyValue(key: keyPrefix, values: QStringList() << QString::number(value.toDouble()), map); |
402 | break; |
403 | case QJsonValue::String: |
404 | insertJsonKeyValue(key: keyPrefix, values: QStringList() << value.toString(), map); |
405 | break; |
406 | case QJsonValue::Array: |
407 | addJsonArray(array: value.toArray(), keyPrefix: keyPrefix + QLatin1Char('.'), map); |
408 | break; |
409 | case QJsonValue::Object: |
410 | addJsonObject(object: value.toObject(), keyPrefix: keyPrefix + QLatin1Char('.'), map); |
411 | break; |
412 | default: |
413 | break; |
414 | } |
415 | } |
416 | |
417 | struct ErrorPosition { |
418 | int line; |
419 | int column; |
420 | }; |
421 | |
422 | static ErrorPosition calculateErrorPosition(const QByteArray &json, int offset) |
423 | { |
424 | ErrorPosition pos = { .line: 0, .column: 0 }; |
425 | offset--; // offset is 1-based, switching to 0-based |
426 | for (int i = 0; i < offset; ++i) { |
427 | switch (json.at(i)) { |
428 | case '\n': |
429 | pos.line++; |
430 | pos.column = 0; |
431 | break; |
432 | case '\r': |
433 | break; |
434 | case '\t': |
435 | pos.column = (pos.column + 8) & ~7; |
436 | break; |
437 | default: |
438 | pos.column++; |
439 | break; |
440 | } |
441 | } |
442 | // Lines and columns in text editors are 1-based: |
443 | pos.line++; |
444 | pos.column++; |
445 | return pos; |
446 | } |
447 | |
448 | QMakeEvaluator::VisitReturn QMakeEvaluator::parseJsonInto(const QByteArray &json, const QString &into, ProValueMap *value) |
449 | { |
450 | QJsonParseError error; |
451 | QJsonDocument document = QJsonDocument::fromJson(json, error: &error); |
452 | if (document.isNull()) { |
453 | if (error.error != QJsonParseError::NoError) { |
454 | ErrorPosition errorPos = calculateErrorPosition(json, offset: error.offset); |
455 | evalError(fL1S("Error parsing JSON at %1:%2: %3" ) |
456 | .arg(a: errorPos.line).arg(a: errorPos.column).arg(a: error.errorString())); |
457 | } |
458 | return QMakeEvaluator::ReturnFalse; |
459 | } |
460 | |
461 | QString currentKey = into + QLatin1Char('.'); |
462 | |
463 | // top-level item is either an array or object |
464 | if (document.isArray()) |
465 | addJsonArray(array: document.array(), keyPrefix: currentKey, map: value); |
466 | else if (document.isObject()) |
467 | addJsonObject(object: document.object(), keyPrefix: currentKey, map: value); |
468 | else |
469 | return QMakeEvaluator::ReturnFalse; |
470 | |
471 | return QMakeEvaluator::ReturnTrue; |
472 | } |
473 | #endif |
474 | |
475 | QMakeEvaluator::VisitReturn |
476 | QMakeEvaluator::writeFile(const QString &ctx, const QString &fn, QIODevice::OpenMode mode, |
477 | QMakeVfs::VfsFlags flags, const QString &contents) |
478 | { |
479 | int oldId = m_vfs->idForFileName(fn, flags: flags | QMakeVfs::VfsAccessedOnly); |
480 | int id = m_vfs->idForFileName(fn, flags: flags | QMakeVfs::VfsCreate); |
481 | QString errStr; |
482 | if (!m_vfs->writeFile(id, mode, flags, contents, errStr: &errStr)) { |
483 | evalError(fL1S("Cannot write %1file %2: %3" ) |
484 | .arg(args: ctx, args: QDir::toNativeSeparators(pathName: fn), args&: errStr)); |
485 | return ReturnFalse; |
486 | } |
487 | if (oldId) |
488 | m_parser->discardFileFromCache(id: oldId); |
489 | return ReturnTrue; |
490 | } |
491 | |
492 | #if QT_CONFIG(process) |
493 | void QMakeEvaluator::runProcess(QProcess *proc, const QString &command) const |
494 | { |
495 | proc->setWorkingDirectory(currentDirectory()); |
496 | # ifdef PROEVALUATOR_SETENV |
497 | if (!m_option->environment.isEmpty()) |
498 | proc->setProcessEnvironment(m_option->environment); |
499 | # endif |
500 | # ifdef Q_OS_WIN |
501 | proc->setNativeArguments(QLatin1String("/v:off /s /c \"" ) + command + QLatin1Char('"')); |
502 | proc->start(m_option->getEnv(QLatin1String("COMSPEC" )), QStringList()); |
503 | # else |
504 | proc->start(program: QLatin1String("/bin/sh" ), arguments: QStringList() << QLatin1String("-c" ) << command); |
505 | # endif |
506 | proc->waitForFinished(msecs: -1); |
507 | } |
508 | #endif |
509 | |
510 | QByteArray QMakeEvaluator::getCommandOutput(const QString &args, int *exitCode) const |
511 | { |
512 | QByteArray out; |
513 | #if QT_CONFIG(process) |
514 | QProcess proc; |
515 | runProcess(proc: &proc, command: args); |
516 | *exitCode = (proc.exitStatus() == QProcess::NormalExit) ? proc.exitCode() : -1; |
517 | QByteArray errout = proc.readAllStandardError(); |
518 | # ifdef PROEVALUATOR_FULL |
519 | // FIXME: Qt really should have the option to set forwarding per channel |
520 | fputs(errout.constData(), stderr); |
521 | # else |
522 | if (!errout.isEmpty()) { |
523 | if (errout.endsWith(c: '\n')) |
524 | errout.chop(n: 1); |
525 | m_handler->message( |
526 | type: QMakeHandler::EvalError | (m_cumulative ? QMakeHandler::CumulativeEvalMessage : 0), |
527 | msg: QString::fromLocal8Bit(str: errout)); |
528 | } |
529 | # endif |
530 | out = proc.readAllStandardOutput(); |
531 | # ifdef Q_OS_WIN |
532 | // FIXME: Qt's line end conversion on sequential files should really be fixed |
533 | out.replace("\r\n" , "\n" ); |
534 | # endif |
535 | #else |
536 | if (FILE *proc = QT_POPEN(QString(QLatin1String("cd " ) |
537 | + IoUtils::shellQuote(QDir::toNativeSeparators(currentDirectory())) |
538 | + QLatin1String(" && " ) + args).toLocal8Bit().constData(), QT_POPEN_READ)) { |
539 | while (!feof(proc)) { |
540 | char buff[10 * 1024]; |
541 | int read_in = int(fread(buff, 1, sizeof(buff), proc)); |
542 | if (!read_in) |
543 | break; |
544 | out += QByteArray(buff, read_in); |
545 | } |
546 | int ec = QT_PCLOSE(proc); |
547 | # ifdef Q_OS_WIN |
548 | *exitCode = ec >= 0 ? ec : -1; |
549 | # else |
550 | *exitCode = WIFEXITED(ec) ? WEXITSTATUS(ec) : -1; |
551 | # endif |
552 | } |
553 | # ifdef Q_OS_WIN |
554 | out.replace("\r\n" , "\n" ); |
555 | # endif |
556 | #endif |
557 | return out; |
558 | } |
559 | |
560 | void QMakeEvaluator::populateDeps( |
561 | const ProStringList &deps, const ProString &prefix, const ProStringList &suffixes, |
562 | const ProString &priosfx, |
563 | QHash<ProKey, QSet<ProKey> > &dependencies, ProValueMap &dependees, |
564 | QMultiMap<int, ProString> &rootSet) const |
565 | { |
566 | for (const ProString &item : deps) |
567 | if (!dependencies.contains(akey: item.toKey())) { |
568 | QSet<ProKey> &dset = dependencies[item.toKey()]; // Always create entry |
569 | ProStringList depends; |
570 | for (const ProString &suffix : suffixes) |
571 | depends += values(variableName: ProKey(prefix + item + suffix)); |
572 | if (depends.isEmpty()) { |
573 | rootSet.insert(akey: first(variableName: ProKey(prefix + item + priosfx)).toInt(), avalue: item); |
574 | } else { |
575 | for (const ProString &dep : qAsConst(t&: depends)) { |
576 | dset.insert(value: dep.toKey()); |
577 | dependees[dep.toKey()] << item; |
578 | } |
579 | populateDeps(deps: depends, prefix, suffixes, priosfx, dependencies, dependees, rootSet); |
580 | } |
581 | } |
582 | } |
583 | |
584 | QString QMakeEvaluator::filePathArg0(const ProStringList &args) |
585 | { |
586 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
587 | QString fn = resolvePath(fileName: u1.str()); |
588 | fn.detach(); |
589 | return fn; |
590 | } |
591 | |
592 | QString QMakeEvaluator::filePathEnvArg0(const ProStringList &args) |
593 | { |
594 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
595 | QString fn = resolvePath(fileName: m_option->expandEnvVars(str: u1.str())); |
596 | fn.detach(); |
597 | return fn; |
598 | } |
599 | |
600 | QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinExpand( |
601 | const QMakeBuiltin &adef, const ProKey &func, const ProStringList &args, ProStringList &ret) |
602 | { |
603 | traceMsg(fmt: "calling built-in $$%s(%s)" , dbgKey(func), dbgSepStrList(args)); |
604 | int asz = args.size() > 1 ? args.size() : args.at(i: 0).isEmpty() ? 0 : 1; |
605 | if (asz < adef.minArgs || asz > adef.maxArgs) { |
606 | evalError(msg: adef.usage); |
607 | return ReturnTrue; |
608 | } |
609 | |
610 | int func_t = adef.index; |
611 | switch (func_t) { |
612 | case E_BASENAME: |
613 | case E_DIRNAME: |
614 | case E_SECTION: { |
615 | bool regexp = false; |
616 | QString sep; |
617 | ProString var; |
618 | int beg = 0; |
619 | int end = -1; |
620 | if (func_t == E_SECTION) { |
621 | var = args[0]; |
622 | sep = args.at(i: 1).toQString(); |
623 | beg = args.at(i: 2).toInt(); |
624 | if (args.count() == 4) |
625 | end = args.at(i: 3).toInt(); |
626 | } else { |
627 | var = args[0]; |
628 | regexp = true; |
629 | sep = QLatin1String("[\\\\/]" ); |
630 | if (func_t == E_DIRNAME) |
631 | end = -2; |
632 | else |
633 | beg = -1; |
634 | } |
635 | if (!var.isEmpty()) { |
636 | const auto strings = values(variableName: map(var)); |
637 | if (regexp) { |
638 | QRegExp sepRx(sep); |
639 | for (const ProString &str : strings) { |
640 | ProStringRwUser u1(str, m_tmp[m_toggle ^= 1]); |
641 | ret << u1.extract(s: u1.str().section(reg: sepRx, start: beg, end)); |
642 | } |
643 | } else { |
644 | for (const ProString &str : strings) { |
645 | ProStringRwUser u1(str, m_tmp1); |
646 | ret << u1.extract(s: u1.str().section(in_sep: sep, start: beg, end)); |
647 | } |
648 | } |
649 | } |
650 | break; |
651 | } |
652 | case E_SPRINTF: { |
653 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
654 | QString tmp = u1.str(); |
655 | for (int i = 1; i < args.count(); ++i) |
656 | tmp = tmp.arg(a: args.at(i).toQStringView()); |
657 | ret << u1.extract(s: tmp); |
658 | break; |
659 | } |
660 | case E_FORMAT_NUMBER: { |
661 | int ibase = 10; |
662 | int obase = 10; |
663 | int width = 0; |
664 | bool zeropad = false; |
665 | bool leftalign = false; |
666 | enum { DefaultSign, PadSign, AlwaysSign } sign = DefaultSign; |
667 | if (args.count() >= 2) { |
668 | const auto opts = split_value_list(vals: args.at(i: 1).toQStringRef()); |
669 | for (const ProString &opt : opts) { |
670 | if (opt.startsWith(sub: QLatin1String("ibase=" ))) { |
671 | ibase = opt.mid(off: 6).toInt(); |
672 | } else if (opt.startsWith(sub: QLatin1String("obase=" ))) { |
673 | obase = opt.mid(off: 6).toInt(); |
674 | } else if (opt.startsWith(sub: QLatin1String("width=" ))) { |
675 | width = opt.mid(off: 6).toInt(); |
676 | } else if (opt == QLatin1String("zeropad" )) { |
677 | zeropad = true; |
678 | } else if (opt == QLatin1String("padsign" )) { |
679 | sign = PadSign; |
680 | } else if (opt == QLatin1String("alwayssign" )) { |
681 | sign = AlwaysSign; |
682 | } else if (opt == QLatin1String("leftalign" )) { |
683 | leftalign = true; |
684 | } else { |
685 | evalError(fL1S("format_number(): invalid format option %1." ) |
686 | .arg(a: opt.toQStringView())); |
687 | goto allfail; |
688 | } |
689 | } |
690 | } |
691 | if (args.at(i: 0).contains(c: QLatin1Char('.'))) { |
692 | evalError(fL1S("format_number(): floats are currently not supported." )); |
693 | break; |
694 | } |
695 | bool ok; |
696 | qlonglong num = args.at(i: 0).toLongLong(ok: &ok, base: ibase); |
697 | if (!ok) { |
698 | evalError(fL1S("format_number(): malformed number %2 for base %1." ) |
699 | .arg(a: ibase).arg(a: args.at(i: 0).toQStringView())); |
700 | break; |
701 | } |
702 | QString outstr; |
703 | if (num < 0) { |
704 | num = -num; |
705 | outstr = QLatin1Char('-'); |
706 | } else if (sign == AlwaysSign) { |
707 | outstr = QLatin1Char('+'); |
708 | } else if (sign == PadSign) { |
709 | outstr = QLatin1Char(' '); |
710 | } |
711 | QString numstr = QString::number(num, base: obase); |
712 | int space = width - outstr.length() - numstr.length(); |
713 | if (space <= 0) { |
714 | outstr += numstr; |
715 | } else if (leftalign) { |
716 | outstr += numstr + QString(space, QLatin1Char(' ')); |
717 | } else if (zeropad) { |
718 | outstr += QString(space, QLatin1Char('0')) + numstr; |
719 | } else { |
720 | outstr.prepend(s: QString(space, QLatin1Char(' '))); |
721 | outstr += numstr; |
722 | } |
723 | ret += ProString(outstr); |
724 | break; |
725 | } |
726 | case E_NUM_ADD: { |
727 | qlonglong sum = 0; |
728 | for (const ProString &arg : qAsConst(t: args)) { |
729 | if (arg.contains(c: QLatin1Char('.'))) { |
730 | evalError(fL1S("num_add(): floats are currently not supported." )); |
731 | goto allfail; |
732 | } |
733 | bool ok; |
734 | qlonglong num = arg.toLongLong(ok: &ok); |
735 | if (!ok) { |
736 | evalError(fL1S("num_add(): malformed number %1." ) |
737 | .arg(a: arg.toQStringView())); |
738 | goto allfail; |
739 | } |
740 | sum += num; |
741 | } |
742 | ret += ProString(QString::number(sum)); |
743 | break; |
744 | } |
745 | case E_JOIN: { |
746 | ProString glue, before, after; |
747 | if (args.count() >= 2) |
748 | glue = args.at(i: 1); |
749 | if (args.count() >= 3) |
750 | before = args[2]; |
751 | if (args.count() == 4) |
752 | after = args[3]; |
753 | const ProStringList &var = values(variableName: map(var: args.at(i: 0))); |
754 | if (!var.isEmpty()) { |
755 | int src = currentFileId(); |
756 | for (const ProString &v : var) |
757 | if (int s = v.sourceFile()) { |
758 | src = s; |
759 | break; |
760 | } |
761 | ret << ProString(before + var.join(sep: glue) + after).setSource(src); |
762 | } |
763 | break; |
764 | } |
765 | case E_SPLIT: { |
766 | ProStringRoUser u1(m_tmp1); |
767 | const QString &sep = (args.count() == 2) ? u1.set(args.at(i: 1)) : statics.field_sep; |
768 | const auto vars = values(variableName: map(var: args.at(i: 0))); |
769 | for (const ProString &var : vars) { |
770 | // FIXME: this is inconsistent with the "there are no empty strings" dogma. |
771 | const auto splits = var.toQStringRef().split(sep, behavior: Qt::KeepEmptyParts); |
772 | for (const auto &splt : splits) |
773 | ret << ProString(splt).setSource(var); |
774 | } |
775 | break; |
776 | } |
777 | case E_MEMBER: { |
778 | const ProStringList &src = values(variableName: map(var: args.at(i: 0))); |
779 | int start, end; |
780 | if (getMemberArgs(func, srclen: src.size(), args, start: &start, end: &end)) { |
781 | ret.reserve(asize: qAbs(t: end - start) + 1); |
782 | if (start < end) { |
783 | for (int i = start; i <= end && src.size() >= i; i++) |
784 | ret += src.at(i); |
785 | } else { |
786 | for (int i = start; i >= end && src.size() >= i && i >= 0; i--) |
787 | ret += src.at(i); |
788 | } |
789 | } |
790 | break; |
791 | } |
792 | case E_STR_MEMBER: { |
793 | const ProString &src = args.at(i: 0); |
794 | int start, end; |
795 | if (getMemberArgs(func, srclen: src.size(), args, start: &start, end: &end)) { |
796 | QString res; |
797 | res.reserve(asize: qAbs(t: end - start) + 1); |
798 | if (start < end) { |
799 | for (int i = start; i <= end && src.size() >= i; i++) |
800 | res += src.at(i); |
801 | } else { |
802 | for (int i = start; i >= end && src.size() >= i && i >= 0; i--) |
803 | res += src.at(i); |
804 | } |
805 | ret += ProString(res); |
806 | } |
807 | break; |
808 | } |
809 | case E_FIRST: |
810 | case E_LAST: { |
811 | const ProStringList &var = values(variableName: map(var: args.at(i: 0))); |
812 | if (!var.isEmpty()) { |
813 | if (func_t == E_FIRST) |
814 | ret.append(t: var[0]); |
815 | else |
816 | ret.append(t: var.last()); |
817 | } |
818 | break; |
819 | } |
820 | case E_TAKE_FIRST: |
821 | case E_TAKE_LAST: { |
822 | ProStringList &var = valuesRef(variableName: map(var: args.at(i: 0))); |
823 | if (!var.isEmpty()) { |
824 | if (func_t == E_TAKE_FIRST) |
825 | ret.append(t: var.takeFirst()); |
826 | else |
827 | ret.append(t: var.takeLast()); |
828 | } |
829 | break; |
830 | } |
831 | case E_SIZE: |
832 | ret.append(t: ProString(QString::number(values(variableName: map(var: args.at(i: 0))).size()))); |
833 | break; |
834 | case E_STR_SIZE: |
835 | ret.append(t: ProString(QString::number(args.at(i: 0).size()))); |
836 | break; |
837 | case E_CAT: { |
838 | bool blob = false; |
839 | bool lines = false; |
840 | bool singleLine = true; |
841 | if (args.count() > 1) { |
842 | if (!args.at(i: 1).compare(sub: QLatin1String("false" ), cs: Qt::CaseInsensitive)) |
843 | singleLine = false; |
844 | else if (!args.at(i: 1).compare(sub: QLatin1String("blob" ), cs: Qt::CaseInsensitive)) |
845 | blob = true; |
846 | else if (!args.at(i: 1).compare(sub: QLatin1String("lines" ), cs: Qt::CaseInsensitive)) |
847 | lines = true; |
848 | } |
849 | QString fn = filePathEnvArg0(args); |
850 | QFile qfile(fn); |
851 | if (qfile.open(flags: QIODevice::ReadOnly)) { |
852 | QTextStream stream(&qfile); |
853 | if (blob) { |
854 | ret += ProString(stream.readAll()); |
855 | } else { |
856 | while (!stream.atEnd()) { |
857 | if (lines) { |
858 | ret += ProString(stream.readLine()); |
859 | } else { |
860 | const QString &line = stream.readLine(); |
861 | ret += split_value_list(vals: QStringRef(&line).trimmed()); |
862 | if (!singleLine) |
863 | ret += ProString("\n" ); |
864 | } |
865 | } |
866 | } |
867 | } |
868 | break; |
869 | } |
870 | case E_FROMFILE: { |
871 | ProValueMap vars; |
872 | QString fn = filePathEnvArg0(args); |
873 | if (evaluateFileInto(fileName: fn, values: &vars, flags: LoadProOnly) == ReturnTrue) |
874 | ret = vars.value(akey: map(var: args.at(i: 1))); |
875 | break; |
876 | } |
877 | case E_EVAL: |
878 | ret += values(variableName: map(var: args.at(i: 0))); |
879 | break; |
880 | case E_LIST: { |
881 | QString tmp = QString::asprintf(format: ".QMAKE_INTERNAL_TMP_variableName_%d" , m_listCount++); |
882 | ret = ProStringList(ProString(tmp)); |
883 | ProStringList lst; |
884 | for (const ProString &arg : args) |
885 | lst += split_value_list(vals: arg.toQStringRef(), source: arg.sourceFile()); // Relies on deep copy |
886 | m_valuemapStack.top()[ret.at(i: 0).toKey()] = lst; |
887 | break; } |
888 | case E_FIND: { |
889 | QRegExp regx(args.at(i: 1).toQString()); |
890 | const auto vals = values(variableName: map(var: args.at(i: 0))); |
891 | for (const ProString &val : vals) { |
892 | ProStringRoUser u1(val, m_tmp[m_toggle ^= 1]); |
893 | if (regx.indexIn(str: u1.str()) != -1) |
894 | ret += val; |
895 | } |
896 | break; |
897 | } |
898 | case E_SYSTEM: { |
899 | if (m_skipLevel) |
900 | break; |
901 | bool blob = false; |
902 | bool lines = false; |
903 | bool singleLine = true; |
904 | if (args.count() > 1) { |
905 | if (!args.at(i: 1).compare(sub: QLatin1String("false" ), cs: Qt::CaseInsensitive)) |
906 | singleLine = false; |
907 | else if (!args.at(i: 1).compare(sub: QLatin1String("blob" ), cs: Qt::CaseInsensitive)) |
908 | blob = true; |
909 | else if (!args.at(i: 1).compare(sub: QLatin1String("lines" ), cs: Qt::CaseInsensitive)) |
910 | lines = true; |
911 | } |
912 | int exitCode; |
913 | QByteArray bytes = getCommandOutput(args: args.at(i: 0).toQString(), exitCode: &exitCode); |
914 | if (args.count() > 2 && !args.at(i: 2).isEmpty()) { |
915 | m_valuemapStack.top()[args.at(i: 2).toKey()] = |
916 | ProStringList(ProString(QString::number(exitCode))); |
917 | } |
918 | if (lines) { |
919 | QTextStream stream(bytes); |
920 | while (!stream.atEnd()) |
921 | ret += ProString(stream.readLine()); |
922 | } else { |
923 | QString output = QString::fromLocal8Bit(str: bytes); |
924 | if (blob) { |
925 | ret += ProString(output); |
926 | } else { |
927 | output.replace(before: QLatin1Char('\t'), after: QLatin1Char(' ')); |
928 | if (singleLine) |
929 | output.replace(before: QLatin1Char('\n'), after: QLatin1Char(' ')); |
930 | ret += split_value_list(vals: QStringRef(&output)); |
931 | } |
932 | } |
933 | break; |
934 | } |
935 | case E_UNIQUE: |
936 | ret = values(variableName: map(var: args.at(i: 0))); |
937 | ret.removeDuplicates(); |
938 | break; |
939 | case E_SORTED: |
940 | ret = values(variableName: map(var: args.at(i: 0))); |
941 | std::sort(first: ret.begin(), last: ret.end()); |
942 | break; |
943 | case E_REVERSE: { |
944 | ProStringList var = values(variableName: args.at(i: 0).toKey()); |
945 | for (int i = 0; i < var.size() / 2; i++) |
946 | qSwap(value1&: var[i], value2&: var[var.size() - i - 1]); |
947 | ret += var; |
948 | break; |
949 | } |
950 | case E_QUOTE: |
951 | ret += args; |
952 | break; |
953 | case E_ESCAPE_EXPAND: |
954 | for (int i = 0; i < args.size(); ++i) { |
955 | QString str = args.at(i).toQString(); |
956 | QChar *i_data = str.data(); |
957 | int i_len = str.length(); |
958 | for (int x = 0; x < i_len; ++x) { |
959 | if (*(i_data+x) == QLatin1Char('\\') && x < i_len-1) { |
960 | if (*(i_data+x+1) == QLatin1Char('\\')) { |
961 | ++x; |
962 | } else { |
963 | struct { |
964 | char in, out; |
965 | } mapped_quotes[] = { |
966 | { .in: 'n', .out: '\n' }, |
967 | { .in: 't', .out: '\t' }, |
968 | { .in: 'r', .out: '\r' }, |
969 | { .in: 0, .out: 0 } |
970 | }; |
971 | for (int i = 0; mapped_quotes[i].in; ++i) { |
972 | if (*(i_data+x+1) == QLatin1Char(mapped_quotes[i].in)) { |
973 | *(i_data+x) = QLatin1Char(mapped_quotes[i].out); |
974 | if (x < i_len-2) |
975 | memmove(dest: i_data+x+1, src: i_data+x+2, n: (i_len-x-2)*sizeof(QChar)); |
976 | --i_len; |
977 | break; |
978 | } |
979 | } |
980 | } |
981 | } |
982 | } |
983 | ret.append(t: ProString(QString(i_data, i_len)).setSource(args.at(i))); |
984 | } |
985 | break; |
986 | case E_RE_ESCAPE: |
987 | for (int i = 0; i < args.size(); ++i) { |
988 | ProStringRwUser u1(args.at(i), m_tmp1); |
989 | ret << u1.extract(s: QRegExp::escape(str: u1.str())); |
990 | } |
991 | break; |
992 | case E_VAL_ESCAPE: { |
993 | const ProStringList &vals = values(variableName: args.at(i: 0).toKey()); |
994 | ret.reserve(asize: vals.size()); |
995 | for (const ProString &str : vals) |
996 | ret += ProString(quoteValue(val: str)); |
997 | break; |
998 | } |
999 | case E_UPPER: |
1000 | case E_LOWER: |
1001 | case E_TITLE: |
1002 | for (int i = 0; i < args.count(); ++i) { |
1003 | ProStringRwUser u1(args.at(i), m_tmp1); |
1004 | QString rstr = u1.str(); |
1005 | if (func_t == E_UPPER) { |
1006 | rstr = rstr.toUpper(); |
1007 | } else { |
1008 | rstr = rstr.toLower(); |
1009 | if (func_t == E_TITLE && rstr.length() > 0) |
1010 | rstr[0] = rstr.at(i: 0).toTitleCase(); |
1011 | } |
1012 | ret << u1.extract(s: rstr); |
1013 | } |
1014 | break; |
1015 | case E_FILES: { |
1016 | bool recursive = false; |
1017 | if (args.count() == 2) |
1018 | recursive = isTrue(str: args.at(i: 1)); |
1019 | QStringList dirs; |
1020 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
1021 | QString r = m_option->expandEnvVars(str: u1.str()) |
1022 | .replace(before: QLatin1Char('\\'), after: QLatin1Char('/')); |
1023 | QString pfx; |
1024 | if (IoUtils::isRelativePath(fileName: r)) { |
1025 | pfx = currentDirectory(); |
1026 | if (!pfx.endsWith(c: QLatin1Char('/'))) |
1027 | pfx += QLatin1Char('/'); |
1028 | } |
1029 | int slash = r.lastIndexOf(c: QLatin1Char('/')); |
1030 | if (slash != -1) { |
1031 | dirs.append(t: r.left(n: slash+1)); |
1032 | r = r.mid(position: slash+1); |
1033 | } else { |
1034 | dirs.append(t: QString()); |
1035 | } |
1036 | |
1037 | r.detach(); // Keep m_tmp out of QRegExp's cache |
1038 | QRegExp regex(r, Qt::CaseSensitive, QRegExp::Wildcard); |
1039 | for (int d = 0; d < dirs.count(); d++) { |
1040 | QString dir = dirs[d]; |
1041 | QDir qdir(pfx + dir); |
1042 | for (int i = 0; i < (int)qdir.count(); ++i) { |
1043 | if (qdir[i] == statics.strDot || qdir[i] == statics.strDotDot) |
1044 | continue; |
1045 | QString fname = dir + qdir[i]; |
1046 | if (IoUtils::fileType(fileName: pfx + fname) == IoUtils::FileIsDir) { |
1047 | if (recursive) |
1048 | dirs.append(t: fname + QLatin1Char('/')); |
1049 | } |
1050 | if (regex.exactMatch(str: qdir[i])) |
1051 | ret += ProString(fname).setSource(currentFileId()); |
1052 | } |
1053 | } |
1054 | break; |
1055 | } |
1056 | #ifdef PROEVALUATOR_FULL |
1057 | case E_PROMPT: { |
1058 | ProStringRoUser u1(args.at(0), m_tmp1); |
1059 | QString msg = m_option->expandEnvVars(u1.str()); |
1060 | bool decorate = true; |
1061 | if (args.count() == 2) |
1062 | decorate = isTrue(args.at(1)); |
1063 | if (decorate) { |
1064 | if (!msg.endsWith(QLatin1Char('?'))) |
1065 | msg += QLatin1Char('?'); |
1066 | fprintf(stderr, "Project PROMPT: %s " , qPrintable(msg)); |
1067 | } else { |
1068 | fputs(qPrintable(msg), stderr); |
1069 | } |
1070 | QFile qfile; |
1071 | if (qfile.open(stdin, QIODevice::ReadOnly)) { |
1072 | QTextStream t(&qfile); |
1073 | const QString &line = t.readLine(); |
1074 | if (t.atEnd()) { |
1075 | fputs("\n" , stderr); |
1076 | evalError(fL1S("Unexpected EOF." )); |
1077 | return ReturnError; |
1078 | } |
1079 | ret = split_value_list(QStringRef(&line)); |
1080 | } |
1081 | break; |
1082 | } |
1083 | #endif |
1084 | case E_REPLACE: { |
1085 | const QRegExp before(args.at(i: 1).toQString()); |
1086 | ProStringRwUser u2(args.at(i: 2), m_tmp2); |
1087 | const QString &after = u2.str(); |
1088 | const auto vals = values(variableName: map(var: args.at(i: 0))); |
1089 | for (const ProString &val : vals) { |
1090 | ProStringRwUser u1(val, m_tmp1); |
1091 | QString rstr = u1.str(); |
1092 | QString copy = rstr; // Force a detach on modify |
1093 | rstr.replace(rx: before, after); |
1094 | ret << u1.extract(s: rstr, other: u2); |
1095 | } |
1096 | break; |
1097 | } |
1098 | case E_SORT_DEPENDS: |
1099 | case E_RESOLVE_DEPENDS: { |
1100 | QHash<ProKey, QSet<ProKey> > dependencies; |
1101 | ProValueMap dependees; |
1102 | QMultiMap<int, ProString> rootSet; |
1103 | ProStringList orgList = values(variableName: args.at(i: 0).toKey()); |
1104 | ProString prefix = args.count() < 2 ? ProString() : args.at(i: 1); |
1105 | ProString priosfx = args.count() < 4 ? ProString(".priority" ) : args.at(i: 3); |
1106 | populateDeps(deps: orgList, prefix, |
1107 | suffixes: args.count() < 3 ? ProStringList(ProString(".depends" )) |
1108 | : split_value_list(vals: args.at(i: 2).toQStringRef()), |
1109 | priosfx, dependencies, dependees, rootSet); |
1110 | while (!rootSet.isEmpty()) { |
1111 | QMultiMap<int, ProString>::iterator it = rootSet.begin(); |
1112 | const ProString item = *it; |
1113 | rootSet.erase(it); |
1114 | if ((func_t == E_RESOLVE_DEPENDS) || orgList.contains(str: item)) |
1115 | ret.prepend(t: item); |
1116 | for (const ProString &dep : qAsConst(t&: dependees[item.toKey()])) { |
1117 | QSet<ProKey> &dset = dependencies[dep.toKey()]; |
1118 | dset.remove(value: item.toKey()); |
1119 | if (dset.isEmpty()) |
1120 | rootSet.insert(akey: first(variableName: ProKey(prefix + dep + priosfx)).toInt(), avalue: dep); |
1121 | } |
1122 | } |
1123 | break; |
1124 | } |
1125 | case E_ENUMERATE_VARS: { |
1126 | QSet<ProString> keys; |
1127 | for (const ProValueMap &vmap : qAsConst(t&: m_valuemapStack)) |
1128 | for (ProValueMap::ConstIterator it = vmap.constBegin(); it != vmap.constEnd(); ++it) |
1129 | keys.insert(value: it.key()); |
1130 | ret.reserve(asize: keys.size()); |
1131 | for (const ProString &key : qAsConst(t&: keys)) |
1132 | ret << key; |
1133 | break; } |
1134 | case E_SHADOWED: { |
1135 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1136 | QString rstr = m_option->shadowedPath(fileName: resolvePath(fileName: u1.str())); |
1137 | if (!rstr.isEmpty()) |
1138 | ret << u1.extract(s: rstr); |
1139 | break; |
1140 | } |
1141 | case E_ABSOLUTE_PATH: { |
1142 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1143 | ProStringRwUser u2(m_tmp2); |
1144 | QString baseDir = args.count() > 1 |
1145 | ? IoUtils::resolvePath(baseDir: currentDirectory(), fileName: u2.set(args.at(i: 1))) |
1146 | : currentDirectory(); |
1147 | QString rstr = u1.str().isEmpty() ? baseDir : IoUtils::resolvePath(baseDir, fileName: u1.str()); |
1148 | ret << u1.extract(s: rstr, other: u2); |
1149 | break; |
1150 | } |
1151 | case E_RELATIVE_PATH: { |
1152 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1153 | ProStringRoUser u2(m_tmp2); |
1154 | QString baseDir = args.count() > 1 |
1155 | ? IoUtils::resolvePath(baseDir: currentDirectory(), fileName: u2.set(args.at(i: 1))) |
1156 | : currentDirectory(); |
1157 | QString absArg = u1.str().isEmpty() ? baseDir : IoUtils::resolvePath(baseDir, fileName: u1.str()); |
1158 | QString rstr = QDir(baseDir).relativeFilePath(fileName: absArg); |
1159 | ret << u1.extract(s: rstr); |
1160 | break; |
1161 | } |
1162 | case E_CLEAN_PATH: { |
1163 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1164 | ret << u1.extract(s: QDir::cleanPath(path: u1.str())); |
1165 | break; |
1166 | } |
1167 | case E_SYSTEM_PATH: { |
1168 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1169 | QString rstr = u1.str(); |
1170 | #ifdef Q_OS_WIN |
1171 | rstr.replace(QLatin1Char('/'), QLatin1Char('\\')); |
1172 | #else |
1173 | rstr.replace(before: QLatin1Char('\\'), after: QLatin1Char('/')); |
1174 | #endif |
1175 | ret << u1.extract(s: rstr); |
1176 | break; |
1177 | } |
1178 | case E_SHELL_PATH: { |
1179 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1180 | QString rstr = u1.str(); |
1181 | if (m_dirSep.startsWith(c: QLatin1Char('\\'))) { |
1182 | rstr.replace(before: QLatin1Char('/'), after: QLatin1Char('\\')); |
1183 | } else { |
1184 | rstr.replace(before: QLatin1Char('\\'), after: QLatin1Char('/')); |
1185 | #ifdef Q_OS_WIN |
1186 | // Convert d:/foo/bar to msys-style /d/foo/bar. |
1187 | if (rstr.length() > 2 && rstr.at(1) == QLatin1Char(':') && rstr.at(2) == QLatin1Char('/')) { |
1188 | rstr[1] = rstr.at(0); |
1189 | rstr[0] = QLatin1Char('/'); |
1190 | } |
1191 | #endif |
1192 | } |
1193 | ret << u1.extract(s: rstr); |
1194 | break; |
1195 | } |
1196 | case E_SYSTEM_QUOTE: { |
1197 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1198 | ret << u1.extract(s: IoUtils::shellQuote(arg: u1.str())); |
1199 | break; |
1200 | } |
1201 | case E_SHELL_QUOTE: { |
1202 | ProStringRwUser u1(args.at(i: 0), m_tmp1); |
1203 | QString rstr = u1.str(); |
1204 | if (m_dirSep.startsWith(c: QLatin1Char('\\'))) |
1205 | rstr = IoUtils::shellQuoteWin(arg: rstr); |
1206 | else |
1207 | rstr = IoUtils::shellQuoteUnix(arg: rstr); |
1208 | ret << u1.extract(s: rstr); |
1209 | break; |
1210 | } |
1211 | case E_GETENV: { |
1212 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
1213 | ret << ProString(m_option->getEnv(u1.str())); |
1214 | break; |
1215 | } |
1216 | default: |
1217 | evalError(fL1S("Function '%1' is not implemented." ).arg(a: func.toQStringView())); |
1218 | break; |
1219 | } |
1220 | |
1221 | allfail: |
1222 | return ReturnTrue; |
1223 | } |
1224 | |
1225 | QMakeEvaluator::VisitReturn QMakeEvaluator::testFunc_cache(const ProStringList &args) |
1226 | { |
1227 | bool persist = true; |
1228 | enum { TargetStash, TargetCache, TargetSuper } target = TargetCache; |
1229 | enum { CacheSet, CacheAdd, CacheSub } mode = CacheSet; |
1230 | ProKey srcvar; |
1231 | if (args.count() >= 2) { |
1232 | const auto opts = split_value_list(vals: args.at(i: 1).toQStringRef()); |
1233 | for (const ProString &opt : opts) { |
1234 | if (opt == QLatin1String("transient" )) { |
1235 | persist = false; |
1236 | } else if (opt == QLatin1String("super" )) { |
1237 | target = TargetSuper; |
1238 | } else if (opt == QLatin1String("stash" )) { |
1239 | target = TargetStash; |
1240 | } else if (opt == QLatin1String("set" )) { |
1241 | mode = CacheSet; |
1242 | } else if (opt == QLatin1String("add" )) { |
1243 | mode = CacheAdd; |
1244 | } else if (opt == QLatin1String("sub" )) { |
1245 | mode = CacheSub; |
1246 | } else { |
1247 | evalError(fL1S("cache(): invalid flag %1." ).arg(a: opt.toQStringView())); |
1248 | return ReturnFalse; |
1249 | } |
1250 | } |
1251 | if (args.count() >= 3) { |
1252 | srcvar = args.at(i: 2).toKey(); |
1253 | } else if (mode != CacheSet) { |
1254 | evalError(fL1S("cache(): modes other than 'set' require a source variable." )); |
1255 | return ReturnFalse; |
1256 | } |
1257 | } |
1258 | QString varstr; |
1259 | ProKey dstvar = args.at(i: 0).toKey(); |
1260 | if (!dstvar.isEmpty()) { |
1261 | if (srcvar.isEmpty()) |
1262 | srcvar = dstvar; |
1263 | ProValueMap::Iterator srcvarIt; |
1264 | if (!findValues(variableName: srcvar, it: &srcvarIt)) { |
1265 | evalError(fL1S("Variable %1 is not defined." ).arg(a: srcvar.toQStringView())); |
1266 | return ReturnFalse; |
1267 | } |
1268 | // The caches for the host and target may differ (e.g., when we are manipulating |
1269 | // CONFIG), so we cannot compute a common new value for both. |
1270 | const ProStringList &diffval = *srcvarIt; |
1271 | ProStringList newval; |
1272 | bool changed = false; |
1273 | for (bool hostBuild = false; ; hostBuild = true) { |
1274 | #ifdef PROEVALUATOR_THREAD_SAFE |
1275 | m_option->mutex.lock(); |
1276 | #endif |
1277 | QMakeBaseEnv *baseEnv = |
1278 | m_option->baseEnvs.value(akey: QMakeBaseKey(m_buildRoot, m_stashfile, hostBuild)); |
1279 | #ifdef PROEVALUATOR_THREAD_SAFE |
1280 | // It's ok to unlock this before locking baseEnv, |
1281 | // as we have no intention to initialize the env. |
1282 | m_option->mutex.unlock(); |
1283 | #endif |
1284 | do { |
1285 | if (!baseEnv) |
1286 | break; |
1287 | #ifdef PROEVALUATOR_THREAD_SAFE |
1288 | QMutexLocker locker(&baseEnv->mutex); |
1289 | if (baseEnv->inProgress && baseEnv->evaluator != this) { |
1290 | // The env is still in the works, but it may be already past the cache |
1291 | // loading. So we need to wait for completion and amend it as usual. |
1292 | QThreadPool::globalInstance()->releaseThread(); |
1293 | baseEnv->cond.wait(&baseEnv->mutex); |
1294 | QThreadPool::globalInstance()->reserveThread(); |
1295 | } |
1296 | if (!baseEnv->isOk) |
1297 | break; |
1298 | #endif |
1299 | QMakeEvaluator *baseEval = baseEnv->evaluator; |
1300 | const ProStringList &oldval = baseEval->values(variableName: dstvar); |
1301 | if (mode == CacheSet) { |
1302 | newval = diffval; |
1303 | } else { |
1304 | newval = oldval; |
1305 | if (mode == CacheAdd) |
1306 | newval += diffval; |
1307 | else |
1308 | newval.removeEach(value: diffval); |
1309 | } |
1310 | if (oldval != newval) { |
1311 | if (target != TargetStash || !m_stashfile.isEmpty()) { |
1312 | baseEval->valuesRef(variableName: dstvar) = newval; |
1313 | if (target == TargetSuper) { |
1314 | do { |
1315 | if (dstvar == QLatin1String("QMAKEPATH" )) { |
1316 | baseEval->m_qmakepath = newval.toQStringList(); |
1317 | baseEval->updateMkspecPaths(); |
1318 | } else if (dstvar == QLatin1String("QMAKEFEATURES" )) { |
1319 | baseEval->m_qmakefeatures = newval.toQStringList(); |
1320 | } else { |
1321 | break; |
1322 | } |
1323 | baseEval->updateFeaturePaths(); |
1324 | if (hostBuild == m_hostBuild) |
1325 | m_featureRoots = baseEval->m_featureRoots; |
1326 | } while (false); |
1327 | } |
1328 | } |
1329 | changed = true; |
1330 | } |
1331 | } while (false); |
1332 | if (hostBuild) |
1333 | break; |
1334 | } |
1335 | // We assume that whatever got the cached value to be what it is now will do so |
1336 | // the next time as well, so we just skip the persisting if nothing changed. |
1337 | if (!persist || !changed) |
1338 | return ReturnTrue; |
1339 | varstr = dstvar.toQString(); |
1340 | if (mode == CacheAdd) |
1341 | varstr += QLatin1String(" +=" ); |
1342 | else if (mode == CacheSub) |
1343 | varstr += QLatin1String(" -=" ); |
1344 | else |
1345 | varstr += QLatin1String(" =" ); |
1346 | if (diffval.count() == 1) { |
1347 | varstr += QLatin1Char(' '); |
1348 | varstr += quoteValue(val: diffval.at(i: 0)); |
1349 | } else if (!diffval.isEmpty()) { |
1350 | for (const ProString &vval : diffval) { |
1351 | varstr += QLatin1String(" \\\n " ); |
1352 | varstr += quoteValue(val: vval); |
1353 | } |
1354 | } |
1355 | varstr += QLatin1Char('\n'); |
1356 | } |
1357 | QString fn; |
1358 | QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact); |
1359 | if (target == TargetSuper) { |
1360 | if (m_superfile.isEmpty()) { |
1361 | m_superfile = QDir::cleanPath(path: m_outputDir + QLatin1String("/.qmake.super" )); |
1362 | printf(format: "Info: creating super cache file %s\n" , qPrintable(QDir::toNativeSeparators(m_superfile))); |
1363 | valuesRef(variableName: ProKey("_QMAKE_SUPER_CACHE_" )) << ProString(m_superfile); |
1364 | } |
1365 | fn = m_superfile; |
1366 | } else if (target == TargetCache) { |
1367 | if (m_cachefile.isEmpty()) { |
1368 | m_cachefile = QDir::cleanPath(path: m_outputDir + QLatin1String("/.qmake.cache" )); |
1369 | printf(format: "Info: creating cache file %s\n" , qPrintable(QDir::toNativeSeparators(m_cachefile))); |
1370 | valuesRef(variableName: ProKey("_QMAKE_CACHE_" )) << ProString(m_cachefile); |
1371 | // We could update m_{source,build}Root and m_featureRoots here, or even |
1372 | // "re-home" our rootEnv, but this doesn't sound too useful - if somebody |
1373 | // wanted qmake to find something in the build directory, he could have |
1374 | // done so "from the outside". |
1375 | // The sub-projects will find the new cache all by themselves. |
1376 | } |
1377 | fn = m_cachefile; |
1378 | } else { |
1379 | fn = m_stashfile; |
1380 | if (fn.isEmpty()) |
1381 | fn = QDir::cleanPath(path: m_outputDir + QLatin1String("/.qmake.stash" )); |
1382 | if (!m_vfs->exists(fn, flags)) { |
1383 | printf(format: "Info: creating stash file %s\n" , qPrintable(QDir::toNativeSeparators(fn))); |
1384 | valuesRef(variableName: ProKey("_QMAKE_STASH_" )) << ProString(fn); |
1385 | } |
1386 | } |
1387 | return writeFile(fL1S("cache " ), fn, mode: QIODevice::Append, flags, contents: varstr); |
1388 | } |
1389 | |
1390 | QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional( |
1391 | const QMakeInternal::QMakeBuiltin &adef, const ProKey &function, const ProStringList &args) |
1392 | { |
1393 | traceMsg(fmt: "calling built-in %s(%s)" , dbgKey(function), dbgSepStrList(args)); |
1394 | int asz = args.size() > 1 ? args.size() : args.at(i: 0).isEmpty() ? 0 : 1; |
1395 | if (asz < adef.minArgs || asz > adef.maxArgs) { |
1396 | evalError(msg: adef.usage); |
1397 | return ReturnFalse; |
1398 | } |
1399 | |
1400 | int func_t = adef.index; |
1401 | switch (func_t) { |
1402 | case T_DEFINED: { |
1403 | const ProKey &var = args.at(i: 0).toKey(); |
1404 | if (args.count() > 1) { |
1405 | if (args[1] == QLatin1String("test" )) { |
1406 | return returnBool(b: m_functionDefs.testFunctions.contains(akey: var)); |
1407 | } else if (args[1] == QLatin1String("replace" )) { |
1408 | return returnBool(b: m_functionDefs.replaceFunctions.contains(akey: var)); |
1409 | } else if (args[1] == QLatin1String("var" )) { |
1410 | ProValueMap::Iterator it; |
1411 | return returnBool(b: findValues(variableName: var, it: &it)); |
1412 | } |
1413 | evalError(fL1S("defined(function, type): unexpected type [%1]." ) |
1414 | .arg(a: args.at(i: 1).toQStringView())); |
1415 | return ReturnFalse; |
1416 | } |
1417 | return returnBool(b: m_functionDefs.replaceFunctions.contains(akey: var) |
1418 | || m_functionDefs.testFunctions.contains(akey: var)); |
1419 | } |
1420 | case T_EXPORT: { |
1421 | const ProKey &var = map(var: args.at(i: 0)); |
1422 | for (ProValueMapStack::iterator vmi = m_valuemapStack.end(); |
1423 | --vmi != m_valuemapStack.begin(); ) { |
1424 | ProValueMap::Iterator it = (*vmi).find(akey: var); |
1425 | if (it != (*vmi).end()) { |
1426 | if (it->constBegin() == statics.fakeValue.constBegin()) { |
1427 | // This is stupid, but qmake doesn't propagate deletions |
1428 | m_valuemapStack.front()[var] = ProStringList(); |
1429 | } else { |
1430 | m_valuemapStack.front()[var] = *it; |
1431 | } |
1432 | (*vmi).erase(it); |
1433 | while (--vmi != m_valuemapStack.begin()) |
1434 | (*vmi).remove(akey: var); |
1435 | break; |
1436 | } |
1437 | } |
1438 | return ReturnTrue; |
1439 | } |
1440 | case T_DISCARD_FROM: { |
1441 | if (m_valuemapStack.size() != 1) { |
1442 | evalError(fL1S("discard_from() cannot be called from functions." )); |
1443 | return ReturnFalse; |
1444 | } |
1445 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
1446 | QString fn = resolvePath(fileName: u1.str()); |
1447 | QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact); |
1448 | int pro = m_vfs->idForFileName(fn, flags: flags | QMakeVfs::VfsAccessedOnly); |
1449 | if (!pro) |
1450 | return ReturnFalse; |
1451 | ProValueMap &vmap = m_valuemapStack.front(); |
1452 | for (auto vit = vmap.begin(); vit != vmap.end(); ) { |
1453 | if (!vit->isEmpty()) { |
1454 | auto isFrom = [pro](const ProString &s) { |
1455 | return s.sourceFile() == pro; |
1456 | }; |
1457 | vit->erase(abegin: std::remove_if(first: vit->begin(), last: vit->end(), pred: isFrom), aend: vit->end()); |
1458 | if (vit->isEmpty()) { |
1459 | // When an initially non-empty variable becomes entirely empty, |
1460 | // undefine it altogether. |
1461 | vit = vmap.erase(it: vit); |
1462 | continue; |
1463 | } |
1464 | } |
1465 | ++vit; |
1466 | } |
1467 | for (auto fit = m_functionDefs.testFunctions.begin(); fit != m_functionDefs.testFunctions.end(); ) { |
1468 | if (fit->pro()->id() == pro) |
1469 | fit = m_functionDefs.testFunctions.erase(it: fit); |
1470 | else |
1471 | ++fit; |
1472 | } |
1473 | for (auto fit = m_functionDefs.replaceFunctions.begin(); fit != m_functionDefs.replaceFunctions.end(); ) { |
1474 | if (fit->pro()->id() == pro) |
1475 | fit = m_functionDefs.replaceFunctions.erase(it: fit); |
1476 | else |
1477 | ++fit; |
1478 | } |
1479 | ProStringList &iif = m_valuemapStack.front()[ProKey("QMAKE_INTERNAL_INCLUDED_FILES" )]; |
1480 | int idx = iif.indexOf(t: ProString(fn)); |
1481 | if (idx >= 0) |
1482 | iif.removeAt(idx); |
1483 | return ReturnTrue; |
1484 | } |
1485 | case T_INFILE: { |
1486 | ProValueMap vars; |
1487 | QString fn = filePathEnvArg0(args); |
1488 | VisitReturn ok = evaluateFileInto(fileName: fn, values: &vars, flags: LoadProOnly); |
1489 | if (ok != ReturnTrue) |
1490 | return ok; |
1491 | if (args.count() == 2) |
1492 | return returnBool(b: vars.contains(akey: map(var: args.at(i: 1)))); |
1493 | QRegExp regx; |
1494 | ProStringRoUser u1(args.at(i: 2), m_tmp1); |
1495 | const QString &qry = u1.str(); |
1496 | if (qry != QRegExp::escape(str: qry)) { |
1497 | QString copy = qry; |
1498 | copy.detach(); |
1499 | regx.setPattern(copy); |
1500 | } |
1501 | const auto strings = vars.value(akey: map(var: args.at(i: 1))); |
1502 | for (const ProString &s : strings) { |
1503 | if (s == qry) |
1504 | return ReturnTrue; |
1505 | if (!regx.isEmpty()) { |
1506 | ProStringRoUser u2(s, m_tmp[m_toggle ^= 1]); |
1507 | if (regx.exactMatch(str: u2.str())) |
1508 | return ReturnTrue; |
1509 | } |
1510 | } |
1511 | return ReturnFalse; |
1512 | } |
1513 | case T_REQUIRES: |
1514 | #ifdef PROEVALUATOR_FULL |
1515 | if (checkRequirements(args) == ReturnError) |
1516 | return ReturnError; |
1517 | #endif |
1518 | return ReturnFalse; // Another qmake breakage |
1519 | case T_EVAL: { |
1520 | VisitReturn ret = ReturnFalse; |
1521 | QString contents = args.join(sep: statics.field_sep); |
1522 | ProFile *pro = m_parser->parsedProBlock(contents: QStringRef(&contents), |
1523 | id: 0, name: m_current.pro->fileName(), line: m_current.line); |
1524 | if (m_cumulative || pro->isOk()) { |
1525 | m_locationStack.push(t: m_current); |
1526 | visitProBlock(pro, tokPtr: pro->tokPtr()); |
1527 | ret = ReturnTrue; // This return value is not too useful, but that's qmake |
1528 | m_current = m_locationStack.pop(); |
1529 | } |
1530 | pro->deref(); |
1531 | return ret; |
1532 | } |
1533 | case T_IF: { |
1534 | return evaluateConditional(cond: args.at(i: 0).toQStringRef(), |
1535 | where: m_current.pro->fileName(), line: m_current.line); |
1536 | } |
1537 | case T_CONFIG: { |
1538 | if (args.count() == 1) |
1539 | return returnBool(b: isActiveConfig(config: args.at(i: 0).toQStringRef())); |
1540 | const auto &mutuals = args.at(i: 1).toQStringRef().split(sep: QLatin1Char('|'), |
1541 | behavior: Qt::SkipEmptyParts); |
1542 | const ProStringList &configs = values(variableName: statics.strCONFIG); |
1543 | |
1544 | for (int i = configs.size() - 1; i >= 0; i--) { |
1545 | for (int mut = 0; mut < mutuals.count(); mut++) { |
1546 | if (configs[i].toQStringRef() == mutuals[mut].trimmed()) |
1547 | return returnBool(b: configs[i] == args[0]); |
1548 | } |
1549 | } |
1550 | return ReturnFalse; |
1551 | } |
1552 | case T_CONTAINS: { |
1553 | ProStringRoUser u1(args.at(i: 1), m_tmp1); |
1554 | const QString &qry = u1.str(); |
1555 | QRegExp regx; |
1556 | if (qry != QRegExp::escape(str: qry)) { |
1557 | QString copy = qry; |
1558 | copy.detach(); |
1559 | regx.setPattern(copy); |
1560 | } |
1561 | const ProStringList &l = values(variableName: map(var: args.at(i: 0))); |
1562 | if (args.count() == 2) { |
1563 | for (int i = 0; i < l.size(); ++i) { |
1564 | const ProString &val = l[i]; |
1565 | if (val == qry) |
1566 | return ReturnTrue; |
1567 | if (!regx.isEmpty()) { |
1568 | ProStringRoUser u2(val, m_tmp[m_toggle ^= 1]); |
1569 | if (regx.exactMatch(str: u2.str())) |
1570 | return ReturnTrue; |
1571 | } |
1572 | } |
1573 | } else { |
1574 | const auto mutuals = args.at(i: 2).toQStringRef().split(sep: QLatin1Char('|'), |
1575 | behavior: Qt::SkipEmptyParts); |
1576 | for (int i = l.size() - 1; i >= 0; i--) { |
1577 | const ProString &val = l[i]; |
1578 | for (int mut = 0; mut < mutuals.count(); mut++) { |
1579 | if (val.toQStringRef() == mutuals[mut].trimmed()) { |
1580 | if (val == qry) |
1581 | return ReturnTrue; |
1582 | if (!regx.isEmpty()) { |
1583 | ProStringRoUser u2(val, m_tmp[m_toggle ^= 1]); |
1584 | if (regx.exactMatch(str: u2.str())) |
1585 | return ReturnTrue; |
1586 | } |
1587 | return ReturnFalse; |
1588 | } |
1589 | } |
1590 | } |
1591 | } |
1592 | return ReturnFalse; |
1593 | } |
1594 | case T_COUNT: { |
1595 | int cnt = values(variableName: map(var: args.at(i: 0))).count(); |
1596 | int val = args.at(i: 1).toInt(); |
1597 | if (args.count() == 3) { |
1598 | const ProString &comp = args.at(i: 2); |
1599 | if (comp == QLatin1String(">" ) || comp == QLatin1String("greaterThan" )) { |
1600 | return returnBool(b: cnt > val); |
1601 | } else if (comp == QLatin1String(">=" )) { |
1602 | return returnBool(b: cnt >= val); |
1603 | } else if (comp == QLatin1String("<" ) || comp == QLatin1String("lessThan" )) { |
1604 | return returnBool(b: cnt < val); |
1605 | } else if (comp == QLatin1String("<=" )) { |
1606 | return returnBool(b: cnt <= val); |
1607 | } else if (comp == QLatin1String("equals" ) || comp == QLatin1String("isEqual" ) |
1608 | || comp == QLatin1String("=" ) || comp == QLatin1String("==" )) { |
1609 | // fallthrough |
1610 | } else { |
1611 | evalError(fL1S("Unexpected modifier to count(%2)." ).arg(a: comp.toQStringView())); |
1612 | return ReturnFalse; |
1613 | } |
1614 | } |
1615 | return returnBool(b: cnt == val); |
1616 | } |
1617 | case T_GREATERTHAN: |
1618 | case T_LESSTHAN: { |
1619 | const ProString &rhs = args.at(i: 1); |
1620 | const QString &lhs = values(variableName: map(var: args.at(i: 0))).join(sep: statics.field_sep); |
1621 | bool ok; |
1622 | int rhs_int = rhs.toInt(ok: &ok); |
1623 | if (ok) { // do integer compare |
1624 | int lhs_int = lhs.toInt(ok: &ok); |
1625 | if (ok) { |
1626 | if (func_t == T_GREATERTHAN) |
1627 | return returnBool(b: lhs_int > rhs_int); |
1628 | return returnBool(b: lhs_int < rhs_int); |
1629 | } |
1630 | } |
1631 | if (func_t == T_GREATERTHAN) |
1632 | return returnBool(b: lhs > rhs.toQStringRef()); |
1633 | return returnBool(b: lhs < rhs.toQStringRef()); |
1634 | } |
1635 | case T_EQUALS: |
1636 | return returnBool(b: values(variableName: map(var: args.at(i: 0))).join(sep: statics.field_sep) |
1637 | == args.at(i: 1).toQStringView()); |
1638 | case T_VERSION_AT_LEAST: |
1639 | case T_VERSION_AT_MOST: { |
1640 | const QVersionNumber lvn = QVersionNumber::fromString(string: values(variableName: args.at(i: 0).toKey()).join(sep: QLatin1Char('.'))); |
1641 | const QVersionNumber rvn = QVersionNumber::fromString(string: args.at(i: 1).toQStringView()); |
1642 | if (func_t == T_VERSION_AT_LEAST) |
1643 | return returnBool(b: lvn >= rvn); |
1644 | return returnBool(b: lvn <= rvn); |
1645 | } |
1646 | case T_CLEAR: { |
1647 | ProValueMap *hsh; |
1648 | ProValueMap::Iterator it; |
1649 | const ProKey &var = map(var: args.at(i: 0)); |
1650 | if (!(hsh = findValues(variableName: var, it: &it))) |
1651 | return ReturnFalse; |
1652 | if (hsh == &m_valuemapStack.top()) |
1653 | it->clear(); |
1654 | else |
1655 | m_valuemapStack.top()[var].clear(); |
1656 | return ReturnTrue; |
1657 | } |
1658 | case T_UNSET: { |
1659 | ProValueMap *hsh; |
1660 | ProValueMap::Iterator it; |
1661 | const ProKey &var = map(var: args.at(i: 0)); |
1662 | if (!(hsh = findValues(variableName: var, it: &it))) |
1663 | return ReturnFalse; |
1664 | if (m_valuemapStack.size() == 1) |
1665 | hsh->erase(it); |
1666 | else if (hsh == &m_valuemapStack.top()) |
1667 | *it = statics.fakeValue; |
1668 | else |
1669 | m_valuemapStack.top()[var] = statics.fakeValue; |
1670 | return ReturnTrue; |
1671 | } |
1672 | #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) |
1673 | case T_PARSE_JSON: { |
1674 | QByteArray json = values(variableName: args.at(i: 0).toKey()).join(sep: QLatin1Char(' ')).toUtf8(); |
1675 | ProStringRoUser u1(args.at(i: 1), m_tmp2); |
1676 | QString parseInto = u1.str(); |
1677 | return parseJsonInto(json, into: parseInto, value: &m_valuemapStack.top()); |
1678 | } |
1679 | #endif |
1680 | case T_INCLUDE: { |
1681 | QString parseInto; |
1682 | LoadFlags flags; |
1683 | if (m_cumulative) |
1684 | flags = LoadSilent; |
1685 | if (args.count() >= 2) { |
1686 | if (!args.at(i: 1).isEmpty()) |
1687 | parseInto = args.at(i: 1) + QLatin1Char('.'); |
1688 | if (args.count() >= 3 && isTrue(str: args.at(i: 2))) |
1689 | flags = LoadSilent; |
1690 | } |
1691 | QString fn = filePathEnvArg0(args); |
1692 | VisitReturn ok; |
1693 | if (parseInto.isEmpty()) { |
1694 | ok = evaluateFileChecked(fileName: fn, type: QMakeHandler::EvalIncludeFile, flags: LoadProOnly | flags); |
1695 | } else { |
1696 | ProValueMap symbols; |
1697 | if ((ok = evaluateFileInto(fileName: fn, values: &symbols, flags: LoadAll | flags)) == ReturnTrue) { |
1698 | ProValueMap newMap; |
1699 | for (ProValueMap::ConstIterator |
1700 | it = m_valuemapStack.top().constBegin(), |
1701 | end = m_valuemapStack.top().constEnd(); |
1702 | it != end; ++it) { |
1703 | const ProString &ky = it.key(); |
1704 | if (!ky.startsWith(sub: parseInto)) |
1705 | newMap[it.key()] = it.value(); |
1706 | } |
1707 | for (ProValueMap::ConstIterator it = symbols.constBegin(); |
1708 | it != symbols.constEnd(); ++it) { |
1709 | if (!it.key().startsWith(c: QLatin1Char('.'))) |
1710 | newMap.insert(akey: ProKey(parseInto + it.key()), avalue: it.value()); |
1711 | } |
1712 | m_valuemapStack.top() = newMap; |
1713 | } |
1714 | } |
1715 | if (ok == ReturnFalse && (flags & LoadSilent)) |
1716 | ok = ReturnTrue; |
1717 | return ok; |
1718 | } |
1719 | case T_LOAD: { |
1720 | bool ignore_error = (args.count() == 2 && isTrue(str: args.at(i: 1))); |
1721 | VisitReturn ok = evaluateFeatureFile(fileName: m_option->expandEnvVars(str: args.at(i: 0).toQString()), |
1722 | silent: ignore_error); |
1723 | if (ok == ReturnFalse && ignore_error) |
1724 | ok = ReturnTrue; |
1725 | return ok; |
1726 | } |
1727 | case T_DEBUG: { |
1728 | #ifdef PROEVALUATOR_DEBUG |
1729 | int level = args.at(i: 0).toInt(); |
1730 | if (level <= m_debugLevel) { |
1731 | ProStringRoUser u1(args.at(i: 1), m_tmp1); |
1732 | const QString &msg = m_option->expandEnvVars(str: u1.str()); |
1733 | debugMsg(level, fmt: "Project DEBUG: %s" , qPrintable(msg)); |
1734 | } |
1735 | #endif |
1736 | return ReturnTrue; |
1737 | } |
1738 | case T_LOG: |
1739 | case T_ERROR: |
1740 | case T_WARNING: |
1741 | case T_MESSAGE: { |
1742 | ProStringRoUser u1(args.at(i: 0), m_tmp1); |
1743 | const QString &msg = m_option->expandEnvVars(str: u1.str()); |
1744 | if (!m_skipLevel) { |
1745 | if (func_t == T_LOG) { |
1746 | #ifdef PROEVALUATOR_FULL |
1747 | fputs(msg.toLatin1().constData(), stderr); |
1748 | #endif |
1749 | } else if (!msg.isEmpty() || func_t != T_ERROR) { |
1750 | ProStringRoUser u2(function, m_tmp2); |
1751 | m_handler->fileMessage( |
1752 | type: (func_t == T_ERROR ? QMakeHandler::ErrorMessage : |
1753 | func_t == T_WARNING ? QMakeHandler::WarningMessage : |
1754 | QMakeHandler::InfoMessage) |
1755 | | (m_cumulative ? QMakeHandler::CumulativeEvalMessage : 0), |
1756 | fL1S("Project %1: %2" ).arg(args: u2.str().toUpper(), args: msg)); |
1757 | } |
1758 | } |
1759 | return (func_t == T_ERROR && !m_cumulative) ? ReturnError : ReturnTrue; |
1760 | } |
1761 | case T_SYSTEM: { |
1762 | #ifdef PROEVALUATOR_FULL |
1763 | if (m_cumulative) // Anything else would be insanity |
1764 | return ReturnFalse; |
1765 | #if QT_CONFIG(process) |
1766 | QProcess proc; |
1767 | proc.setProcessChannelMode(QProcess::ForwardedChannels); |
1768 | runProcess(&proc, args.at(0).toQString()); |
1769 | return returnBool(proc.exitStatus() == QProcess::NormalExit && proc.exitCode() == 0); |
1770 | #else |
1771 | int ec = system((QLatin1String("cd " ) |
1772 | + IoUtils::shellQuote(QDir::toNativeSeparators(currentDirectory())) |
1773 | + QLatin1String(" && " ) + args.at(0)).toLocal8Bit().constData()); |
1774 | # ifdef Q_OS_UNIX |
1775 | if (ec != -1 && WIFSIGNALED(ec) && (WTERMSIG(ec) == SIGQUIT || WTERMSIG(ec) == SIGINT)) |
1776 | raise(WTERMSIG(ec)); |
1777 | # endif |
1778 | return returnBool(ec == 0); |
1779 | #endif |
1780 | #else |
1781 | return ReturnTrue; |
1782 | #endif |
1783 | } |
1784 | case T_ISEMPTY: { |
1785 | return returnBool(b: values(variableName: map(var: args.at(i: 0))).isEmpty()); |
1786 | } |
1787 | case T_EXISTS: { |
1788 | QString file = filePathEnvArg0(args); |
1789 | // Don't use VFS here: |
1790 | // - it supports neither listing nor even directories |
1791 | // - it's unlikely that somebody would test for files they created themselves |
1792 | if (IoUtils::exists(fileName: file)) |
1793 | return ReturnTrue; |
1794 | int slsh = file.lastIndexOf(c: QLatin1Char('/')); |
1795 | QString fn = file.mid(position: slsh+1); |
1796 | if (fn.contains(c: QLatin1Char('*')) || fn.contains(c: QLatin1Char('?'))) { |
1797 | QString dirstr = file.left(n: slsh+1); |
1798 | dirstr.detach(); |
1799 | if (!QDir(dirstr).entryList(nameFilters: QStringList(fn)).isEmpty()) |
1800 | return ReturnTrue; |
1801 | } |
1802 | |
1803 | return ReturnFalse; |
1804 | } |
1805 | case T_MKPATH: { |
1806 | #ifdef PROEVALUATOR_FULL |
1807 | QString fn = filePathArg0(args); |
1808 | if (!QDir::current().mkpath(fn)) { |
1809 | evalError(fL1S("Cannot create directory %1." ).arg(QDir::toNativeSeparators(fn))); |
1810 | return ReturnFalse; |
1811 | } |
1812 | #endif |
1813 | return ReturnTrue; |
1814 | } |
1815 | case T_WRITE_FILE: { |
1816 | QIODevice::OpenMode mode = QIODevice::Truncate; |
1817 | QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact); |
1818 | QString contents; |
1819 | if (args.count() >= 2) { |
1820 | const ProStringList &vals = values(variableName: args.at(i: 1).toKey()); |
1821 | if (!vals.isEmpty()) |
1822 | contents = vals.join(sep: QLatin1Char('\n')) + QLatin1Char('\n'); |
1823 | if (args.count() >= 3) { |
1824 | const auto opts = split_value_list(vals: args.at(i: 2).toQStringRef()); |
1825 | for (const ProString &opt : opts) { |
1826 | if (opt == QLatin1String("append" )) { |
1827 | mode = QIODevice::Append; |
1828 | } else if (opt == QLatin1String("exe" )) { |
1829 | flags |= QMakeVfs::VfsExecutable; |
1830 | } else { |
1831 | evalError(fL1S("write_file(): invalid flag %1." ).arg(a: opt.toQStringView())); |
1832 | return ReturnFalse; |
1833 | } |
1834 | } |
1835 | } |
1836 | } |
1837 | QString path = filePathArg0(args); |
1838 | return writeFile(ctx: QString(), fn: path, mode, flags, contents); |
1839 | } |
1840 | case T_TOUCH: { |
1841 | #ifdef PROEVALUATOR_FULL |
1842 | ProStringRoUser u1(args.at(0), m_tmp1); |
1843 | ProStringRoUser u2(args.at(1), m_tmp2); |
1844 | const QString &tfn = resolvePath(u1.str()); |
1845 | const QString &rfn = resolvePath(u2.str()); |
1846 | QString error; |
1847 | if (!IoUtils::touchFile(tfn, rfn, &error)) { |
1848 | evalError(error); |
1849 | return ReturnFalse; |
1850 | } |
1851 | #endif |
1852 | return ReturnTrue; |
1853 | } |
1854 | case T_CACHE: |
1855 | if (args.count() > 3) { |
1856 | evalError(fL1S("cache(var, [set|add|sub] [transient] [super|stash], [srcvar]) requires one to three arguments." )); |
1857 | return ReturnFalse; |
1858 | } |
1859 | return testFunc_cache(args); |
1860 | case T_RELOAD_PROPERTIES: |
1861 | #ifdef QT_BUILD_QMAKE |
1862 | m_option->reloadProperties(); |
1863 | #endif |
1864 | return ReturnTrue; |
1865 | default: |
1866 | evalError(fL1S("Function '%1' is not implemented." ).arg(a: function.toQStringView())); |
1867 | return ReturnFalse; |
1868 | } |
1869 | } |
1870 | |
1871 | QT_END_NAMESPACE |
1872 | |