Debian Codegraph @

qmake/library/qmakeevaluator.cpp

raw
1 // Copyright (C) 2016 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 "qmakeevaluator.h"
5 #include "qmakeevaluator_p.h"
6
7 #include "qmakeglobals.h"
8 #include "qmakeparser.h"
9 #include "qmakevfs.h"
10 #include "ioutils.h"
11
12 #include <qbytearray.h>
13 #include <qdatetime.h>
14 #include <qdebug.h>
15 #include <qdir.h>
16 #include <qfile.h>
17 #include <qfileinfo.h>
18 #include <qlist.h>
19 #include <qregularexpression.h>
20 #include <qset.h>
21 #include <qstack.h>
22 #include <qstring.h>
23 #include <qstringlist.h>
24 #ifdef PROEVALUATOR_THREAD_SAFE
25 # include <qthreadpool.h>
26 #endif
27
28 #ifdef Q_OS_UNIX
29 #include <unistd.h>
30 #include <sys/utsname.h>
31 # ifdef Q_OS_BSD4
32 # include <sys/sysctl.h>
33 # endif
34 #else
35 #include <qt_windows.h>
36 #endif
37 #include <stdio.h>
38 #include <stdlib.h>
39
40 using namespace QMakeInternal;
41
42 QT_BEGIN_NAMESPACE
43
44 #define fL1S(s) QString::fromLatin1(s)
45
46 // we can't use QThread in qmake
47 // this function is a merger of QThread::idealThreadCount from qthread_win.cpp and qthread_unix.cpp
48 static int idealThreadCount()
49 {
50 #ifdef PROEVALUATOR_THREAD_SAFE
51 return QThread::idealThreadCount();
52 #elif defined(Q_OS_WIN)
53 SYSTEM_INFO sysinfo;
54 GetSystemInfo(&sysinfo);
55 return sysinfo.dwNumberOfProcessors;
56 #else
57 // there are a couple more definitions in the Unix QThread::idealThreadCount, but
58 // we don't need them all here
59 int cores = 1;
60 # if defined(Q_OS_BSD4)
61 // FreeBSD, OpenBSD, NetBSD, BSD/OS, OS X
62 size_t len = sizeof(cores);
63 int mib[2];
64 mib[0] = CTL_HW;
65 mib[1] = HW_NCPU;
66 if (sysctl(mib, 2, &cores, &len, NULL, 0) != 0) {
67 perror("sysctl");
68 }
69 # elif defined(_SC_NPROCESSORS_ONLN)
70 // the rest: Linux, Solaris, AIX, Tru64
71 cores = (int)sysconf(_SC_NPROCESSORS_ONLN);
72 if (cores == -1)
73 return 1;
74 # endif
75 return cores;
76 #endif
77 }
78
79
80 QMakeBaseKey::QMakeBaseKey(const QString &_root, const QString &_stash, bool _hostBuild)
81 : root(_root), stash(_stash), hostBuild(_hostBuild)
82 {
83 }
84
85 size_t qHash(const QMakeBaseKey &key)
86 {
87 return qHash(key.root) ^ qHash(key.stash) ^ (uint)key.hostBuild;
88 }
89
90 bool operator==(const QMakeBaseKey &one, const QMakeBaseKey &two)
91 {
92 return one.root == two.root && one.stash == two.stash && one.hostBuild == two.hostBuild;
93 }
94
95 QMakeBaseEnv::QMakeBaseEnv()
96 : evaluator(nullptr)
97 {
98 #ifdef PROEVALUATOR_THREAD_SAFE
99 inProgress = false;
100 #endif
101 }
102
103 QMakeBaseEnv::~QMakeBaseEnv()
104 {
105 delete evaluator;
106 }
107
108 namespace QMakeInternal {
109 QMakeStatics statics;
110 }
111
112 void QMakeEvaluator::initStatics()
113 {
114 if (!statics.field_sep.isNull())
115 return;
116
117 statics.field_sep = QLatin1String(" ");
118 statics.strtrue = QLatin1String("true");
119 statics.strfalse = QLatin1String("false");
120 statics.strCONFIG = ProKey("CONFIG");
121 statics.strARGS = ProKey("ARGS");
122 statics.strARGC = ProKey("ARGC");
123 statics.strDot = QLatin1String(".");
124 statics.strDotDot = QLatin1String("..");
125 statics.strever = QLatin1String("ever");
126 statics.strforever = QLatin1String("forever");
127 statics.strhost_build = QLatin1String("host_build");
128 statics.strTEMPLATE = ProKey("TEMPLATE");
129 statics.strQMAKE_PLATFORM = ProKey("QMAKE_PLATFORM");
130 statics.strQMAKE_DIR_SEP = ProKey("QMAKE_DIR_SEP");
131 statics.strQMAKESPEC = ProKey("QMAKESPEC");
132 #ifdef PROEVALUATOR_FULL
133 statics.strREQUIRES = ProKey("REQUIRES");
134 #endif
135
136 statics.fakeValue = ProStringList(ProString("_FAKE_")); // It has to have a unique begin() value
137
138 initFunctionStatics();
139
140 static const struct {
141 const char * const oldname, * const newname;
142 } mapInits[] = {
143 { "INTERFACES", "FORMS" },
144 { "QMAKE_POST_BUILD", "QMAKE_POST_LINK" },
145 { "TARGETDEPS", "POST_TARGETDEPS" },
146 { "LIBPATH", "QMAKE_LIBDIR" },
147 { "QMAKE_EXT_MOC", "QMAKE_EXT_CPP_MOC" },
148 { "QMAKE_MOD_MOC", "QMAKE_H_MOD_MOC" },
149 { "QMAKE_LFLAGS_SHAPP", "QMAKE_LFLAGS_APP" },
150 { "PRECOMPH", "PRECOMPILED_HEADER" },
151 { "PRECOMPCPP", "PRECOMPILED_SOURCE" },
152 { "INCPATH", "INCLUDEPATH" },
153 { "QMAKE_EXTRA_WIN_COMPILERS", "QMAKE_EXTRA_COMPILERS" },
154 { "QMAKE_EXTRA_UNIX_COMPILERS", "QMAKE_EXTRA_COMPILERS" },
155 { "QMAKE_EXTRA_WIN_TARGETS", "QMAKE_EXTRA_TARGETS" },
156 { "QMAKE_EXTRA_UNIX_TARGETS", "QMAKE_EXTRA_TARGETS" },
157 { "QMAKE_EXTRA_UNIX_INCLUDES", "QMAKE_EXTRA_INCLUDES" },
158 { "QMAKE_EXTRA_UNIX_VARIABLES", "QMAKE_EXTRA_VARIABLES" },
159 { "QMAKE_RPATH", "QMAKE_LFLAGS_RPATH" },
160 { "QMAKE_FRAMEWORKDIR", "QMAKE_FRAMEWORKPATH" },
161 { "QMAKE_FRAMEWORKDIR_FLAGS", "QMAKE_FRAMEWORKPATH_FLAGS" },
162 { "IN_PWD", "PWD" },
163 { "DEPLOYMENT", "INSTALLS" }
164 };
165 statics.varMap.reserve((int)(sizeof(mapInits)/sizeof(mapInits[0])));
166 for (unsigned i = 0; i < sizeof(mapInits)/sizeof(mapInits[0]); ++i)
167 statics.varMap.insert(ProKey(mapInits[i].oldname), ProKey(mapInits[i].newname));
168 }
169
170 const ProKey &QMakeEvaluator::map(const ProKey &var)
171 {
172 QHash<ProKey, ProKey>::ConstIterator it = statics.varMap.constFind(var);
173 if (it == statics.varMap.constEnd())
174 return var;
175 deprecationWarning(fL1S("Variable %1 is deprecated; use %2 instead.")
176 .arg(var.toQString(), it.value().toQString()));
177 return it.value();
178 }
179
180
181 QMakeEvaluator::QMakeEvaluator(QMakeGlobals *option, QMakeParser *parser, QMakeVfs *vfs,
182 QMakeHandler *handler)
183 :
184 #ifdef PROEVALUATOR_DEBUG
185 m_debugLevel(option->debugLevel),
186 #endif
187 m_option(option), m_parser(parser), m_handler(handler), m_vfs(vfs)
188 {
189 // So that single-threaded apps don't have to call initialize() for now.
190 initStatics();
191
192 // Configuration, more or less
193 m_caller = nullptr;
194 #ifdef PROEVALUATOR_CUMULATIVE
195 m_cumulative = false;
196 #endif
197 m_hostBuild = false;
198
199 // Evaluator state
200 #ifdef PROEVALUATOR_CUMULATIVE
201 m_skipLevel = 0;
202 #endif
203 m_listCount = 0;
204 m_toggle = 0;
205 m_valuemapStack.push(ProValueMap());
206 m_valuemapInited = false;
207 }
208
209 QMakeEvaluator::~QMakeEvaluator()
210 {
211 }
212
213 void QMakeEvaluator::initFrom(const QMakeEvaluator *other)
214 {
215 Q_ASSERT_X(other, "QMakeEvaluator::visitProFile", "Project not prepared");
216 m_functionDefs = other->m_functionDefs;
217 m_valuemapStack = other->m_valuemapStack;
218 m_valuemapInited = true;
219 m_qmakespec = other->m_qmakespec;
220 m_qmakespecName = other->m_qmakespecName;
221 m_mkspecPaths = other->m_mkspecPaths;
222 m_featureRoots = other->m_featureRoots;
223 m_dirSep = other->m_dirSep;
224 }
225
226 //////// Evaluator tools /////////
227
228 uint QMakeEvaluator::getBlockLen(const ushort *&tokPtr)
229 {
230 uint len = *tokPtr++;
231 len |= (uint)*tokPtr++ << 16;
232 return len;
233 }
234
235 void QMakeEvaluator::skipStr(const ushort *&tokPtr)
236 {
237 uint len = *tokPtr++;
238 tokPtr += len;
239 }
240
241 void QMakeEvaluator::skipHashStr(const ushort *&tokPtr)
242 {
243 tokPtr += 2;
244 uint len = *tokPtr++;
245 tokPtr += len;
246 }
247
248 // FIXME: this should not build new strings for direct sections.
249 // Note that the E_SPRINTF and E_LIST implementations rely on the deep copy.
250 ProStringList QMakeEvaluator::split_value_list(QStringView vals, int source)
251 {
252 QString build;
253 ProStringList ret;
254
255 if (!source)
256 source = currentFileId();
257
258 const QChar *vals_data = vals.data();
259 const int vals_len = vals.size();
260 char16_t quote = 0;
261 bool hadWord = false;
262 for (int x = 0; x < vals_len; x++) {
263 char16_t unicode = vals_data[x].unicode();
264 if (unicode == quote) {
265 quote = 0;
266 hadWord = true;
267 build += QChar(unicode);
268 continue;
269 }
270 switch (unicode) {
271 case '"':
272 case '\'':
273 if (!quote)
274 quote = unicode;
275 // FIXME: this is inconsistent with the "there are no empty strings" dogma.
276 hadWord = true;
277 break;
278 case ' ':
279 case '\t':
280 if (!quote) {
281 if (hadWord) {
282 ret << ProString(build).setSource(source);
283 build.clear();
284 hadWord = false;
285 }
286 continue;
287 }
288 break;
289 case '\\':
290 if (x + 1 != vals_len) {
291 char16_t next = vals_data[++x].unicode();
292 if (next == '\'' || next == '"' || next == '\\') {
293 build += QChar(unicode);
294 unicode = next;
295 } else {
296 --x;
297 }
298 }
299 Q_FALLTHROUGH();
300 default:
301 hadWord = true;
302 break;
303 }
304 build += QChar(unicode);
305 }
306 if (hadWord)
307 ret << ProString(build).setSource(source);
308 return ret;
309 }
310
311 static void replaceInList(ProStringList *varlist,
312 const QRegularExpression &regexp, const QString &replace, bool global, QString &tmp)
313 {
314 for (ProStringList::Iterator varit = varlist->begin(); varit != varlist->end(); ) {
315 ProStringRoUser u1(*varit, tmp);
316 QString val = u1.str();
317 QString copy = val; // Force detach and have a reference value
318 val.replace(regexp, replace);
319 if (!val.isSharedWith(copy) && val != copy) {
320 if (val.isEmpty()) {
321 varit = varlist->erase(varit);
322 } else {
323 (*varit).setValue(val);
324 ++varit;
325 }
326 if (!global)
327 break;
328 } else {
329 ++varit;
330 }
331 }
332 }
333
334 //////// Evaluator /////////
335
336 static ALWAYS_INLINE void addStr(
337 const ProString &str, ProStringList *ret, bool &pending, bool joined)
338 {
339 if (joined) {
340 ret->last().append(str, &pending);
341 } else {
342 if (!pending) {
343 pending = true;
344 *ret << str;
345 } else {
346 ret->last().append(str);
347 }
348 }
349 }
350
351 static ALWAYS_INLINE void addStrList(
352 const ProStringList &list, ushort tok, ProStringList *ret, bool &pending, bool joined)
353 {
354 if (!list.isEmpty()) {
355 if (joined) {
356 ret->last().append(list, &pending, !(tok & TokQuoted));
357 } else {
358 if (tok & TokQuoted) {
359 if (!pending) {
360 pending = true;
361 *ret << ProString();
362 }
363 ret->last().append(list);
364 } else {
365 if (!pending) {
366 // Another qmake bizzarity: if nothing is pending and the
367 // first element is empty, it will be eaten
368 if (!list.at(0).isEmpty()) {
369 // The common case
370 pending = true;
371 *ret += list;
372 return;
373 }
374 } else {
375 ret->last().append(list.at(0));
376 }
377 // This is somewhat slow, but a corner case
378 for (int j = 1; j < list.size(); ++j) {
379 pending = true;
380 *ret << list.at(j);
381 }
382 }
383 }
384 }
385 }
386
387 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateExpression(
388 const ushort *&tokPtr, ProStringList *ret, bool joined)
389 {
390 debugMsg(2, joined ? "evaluating joined expression" : "evaluating expression");
391 ProFile *pro = m_current.pro;
392 if (joined)
393 *ret << ProString();
394 bool pending = false;
395 forever {
396 ushort tok = *tokPtr++;
397 if (tok & TokNewStr) {
398 debugMsg(2, "new string");
399 pending = false;
400 }
401 ushort maskedTok = tok & TokMask;
402 switch (maskedTok) {
403 case TokLine:
404 m_current.line = *tokPtr++;
405 break;
406 case TokLiteral: {
407 const ProString &val = pro->getStr(tokPtr);
408 debugMsg(2, "literal %s", dbgStr(val));
409 addStr(val, ret, pending, joined);
410 break; }
411 case TokHashLiteral: {
412 const ProKey &val = pro->getHashStr(tokPtr);
413 debugMsg(2, "hashed literal %s", dbgStr(val.toString()));
414 addStr(val, ret, pending, joined);
415 break; }
416 case TokVariable: {
417 const ProKey &var = pro->getHashStr(tokPtr);
418 const ProStringList &val = values(map(var));
419 debugMsg(2, "variable %s => %s", dbgKey(var), dbgStrList(val));
420 addStrList(val, tok, ret, pending, joined);
421 break; }
422 case TokProperty: {
423 const ProKey &var = pro->getHashStr(tokPtr);
424 const ProString &val = propertyValue(var);
425 debugMsg(2, "property %s => %s", dbgKey(var), dbgStr(val));
426 addStr(val, ret, pending, joined);
427 break; }
428 case TokEnvVar: {
429 const ProString &var = pro->getStr(tokPtr);
430 const ProString &val = ProString(m_option->getEnv(var.toQString()));
431 debugMsg(2, "env var %s => %s", dbgStr(var), dbgStr(val));
432 addStr(val, ret, pending, joined);
433 break; }
434 case TokFuncName: {
435 const ProKey &func = pro->getHashStr(tokPtr);
436 debugMsg(2, "function %s", dbgKey(func));
437 ProStringList val;
438 if (evaluateExpandFunction(func, tokPtr, &val) == ReturnError)
439 return ReturnError;
440 addStrList(val, tok, ret, pending, joined);
441 break; }
442 default:
443 debugMsg(2, "evaluated expression => %s", dbgStrList(*ret));
444 tokPtr--;
445 return ReturnTrue;
446 }
447 }
448 }
449
450 void QMakeEvaluator::skipExpression(const ushort *&pTokPtr)
451 {
452 const ushort *tokPtr = pTokPtr;
453 forever {
454 ushort tok = *tokPtr++;
455 switch (tok) {
456 case TokLine:
457 m_current.line = *tokPtr++;
458 break;
459 case TokValueTerminator:
460 case TokFuncTerminator:
461 pTokPtr = tokPtr;
462 return;
463 case TokArgSeparator:
464 break;
465 default:
466 switch (tok & TokMask) {
467 case TokLiteral:
468 case TokEnvVar:
469 skipStr(tokPtr);
470 break;
471 case TokHashLiteral:
472 case TokVariable:
473 case TokProperty:
474 skipHashStr(tokPtr);
475 break;
476 case TokFuncName:
477 skipHashStr(tokPtr);
478 pTokPtr = tokPtr;
479 skipExpression(pTokPtr);
480 tokPtr = pTokPtr;
481 break;
482 default:
483 Q_ASSERT_X(false, "skipExpression", "Unrecognized token");
484 break;
485 }
486 }
487 }
488 }
489
490 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProBlock(
491 ProFile *pro, const ushort *tokPtr)
492 {
493 m_current.pro = pro;
494 m_current.line = 0;
495 return visitProBlock(tokPtr);
496 }
497
498 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProBlock(
499 const ushort *tokPtr)
500 {
501 traceMsg("entering block");
502 ProStringList curr;
503 ProFile *pro = m_current.pro;
504 bool okey = true, or_op = false, invert = false;
505 uint blockLen;
506 while (ushort tok = *tokPtr++) {
507 VisitReturn ret;
508 switch (tok) {
509 case TokLine:
510 m_current.line = *tokPtr++;
511 continue;
512 case TokAssign:
513 case TokAppend:
514 case TokAppendUnique:
515 case TokRemove:
516 case TokReplace:
517 ret = visitProVariable(tok, curr, tokPtr);
518 if (ret == ReturnError)
519 break;
520 curr.clear();
521 continue;
522 case TokBranch:
523 blockLen = getBlockLen(tokPtr);
524 if (m_cumulative) {
525 #ifdef PROEVALUATOR_CUMULATIVE
526 if (!okey)
527 m_skipLevel++;
528 ret = blockLen ? visitProBlock(tokPtr) : ReturnTrue;
529 tokPtr += blockLen;
530 blockLen = getBlockLen(tokPtr);
531 if (!okey)
532 m_skipLevel--;
533 else
534 m_skipLevel++;
535 if ((ret == ReturnTrue || ret == ReturnFalse) && blockLen)
536 ret = visitProBlock(tokPtr);
537 if (okey)
538 m_skipLevel--;
539 #endif
540 } else {
541 if (okey) {
542 traceMsg("taking 'then' branch");
543 ret = blockLen ? visitProBlock(tokPtr) : ReturnTrue;
544 traceMsg("finished 'then' branch");
545 }
546 tokPtr += blockLen;
547 blockLen = getBlockLen(tokPtr);
548 if (!okey) {
549 traceMsg("taking 'else' branch");
550 ret = blockLen ? visitProBlock(tokPtr) : ReturnTrue;
551 traceMsg("finished 'else' branch");
552 }
553 }
554 tokPtr += blockLen;
555 okey = true, or_op = false; // force next evaluation
556 break;
557 case TokForLoop:
558 if (m_cumulative || okey != or_op) {
559 const ProKey &variable = pro->getHashStr(tokPtr);
560 uint exprLen = getBlockLen(tokPtr);
561 const ushort *exprPtr = tokPtr;
562 tokPtr += exprLen;
563 blockLen = getBlockLen(tokPtr);
564 ret = visitProLoop(variable, exprPtr, tokPtr);
565 } else {
566 skipHashStr(tokPtr);
567 uint exprLen = getBlockLen(tokPtr);
568 tokPtr += exprLen;
569 blockLen = getBlockLen(tokPtr);
570 traceMsg("skipped loop");
571 ret = ReturnTrue;
572 }
573 tokPtr += blockLen;
574 okey = true, or_op = false; // force next evaluation
575 break;
576 case TokBypassNesting:
577 blockLen = getBlockLen(tokPtr);
578 if ((m_cumulative || okey != or_op) && blockLen) {
579 ProValueMapStack savedValuemapStack = std::move(m_valuemapStack);
580 m_valuemapStack.clear();
581 m_valuemapStack.splice(m_valuemapStack.end(),
582 savedValuemapStack, savedValuemapStack.begin());
583 traceMsg("visiting nesting-bypassing block");
584 ret = visitProBlock(tokPtr);
585 traceMsg("visited nesting-bypassing block");
586 savedValuemapStack.splice(savedValuemapStack.begin(),
587 m_valuemapStack, m_valuemapStack.begin());
588 m_valuemapStack = std::move(savedValuemapStack);
589 } else {
590 traceMsg("skipped nesting-bypassing block");
591 ret = ReturnTrue;
592 }
593 tokPtr += blockLen;
594 okey = true, or_op = false; // force next evaluation
595 break;
596 case TokTestDef:
597 case TokReplaceDef:
598 if (m_cumulative || okey != or_op) {
599 const ProKey &name = pro->getHashStr(tokPtr);
600 blockLen = getBlockLen(tokPtr);
601 visitProFunctionDef(tok, name, tokPtr);
602 traceMsg("defined %s function %s",
603 tok == TokTestDef ? "test" : "replace", dbgKey(name));
604 } else {
605 traceMsg("skipped function definition");
606 skipHashStr(tokPtr);
607 blockLen = getBlockLen(tokPtr);
608 }
609 tokPtr += blockLen;
610 okey = true, or_op = false; // force next evaluation
611 continue;
612 case TokNot:
613 traceMsg("NOT");
614 invert ^= true;
615 continue;
616 case TokAnd:
617 traceMsg("AND");
618 or_op = false;
619 continue;
620 case TokOr:
621 traceMsg("OR");
622 or_op = true;
623 continue;
624 case TokCondition:
625 if (!m_skipLevel && okey != or_op) {
626 if (curr.size() != 1) {
627 if (!m_cumulative || !curr.isEmpty())
628 evalError(fL1S("Conditional must expand to exactly one word."));
629 okey = false;
630 } else {
631 okey = isActiveConfig(curr.at(0).toQStringView(), true);
632 traceMsg("condition %s is %s", dbgStr(curr.at(0)), dbgBool(okey));
633 okey ^= invert;
634 }
635 } else {
636 traceMsg("skipped condition %s", curr.size() == 1 ? dbgStr(curr.at(0)) : "<invalid>");
637 }
638 or_op = !okey; // tentatively force next evaluation
639 invert = false;
640 curr.clear();
641 continue;
642 case TokTestCall:
643 if (!m_skipLevel && okey != or_op) {
644 if (curr.size() != 1) {
645 if (!m_cumulative || !curr.isEmpty())
646 evalError(fL1S("Test name must expand to exactly one word."));
647 skipExpression(tokPtr);
648 okey = false;
649 } else {
650 traceMsg("evaluating test function %s", dbgStr(curr.at(0)));
651 ret = evaluateConditionalFunction(curr.at(0).toKey(), tokPtr);
652 switch (ret) {
653 case ReturnTrue: okey = true; break;
654 case ReturnFalse: okey = false; break;
655 default:
656 traceMsg("aborting block, function status: %s", dbgReturn(ret));
657 return ret;
658 }
659 traceMsg("test function returned %s", dbgBool(okey));
660 okey ^= invert;
661 }
662 } else if (m_cumulative) {
663 #ifdef PROEVALUATOR_CUMULATIVE
664 m_skipLevel++;
665 if (curr.size() != 1)
666 skipExpression(tokPtr);
667 else
668 evaluateConditionalFunction(curr.at(0).toKey(), tokPtr);
669 m_skipLevel--;
670 #endif
671 } else {
672 skipExpression(tokPtr);
673 traceMsg("skipped test function %s", curr.size() == 1 ? dbgStr(curr.at(0)) : "<invalid>");
674 }
675 or_op = !okey; // tentatively force next evaluation
676 invert = false;
677 curr.clear();
678 continue;
679 case TokReturn:
680 m_returnValue = curr;
681 curr.clear();
682 ret = ReturnReturn;
683 goto ctrlstm;
684 case TokBreak:
685 ret = ReturnBreak;
686 goto ctrlstm;
687 case TokNext:
688 ret = ReturnNext;
689 ctrlstm:
690 if (!m_skipLevel && okey != or_op) {
691 traceMsg("flow control statement '%s', aborting block", dbgReturn(ret));
692 return ret;
693 }
694 traceMsg("skipped flow control statement '%s'", dbgReturn(ret));
695 okey = false, or_op = true; // force next evaluation
696 continue;
697 default: {
698 const ushort *oTokPtr = --tokPtr;
699 ret = evaluateExpression(tokPtr, &curr, false);
700 if (ret == ReturnError || tokPtr != oTokPtr)
701 break;
702 }
703 Q_ASSERT_X(false, "visitProBlock", "unexpected item type");
704 continue;
705 }
706 if (ret != ReturnTrue && ret != ReturnFalse) {
707 traceMsg("aborting block, status: %s", dbgReturn(ret));
708 return ret;
709 }
710 }
711 traceMsg("leaving block, okey=%s", dbgBool(okey));
712 return returnBool(okey);
713 }
714
715
716 void QMakeEvaluator::visitProFunctionDef(
717 ushort tok, const ProKey &name, const ushort *tokPtr)
718 {
719 QHash<ProKey, ProFunctionDef> *hash =
720 (tok == TokTestDef
721 ? &m_functionDefs.testFunctions
722 : &m_functionDefs.replaceFunctions);
723 hash->insert(name, ProFunctionDef(m_current.pro, tokPtr - m_current.pro->tokPtr()));
724 }
725
726 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProLoop(
727 const ProKey &_variable, const ushort *exprPtr, const ushort *tokPtr)
728 {
729 VisitReturn ret = ReturnTrue;
730 bool infinite = false;
731 int index = 0;
732 ProKey variable;
733 ProStringList oldVarVal;
734 ProStringList it_list_out;
735 if (expandVariableReferences(exprPtr, 0, &it_list_out, true) == ReturnError)
736 return ReturnError;
737 ProString it_list = it_list_out.at(0);
738 if (_variable.isEmpty()) {
739 if (it_list != statics.strever) {
740 evalError(fL1S("Invalid loop expression."));
741 return ReturnFalse;
742 }
743 it_list = ProString(statics.strforever);
744 } else {
745 variable = map(_variable);
746 oldVarVal = values(variable);
747 }
748 ProStringList list = values(it_list.toKey());
749 if (list.isEmpty()) {
750 if (it_list == statics.strforever) {
751 if (m_cumulative) {
752 // The termination conditions wouldn't be evaluated, so we must skip it.
753 traceMsg("skipping forever loop in cumulative mode");
754 return ReturnFalse;
755 }
756 infinite = true;
757 } else {
758 QStringView itl = it_list.toQStringView();
759 int dotdot = itl.indexOf(statics.strDotDot);
760 if (dotdot != -1) {
761 bool ok;
762 int start = itl.left(dotdot).toInt(&ok);
763 if (ok) {
764 int end = itl.mid(dotdot+2).toInt(&ok);
765 if (ok) {
766 const int absDiff = qAbs(end - start);
767 if (m_cumulative && absDiff > 100) {
768 // Such a loop is unlikely to contribute something useful to the
769 // file collection, and may cause considerable delay.
770 traceMsg("skipping excessive loop in cumulative mode");
771 return ReturnFalse;
772 }
773 list.reserve(absDiff + 1);
774 if (start < end) {
775 for (int i = start; i <= end; i++)
776 list << ProString(QString::number(i));
777 } else {
778 for (int i = start; i >= end; i--)
779 list << ProString(QString::number(i));
780 }
781 }
782 }
783 }
784 }
785 }
786
787 if (infinite)
788 traceMsg("entering infinite loop for %s", dbgKey(variable));
789 else
790 traceMsg("entering loop for %s over %s", dbgKey(variable), dbgStrList(list));
791
792 forever {
793 if (infinite) {
794 if (!variable.isEmpty())
795 m_valuemapStack.top()[variable] = ProStringList(ProString(QString::number(index)));
796 if (++index > 1000) {
797 evalError(fL1S("Ran into infinite loop (> 1000 iterations)."));
798 break;
799 }
800 traceMsg("loop iteration %d", index);
801 } else {
802 ProString val;
803 do {
804 if (index >= list.size())
805 goto do_break;
806 val = list.at(index++);
807 } while (val.isEmpty()); // stupid, but qmake is like that
808 traceMsg("loop iteration %s", dbgStr(val));
809 m_valuemapStack.top()[variable] = ProStringList(val);
810 }
811
812 ret = visitProBlock(tokPtr);
813 switch (ret) {
814 case ReturnTrue:
815 case ReturnFalse:
816 break;
817 case ReturnNext:
818 ret = ReturnTrue;
819 break;
820 case ReturnBreak:
821 ret = ReturnTrue;
822 goto do_break;
823 default:
824 goto do_break;
825 }
826 }
827 do_break:
828
829 traceMsg("done looping");
830
831 if (!variable.isEmpty())
832 m_valuemapStack.top()[variable] = oldVarVal;
833 return ret;
834 }
835
836 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProVariable(
837 ushort tok, const ProStringList &curr, const ushort *&tokPtr)
838 {
839 int sizeHint = *tokPtr++;
840
841 if (curr.size() != 1) {
842 skipExpression(tokPtr);
843 if (!m_cumulative || !curr.isEmpty())
844 evalError(fL1S("Left hand side of assignment must expand to exactly one word."));
845 return ReturnTrue;
846 }
847 const ProKey &varName = map(curr.first());
848
849 if (tok == TokReplace) { // ~=
850 // DEFINES ~= s/a/b/?[gqi]
851
852 ProStringList varVal;
853 if (expandVariableReferences(tokPtr, sizeHint, &varVal, true) == ReturnError)
854 return ReturnError;
855 QStringView val = varVal.at(0).toQStringView();
856 if (val.size() < 4 || val.at(0) != QLatin1Char('s')) {
857 evalError(fL1S("The ~= operator can handle only the s/// function."));
858 return ReturnTrue;
859 }
860 QChar sep = val.at(1);
861 auto func = val.split(sep, Qt::KeepEmptyParts);
862 if (func.size() < 3 || func.size() > 4) {
863 evalError(fL1S("The s/// function expects 3 or 4 arguments."));
864 return ReturnTrue;
865 }
866
867 bool global = false, quote = false, case_sense = false;
868 if (func.size() == 4) {
869 global = func[3].indexOf(QLatin1Char('g')) != -1;
870 case_sense = func[3].indexOf(QLatin1Char('i')) == -1;
871 quote = func[3].indexOf(QLatin1Char('q')) != -1;
872 }
873 QString pattern = func[1].toString();
874 QString replace = func[2].toString();
875 if (quote)
876 pattern = QRegularExpression::escape(pattern);
877
878 QRegularExpression regexp(pattern, case_sense ? QRegularExpression::NoPatternOption :
879 QRegularExpression::CaseInsensitiveOption);
880
881 // We could make a union of modified and unmodified values,
882 // but this will break just as much as it fixes, so leave it as is.
883 replaceInList(&valuesRef(varName), regexp, replace, global, m_tmp2);
884 debugMsg(2, "replaced %s with %s", dbgQStr(pattern), dbgQStr(replace));
885 } else {
886 ProStringList varVal;
887 if (expandVariableReferences(tokPtr, sizeHint, &varVal, false) == ReturnError)
888 return ReturnError;
889 switch (tok) {
890 default: // whatever - cannot happen
891 case TokAssign: // =
892 varVal.removeEmpty();
893 // FIXME: add check+warning about accidental value removal.
894 // This may be a bit too noisy, though.
895 m_valuemapStack.top()[varName] = varVal;
896 debugMsg(2, "assigning");
897 break;
898 case TokAppendUnique: // *=
899 valuesRef(varName).insertUnique(varVal);
900 debugMsg(2, "appending unique");
901 break;
902 case TokAppend: // +=
903 varVal.removeEmpty();
904 valuesRef(varName) += varVal;
905 debugMsg(2, "appending");
906 break;
907 case TokRemove: // -=
908 if (!m_cumulative) {
909 valuesRef(varName).removeEach(varVal);
910 } else {
911 // We are stingy with our values.
912 }
913 debugMsg(2, "removing");
914 break;
915 }
916 }
917 traceMsg("%s := %s", dbgKey(varName), dbgStrList(values(varName)));
918
919 if (varName == statics.strTEMPLATE)
920 setTemplate();
921 else if (varName == statics.strQMAKE_PLATFORM)
922 m_featureRoots = nullptr;
923 else if (varName == statics.strQMAKE_DIR_SEP)
924 m_dirSep = first(varName);
925 else if (varName == statics.strQMAKESPEC) {
926 if (!values(varName).isEmpty()) {
927 QString spec = values(varName).first().toQString();
928 if (IoUtils::isAbsolutePath(spec)) {
929 m_qmakespec = spec;
930 m_qmakespecName = IoUtils::fileName(m_qmakespec).toString();
931 m_featureRoots = nullptr;
932 }
933 }
934 }
935 #ifdef PROEVALUATOR_FULL
936 else if (varName == statics.strREQUIRES)
937 return checkRequirements(values(varName));
938 #endif
939
940 return ReturnTrue;
941 }
942
943 void QMakeEvaluator::setTemplate()
944 {
945 ProStringList &values = valuesRef(statics.strTEMPLATE);
946 if (!m_option->user_template.isEmpty()) {
947 // Don't allow override
948 values = ProStringList(ProString(m_option->user_template));
949 } else {
950 if (values.isEmpty())
951 values.append(ProString("app"));
952 else
953 values.erase(values.begin() + 1, values.end());
954 }
955 if (!m_option->user_template_prefix.isEmpty()) {
956 ProString val = values.first();
957 if (!val.startsWith(m_option->user_template_prefix))
958 values = ProStringList(ProString(m_option->user_template_prefix + val));
959 }
960 }
961
962 #if defined(Q_CC_MSVC)
963 static ProString msvcBinDirToQMakeArch(QString subdir)
964 {
965 int idx = subdir.indexOf(QLatin1Char('\\'));
966 if (idx == -1)
967 return ProString("x86");
968 subdir.remove(0, idx + 1);
969 idx = subdir.indexOf(QLatin1Char('_'));
970 if (idx >= 0)
971 subdir.remove(0, idx + 1);
972 subdir = subdir.toLower();
973 if (subdir == QLatin1String("amd64"))
974 return ProString("x86_64");
975 // Since 2017 the folder structure from here is HostX64|X86/x64|x86
976 idx = subdir.indexOf(QLatin1Char('\\'));
977 if (idx == -1)
978 return ProString("x86");
979 subdir.remove(0, idx + 1);
980 if (subdir == QLatin1String("x64"))
981 return ProString("x86_64");
982 return ProString(subdir);
983 }
984
985 static ProString defaultMsvcArchitecture()
986 {
987 #if defined(Q_OS_WIN64)
988 return ProString("x86_64");
989 #else
990 return ProString("x86");
991 #endif
992 }
993
994 static ProString msvcArchitecture(const QString &vcInstallDir, const QString &pathVar)
995 {
996 if (vcInstallDir.isEmpty())
997 return defaultMsvcArchitecture();
998 QString vcBinDir = vcInstallDir;
999 if (vcBinDir.endsWith(QLatin1Char('\\')))
1000 vcBinDir.chop(1);
1001 const auto dirs = pathVar.split(QLatin1Char(';'), Qt::SkipEmptyParts);
1002 for (const QString &dir : dirs) {
1003 if (!dir.startsWith(vcBinDir, Qt::CaseInsensitive))
1004 continue;
1005 const ProString arch = msvcBinDirToQMakeArch(dir.mid(vcBinDir.length() + 1));
1006 if (!arch.isEmpty())
1007 return arch;
1008 }
1009 return defaultMsvcArchitecture();
1010 }
1011 #endif // defined(Q_CC_MSVC)
1012
1013 void QMakeEvaluator::loadDefaults()
1014 {
1015 ProValueMap &vars = m_valuemapStack.top();
1016 qlonglong sde = qgetenv("SOURCE_DATE_EPOCH").toLongLong();
1017 QDateTime builddate = sde ? QDateTime::fromSecsSinceEpoch(sde)
1018 : QDateTime::currentDateTime();
1019
1020 vars[ProKey("DIR_SEPARATOR")] << ProString(m_option->dir_sep);
1021 vars[ProKey("DIRLIST_SEPARATOR")] << ProString(m_option->dirlist_sep);
1022 vars[ProKey("_DATE_")] << ProString(builddate.toString());
1023 if (!m_option->qmake_abslocation.isEmpty())
1024 vars[ProKey("QMAKE_QMAKE")] << ProString(m_option->qmake_abslocation);
1025 if (!m_option->qmake_args.isEmpty())
1026 vars[ProKey("QMAKE_ARGS")] = ProStringList(m_option->qmake_args);
1027 if (!m_option->qtconf.isEmpty())
1028 vars[ProKey("QMAKE_QTCONF")] = ProString(m_option->qtconf);
1029 vars[ProKey("QMAKE_HOST.cpu_count")] = ProString(QString::number(idealThreadCount()));
1030 #if defined(Q_OS_WIN32)
1031 vars[ProKey("QMAKE_HOST.os")] << ProString("Windows");
1032
1033 DWORD name_length = 1024;
1034 wchar_t name[1024];
1035 if (GetComputerName(name, &name_length))
1036 vars[ProKey("QMAKE_HOST.name")] << ProString(QString::fromWCharArray(name));
1037
1038 vars[ProKey("QMAKE_HOST.version")] << ProString(QSysInfo::kernelVersion());
1039 vars[ProKey("QMAKE_HOST.version_string")] << ProString(QSysInfo::productVersion());
1040
1041 SYSTEM_INFO info;
1042 GetSystemInfo(&info);
1043 ProString archStr;
1044 switch (info.wProcessorArchitecture) {
1045 # ifdef PROCESSOR_ARCHITECTURE_AMD64
1046 case PROCESSOR_ARCHITECTURE_AMD64:
1047 archStr = ProString("x86_64");
1048 break;
1049 # endif
1050 # ifdef PROCESSOR_ARCHITECTURE_ARM64
1051 case PROCESSOR_ARCHITECTURE_ARM64:
1052 archStr = ProString("arm64");
1053 break;
1054 # endif
1055 case PROCESSOR_ARCHITECTURE_INTEL:
1056 archStr = ProString("x86");
1057 break;
1058 case PROCESSOR_ARCHITECTURE_IA64:
1059 # ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
1060 case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
1061 # endif
1062 archStr = ProString("IA64");
1063 break;
1064 default:
1065 archStr = ProString("Unknown");
1066 break;
1067 }
1068 vars[ProKey("QMAKE_HOST.arch")] << archStr;
1069
1070 # if defined(Q_CC_MSVC) // ### bogus condition, but nobody x-builds for msvc with a different qmake
1071 // Since VS 2017 we need VCToolsInstallDir instead of VCINSTALLDIR
1072 QString vcInstallDir = m_option->getEnv(QLatin1String("VCToolsInstallDir"));
1073 if (vcInstallDir.isEmpty())
1074 vcInstallDir = m_option->getEnv(QLatin1String("VCINSTALLDIR"));
1075 vars[ProKey("QMAKE_TARGET.arch")] = msvcArchitecture(
1076 vcInstallDir,
1077 m_option->getEnv(QLatin1String("PATH")));
1078 # endif
1079 #elif defined(Q_OS_UNIX)
1080 struct utsname name;
1081 if (uname(&name) != -1) {
1082 vars[ProKey("QMAKE_HOST.os")] << ProString(name.sysname);
1083 vars[ProKey("QMAKE_HOST.name")] << ProString(QString::fromLocal8Bit(name.nodename));
1084 vars[ProKey("QMAKE_HOST.version")] << ProString(name.release);
1085 vars[ProKey("QMAKE_HOST.version_string")] << ProString(name.version);
1086 vars[ProKey("QMAKE_HOST.arch")] << ProString(name.machine);
1087 }
1088 #endif
1089
1090 m_valuemapInited = true;
1091 }
1092
1093 bool QMakeEvaluator::prepareProject(const QString &inDir)
1094 {
1095 QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact);
1096 QString superdir;
1097 if (m_option->do_cache) {
1098 QString conffile;
1099 QString cachefile = m_option->cachefile;
1100 if (cachefile.isEmpty()) { //find it as it has not been specified
1101 if (m_outputDir.isEmpty())
1102 goto no_cache;
1103 superdir = m_outputDir;
1104 forever {
1105 QString superfile = superdir + QLatin1String("/.qmake.super");
1106 if (m_vfs->exists(superfile, flags)) {
1107 m_superfile = QDir::cleanPath(superfile);
1108 break;
1109 }
1110 QFileInfo qdfi(superdir);
1111 if (qdfi.isRoot()) {
1112 superdir.clear();
1113 break;
1114 }
1115 superdir = qdfi.path();
1116 }
1117 QString sdir = inDir;
1118 QString dir = m_outputDir;
1119 forever {
1120 conffile = sdir + QLatin1String("/.qmake.conf");
1121 if (!m_vfs->exists(conffile, flags))
1122 conffile.clear();
1123 cachefile = dir + QLatin1String("/.qmake.cache");
1124 if (!m_vfs->exists(cachefile, flags))
1125 cachefile.clear();
1126 if (!conffile.isEmpty() || !cachefile.isEmpty()) {
1127 if (dir != sdir)
1128 m_sourceRoot = sdir;
1129 m_buildRoot = dir;
1130 break;
1131 }
1132 if (dir == superdir)
1133 goto no_cache;
1134 QFileInfo qsdfi(sdir);
1135 QFileInfo qdfi(dir);
1136 if (qsdfi.isRoot() || qdfi.isRoot())
1137 goto no_cache;
1138 sdir = qsdfi.path();
1139 dir = qdfi.path();
1140 }
1141 } else {
1142 m_buildRoot = QFileInfo(cachefile).path();
1143 }
1144 m_conffile = QDir::cleanPath(conffile);
1145 m_cachefile = QDir::cleanPath(cachefile);
1146 }
1147 no_cache:
1148
1149 QString dir = m_outputDir;
1150 forever {
1151 QString stashfile = dir + QLatin1String("/.qmake.stash");
1152 if (dir == (!superdir.isEmpty() ? superdir : m_buildRoot) || m_vfs->exists(stashfile, flags)) {
1153 m_stashfile = QDir::cleanPath(stashfile);
1154 break;
1155 }
1156 QFileInfo qdfi(dir);
1157 if (qdfi.isRoot())
1158 break;
1159 dir = qdfi.path();
1160 }
1161
1162 return true;
1163 }
1164
1165 bool QMakeEvaluator::loadSpecInternal()
1166 {
1167 if (evaluateFeatureFile(QLatin1String("spec_pre.prf")) != ReturnTrue)
1168 return false;
1169 QString spec = m_qmakespec + QLatin1String("/qmake.conf");
1170 if (evaluateFile(spec, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue) {
1171 evalError(fL1S("Could not read qmake configuration file %1.").arg(spec));
1172 return false;
1173 }
1174 #ifndef QT_BUILD_QMAKE
1175 // Legacy support for Qt4 default specs
1176 # ifdef Q_OS_UNIX
1177 if (m_qmakespec.endsWith(QLatin1String("/default-host"))
1178 || m_qmakespec.endsWith(QLatin1String("/default"))) {
1179 QString rspec = QFileInfo(m_qmakespec).symLinkTarget();
1180 if (!rspec.isEmpty())
1181 m_qmakespec = QDir::cleanPath(QDir(m_qmakespec).absoluteFilePath(rspec));
1182 }
1183 # else
1184 // We can't resolve symlinks as they do on Unix, so configure.exe puts
1185 // the source of the qmake.conf at the end of the default/qmake.conf in
1186 // the QMAKESPEC_ORIGINAL variable.
1187 const ProString &orig_spec = first(ProKey("QMAKESPEC_ORIGINAL"));
1188 if (!orig_spec.isEmpty()) {
1189 QString spec = orig_spec.toQString();
1190 if (IoUtils::isAbsolutePath(spec))
1191 m_qmakespec = spec;
1192 }
1193 # endif
1194 #endif
1195 valuesRef(ProKey("QMAKESPEC")) = ProString(m_qmakespec);
1196 m_qmakespecName = IoUtils::fileName(m_qmakespec).toString();
1197 // This also ensures that m_featureRoots is valid.
1198 if (evaluateFeatureFile(QLatin1String("spec_post.prf")) != ReturnTrue)
1199 return false;
1200 return true;
1201 }
1202
1203 bool QMakeEvaluator::loadSpec()
1204 {
1205 QString qmakespec = m_option->expandEnvVars(
1206 m_hostBuild ? m_option->qmakespec : m_option->xqmakespec);
1207
1208 {
1209 QMakeEvaluator evaluator(m_option, m_parser, m_vfs, m_handler);
1210 evaluator.m_sourceRoot = m_sourceRoot;
1211 evaluator.m_buildRoot = m_buildRoot;
1212
1213 if (!m_superfile.isEmpty() && evaluator.evaluateFile(
1214 m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly|LoadHidden) != ReturnTrue) {
1215 return false;
1216 }
1217 if (!m_conffile.isEmpty() && evaluator.evaluateFile(
1218 m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly|LoadHidden) != ReturnTrue) {
1219 return false;
1220 }
1221 if (!m_cachefile.isEmpty() && evaluator.evaluateFile(
1222 m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly|LoadHidden) != ReturnTrue) {
1223 return false;
1224 }
1225 if (qmakespec.isEmpty()) {
1226 if (!m_hostBuild)
1227 qmakespec = evaluator.first(ProKey("XQMAKESPEC")).toQString();
1228 if (qmakespec.isEmpty())
1229 qmakespec = evaluator.first(ProKey("QMAKESPEC")).toQString();
1230 }
1231 m_qmakepath = evaluator.values(ProKey("QMAKEPATH")).toQStringList();
1232 m_qmakefeatures = evaluator.values(ProKey("QMAKEFEATURES")).toQStringList();
1233 }
1234
1235 updateMkspecPaths();
1236 if (qmakespec.isEmpty())
1237 qmakespec = propertyValue(ProKey(m_hostBuild ? "QMAKE_SPEC" : "QMAKE_XSPEC")).toQString();
1238 #ifndef QT_BUILD_QMAKE
1239 // Legacy support for Qt4 qmake in Qt Creator, etc.
1240 if (qmakespec.isEmpty())
1241 qmakespec = m_hostBuild ? QLatin1String("default-host") : QLatin1String("default");
1242 #endif
1243 if (IoUtils::isRelativePath(qmakespec)) {
1244 for (const QString &root : std::as_const(m_mkspecPaths)) {
1245 QString mkspec = root + QLatin1Char('/') + qmakespec;
1246 if (IoUtils::exists(mkspec)) {
1247 qmakespec = mkspec;
1248 goto cool;
1249 }
1250 }
1251 evalError(fL1S("Could not find qmake spec '%1'.").arg(qmakespec));
1252 return false;
1253 }
1254 cool:
1255 m_qmakespec = QDir::cleanPath(qmakespec);
1256
1257 if (!m_superfile.isEmpty()) {
1258 valuesRef(ProKey("_QMAKE_SUPER_CACHE_")) << ProString(m_superfile);
1259 if (evaluateFile(
1260 m_superfile, QMakeHandler::EvalConfigFile, LoadProOnly|LoadHidden) != ReturnTrue)
1261 return false;
1262 }
1263 if (!loadSpecInternal())
1264 return false;
1265 if (!m_conffile.isEmpty()) {
1266 valuesRef(ProKey("_QMAKE_CONF_")) << ProString(m_conffile);
1267 if (evaluateFile(
1268 m_conffile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
1269 return false;
1270 }
1271 if (!m_cachefile.isEmpty()) {
1272 valuesRef(ProKey("_QMAKE_CACHE_")) << ProString(m_cachefile);
1273 if (evaluateFile(
1274 m_cachefile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
1275 return false;
1276 }
1277 QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact);
1278 if (!m_stashfile.isEmpty() && m_vfs->exists(m_stashfile, flags)) {
1279 valuesRef(ProKey("_QMAKE_STASH_")) << ProString(m_stashfile);
1280 if (evaluateFile(
1281 m_stashfile, QMakeHandler::EvalConfigFile, LoadProOnly) != ReturnTrue)
1282 return false;
1283 }
1284 return true;
1285 }
1286
1287 void QMakeEvaluator::setupProject()
1288 {
1289 setTemplate();
1290 ProValueMap &vars = m_valuemapStack.top();
1291 int proFile = currentFileId();
1292 vars[ProKey("TARGET")] << ProString(QFileInfo(currentFileName()).baseName()).setSource(proFile);
1293 vars[ProKey("_PRO_FILE_")] << ProString(currentFileName()).setSource(proFile);
1294 vars[ProKey("_PRO_FILE_PWD_")] << ProString(currentDirectory()).setSource(proFile);
1295 vars[ProKey("OUT_PWD")] << ProString(m_outputDir).setSource(proFile);
1296 }
1297
1298 void QMakeEvaluator::evaluateCommand(const QString &cmds, const QString &where)
1299 {
1300 if (!cmds.isEmpty()) {
1301 ProFile *pro = m_parser->parsedProBlock(QStringView(cmds), 0, where, -1);
1302 if (pro->isOk()) {
1303 m_locationStack.push(m_current);
1304 visitProBlock(pro, pro->tokPtr());
1305 m_current = m_locationStack.pop();
1306 }
1307 pro->deref();
1308 }
1309 }
1310
1311 void QMakeEvaluator::applyExtraConfigs()
1312 {
1313 if (m_extraConfigs.isEmpty())
1314 return;
1315
1316 evaluateCommand(fL1S("CONFIG += ") + m_extraConfigs.join(QLatin1Char(' ')), fL1S("(extra configs)"));
1317 }
1318
1319 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateConfigFeatures()
1320 {
1321 QSet<QString> processed;
1322 forever {
1323 bool finished = true;
1324 ProStringList configs = values(statics.strCONFIG);
1325 for (int i = configs.size() - 1; i >= 0; --i) {
1326 ProStringRoUser u1(configs.at(i), m_tmp1);
1327 QString config = u1.str().toLower();
1328 if (!processed.contains(config)) {
1329 config.detach();
1330 processed.insert(config);
1331 VisitReturn vr = evaluateFeatureFile(config, true);
1332 if (vr == ReturnError && !m_cumulative)
1333 return vr;
1334 if (vr == ReturnTrue) {
1335 finished = false;
1336 break;
1337 }
1338 }
1339 }
1340 if (finished)
1341 break;
1342 }
1343 return ReturnTrue;
1344 }
1345
1346 QMakeEvaluator::VisitReturn QMakeEvaluator::visitProFile(
1347 ProFile *pro, QMakeHandler::EvalFileType type, LoadFlags flags)
1348 {
1349 if (!m_cumulative && !pro->isOk())
1350 return ReturnFalse;
1351
1352 if (flags & LoadPreFiles) {
1353 if (!prepareProject(pro->directoryName()))
1354 return ReturnFalse;
1355
1356 m_hostBuild = pro->isHostBuild();
1357
1358 #ifdef PROEVALUATOR_THREAD_SAFE
1359 m_option->mutex.lock();
1360 #endif
1361 QMakeBaseEnv **baseEnvPtr = &m_option->baseEnvs[QMakeBaseKey(m_buildRoot, m_stashfile, m_hostBuild)];
1362 if (!*baseEnvPtr)
1363 *baseEnvPtr = new QMakeBaseEnv;
1364 QMakeBaseEnv *baseEnv = *baseEnvPtr;
1365
1366 #ifdef PROEVALUATOR_THREAD_SAFE
1367 QMutexLocker locker(&baseEnv->mutex);
1368 m_option->mutex.unlock();
1369 if (baseEnv->inProgress) {
1370 QThreadPool::globalInstance()->releaseThread();
1371 baseEnv->cond.wait(&baseEnv->mutex);
1372 QThreadPool::globalInstance()->reserveThread();
1373 if (!baseEnv->isOk)
1374 return ReturnFalse;
1375 } else
1376 #endif
1377 if (!baseEnv->evaluator) {
1378 #ifdef PROEVALUATOR_THREAD_SAFE
1379 baseEnv->inProgress = true;
1380 locker.unlock();
1381 #endif
1382
1383 QMakeEvaluator *baseEval = new QMakeEvaluator(m_option, m_parser, m_vfs, m_handler);
1384 baseEnv->evaluator = baseEval;
1385 baseEval->m_superfile = m_superfile;
1386 baseEval->m_conffile = m_conffile;
1387 baseEval->m_cachefile = m_cachefile;
1388 baseEval->m_stashfile = m_stashfile;
1389 baseEval->m_sourceRoot = m_sourceRoot;
1390 baseEval->m_buildRoot = m_buildRoot;
1391 baseEval->m_hostBuild = m_hostBuild;
1392 bool ok = baseEval->loadSpec();
1393
1394 #ifdef PROEVALUATOR_THREAD_SAFE
1395 locker.relock();
1396 baseEnv->isOk = ok;
1397 baseEnv->inProgress = false;
1398 baseEnv->cond.wakeAll();
1399 #endif
1400
1401 if (!ok)
1402 return ReturnFalse;
1403 }
1404 #ifdef PROEVALUATOR_THREAD_SAFE
1405 else if (!baseEnv->isOk)
1406 return ReturnFalse;
1407 #endif
1408
1409 initFrom(baseEnv->evaluator);
1410 } else {
1411 if (!m_valuemapInited)
1412 loadDefaults();
1413 }
1414
1415 VisitReturn vr;
1416
1417 m_handler->aboutToEval(currentProFile(), pro, type);
1418 m_profileStack.push(pro);
1419 valuesRef(ProKey("PWD")) = ProStringList(ProString(currentDirectory()));
1420 if (flags & LoadPreFiles) {
1421 setupProject();
1422
1423 if (!m_option->extra_cmds[QMakeEvalEarly].isEmpty())
1424 evaluateCommand(m_option->extra_cmds[QMakeEvalEarly], fL1S("(command line -early)"));
1425
1426 for (ProValueMap::ConstIterator it = m_extraVars.constBegin();
1427 it != m_extraVars.constEnd(); ++it)
1428 m_valuemapStack.front().insert(it.key(), it.value());
1429
1430 // In case default_pre needs to make decisions based on the current
1431 // build pass configuration.
1432 applyExtraConfigs();
1433
1434 if ((vr = evaluateFeatureFile(QLatin1String("default_pre.prf"))) == ReturnError)
1435 goto failed;
1436
1437 if (!m_option->extra_cmds[QMakeEvalBefore].isEmpty()) {
1438 evaluateCommand(m_option->extra_cmds[QMakeEvalBefore], fL1S("(command line)"));
1439
1440 // Again, after user configs, to override them
1441 applyExtraConfigs();
1442 }
1443 }
1444
1445 debugMsg(1, "visiting file %s", qPrintable(pro->fileName()));
1446 if ((vr = visitProBlock(pro, pro->tokPtr())) == ReturnError)
1447 goto failed;
1448 debugMsg(1, "done visiting file %s", qPrintable(pro->fileName()));
1449
1450 if (flags & LoadPostFiles) {
1451 evaluateCommand(m_option->extra_cmds[QMakeEvalAfter], fL1S("(command line -after)"));
1452
1453 // Again, to ensure the project does not mess with us.
1454 // Specifically, do not allow a project to override debug/release within a
1455 // debug_and_release build pass - it's too late for that at this point anyway.
1456 applyExtraConfigs();
1457
1458 if ((vr = evaluateFeatureFile(QLatin1String("default_post.prf"))) == ReturnError)
1459 goto failed;
1460
1461 if (!m_option->extra_cmds[QMakeEvalLate].isEmpty())
1462 evaluateCommand(m_option->extra_cmds[QMakeEvalLate], fL1S("(command line -late)"));
1463
1464 if ((vr = evaluateConfigFeatures()) == ReturnError)
1465 goto failed;
1466 }
1467 vr = ReturnTrue;
1468 failed:
1469 m_profileStack.pop();
1470 valuesRef(ProKey("PWD")) = ProStringList(ProString(currentDirectory()));
1471 m_handler->doneWithEval(currentProFile());
1472
1473 return vr;
1474 }
1475
1476
1477 void QMakeEvaluator::updateMkspecPaths()
1478 {
1479 QStringList ret;
1480 const QString concat = QLatin1String("/mkspecs");
1481
1482 const auto paths = m_option->getPathListEnv(QLatin1String("QMAKEPATH"));
1483 for (const QString &it : paths)
1484 ret << it + concat;
1485
1486 for (const QString &it : std::as_const(m_qmakepath))
1487 ret << it + concat;
1488
1489 if (!m_buildRoot.isEmpty())
1490 ret << m_buildRoot + concat;
1491 if (!m_sourceRoot.isEmpty())
1492 ret << m_sourceRoot + concat;
1493
1494 ret << m_option->propertyValue(ProKey("QT_HOST_DATA/get")) + concat;
1495 ret << m_option->propertyValue(ProKey("QT_HOST_DATA/src")) + concat;
1496
1497 ret.removeDuplicates();
1498 m_mkspecPaths = ret;
1499 }
1500
1501 void QMakeEvaluator::updateFeaturePaths()
1502 {
1503 QString mkspecs_concat = QLatin1String("/mkspecs");
1504 QString features_concat = QLatin1String("/features/");
1505
1506 QStringList feature_roots;
1507
1508 feature_roots += m_option->getPathListEnv(QLatin1String("QMAKEFEATURES"));
1509 feature_roots += m_qmakefeatures;
1510 feature_roots += m_option->splitPathList(
1511 m_option->propertyValue(ProKey("QMAKEFEATURES")).toQString());
1512
1513 QStringList feature_bases;
1514 if (!m_buildRoot.isEmpty()) {
1515 feature_bases << m_buildRoot + mkspecs_concat;
1516 feature_bases << m_buildRoot;
1517 }
1518 if (!m_sourceRoot.isEmpty()) {
1519 feature_bases << m_sourceRoot + mkspecs_concat;
1520 feature_bases << m_sourceRoot;
1521 }
1522
1523 const auto items = m_option->getPathListEnv(QLatin1String("QMAKEPATH"));
1524 for (const QString &item : items)
1525 feature_bases << (item + mkspecs_concat);
1526
1527 for (const QString &item : std::as_const(m_qmakepath))
1528 feature_bases << (item + mkspecs_concat);
1529
1530 if (!m_qmakespec.isEmpty()) {
1531 // The spec is already platform-dependent, so no subdirs here.
1532 feature_roots << (m_qmakespec + features_concat);
1533
1534 // Also check directly under the root directory of the mkspecs collection
1535 QDir specdir(m_qmakespec);
1536 while (!specdir.isRoot() && specdir.cdUp()) {
1537 const QString specpath = specdir.path();
1538 if (specpath.endsWith(mkspecs_concat)) {
1539 if (IoUtils::exists(specpath + features_concat))
1540 feature_bases << specpath;
1541 break;
1542 }
1543 }
1544 }
1545
1546 feature_bases << (m_option->propertyValue(ProKey("QT_HOST_DATA/get")) + mkspecs_concat);
1547 feature_bases << (m_option->propertyValue(ProKey("QT_HOST_DATA/src")) + mkspecs_concat);
1548
1549 for (const QString &fb : std::as_const(feature_bases)) {
1550 const auto sfxs = values(ProKey("QMAKE_PLATFORM"));
1551 for (const ProString &sfx : sfxs)
1552 feature_roots << (fb + features_concat + sfx + QLatin1Char('/'));
1553 feature_roots << (fb + features_concat);
1554 }
1555
1556 for (int i = 0; i < feature_roots.size(); ++i)
1557 if (!feature_roots.at(i).endsWith(QLatin1Char('/')))
1558 feature_roots[i].append(QLatin1Char('/'));
1559
1560 feature_roots.removeDuplicates();
1561
1562 QStringList ret;
1563 for (const QString &root : std::as_const(feature_roots))
1564 if (IoUtils::exists(root))
1565 ret << root;
1566 m_featureRoots = new QMakeFeatureRoots(ret);
1567 }
1568
1569 ProString QMakeEvaluator::propertyValue(const ProKey &name) const
1570 {
1571 if (name == QLatin1String("QMAKE_MKSPECS"))
1572 return ProString(m_mkspecPaths.join(m_option->dirlist_sep));
1573 ProString ret = m_option->propertyValue(name);
1574 // if (ret.isNull())
1575 // evalError(fL1S("Querying unknown property %1").arg(name.toQStringView()));
1576 return ret;
1577 }
1578
1579 ProFile *QMakeEvaluator::currentProFile() const
1580 {
1581 if (m_profileStack.size() > 0)
1582 return m_profileStack.top();
1583 return nullptr;
1584 }
1585
1586 int QMakeEvaluator::currentFileId() const
1587 {
1588 ProFile *pro = currentProFile();
1589 if (pro)
1590 return pro->id();
1591 return 0;
1592 }
1593
1594 QString QMakeEvaluator::currentFileName() const
1595 {
1596 ProFile *pro = currentProFile();
1597 if (pro)
1598 return pro->fileName();
1599 return QString();
1600 }
1601
1602 QString QMakeEvaluator::currentDirectory() const
1603 {
1604 ProFile *pro = currentProFile();
1605 if (pro)
1606 return pro->directoryName();
1607 return QString();
1608 }
1609
1610 bool QMakeEvaluator::isActiveConfig(QStringView config, bool regex)
1611 {
1612 // magic types for easy flipping
1613 if (config == statics.strtrue)
1614 return true;
1615 if (config == statics.strfalse)
1616 return false;
1617
1618 if (config == statics.strhost_build)
1619 return m_hostBuild;
1620
1621 if (regex && (config.contains(QLatin1Char('*')) || config.contains(QLatin1Char('?')))) {
1622 auto re = QRegularExpression::fromWildcard(config.toString());
1623
1624 // mkspecs
1625 if (re.match(m_qmakespecName).hasMatch())
1626 return true;
1627
1628 // CONFIG variable
1629 const auto configValues = values(statics.strCONFIG);
1630 for (const ProString &configValue : configValues) {
1631 ProStringRoUser u1(configValue, m_tmp[m_toggle ^= 1]);
1632 if (re.match(u1.str()).hasMatch())
1633 return true;
1634 }
1635 } else {
1636 // mkspecs
1637 if (m_qmakespecName == config)
1638 return true;
1639
1640 // CONFIG variable
1641 if (values(statics.strCONFIG).contains(config))
1642 return true;
1643 }
1644
1645 return false;
1646 }
1647
1648 QMakeEvaluator::VisitReturn QMakeEvaluator::expandVariableReferences(
1649 const ushort *&tokPtr, int sizeHint, ProStringList *ret, bool joined)
1650 {
1651 ret->reserve(sizeHint);
1652 forever {
1653 if (evaluateExpression(tokPtr, ret, joined) == ReturnError)
1654 return ReturnError;
1655 switch (*tokPtr) {
1656 case TokValueTerminator:
1657 case TokFuncTerminator:
1658 tokPtr++;
1659 return ReturnTrue;
1660 case TokArgSeparator:
1661 if (joined) {
1662 tokPtr++;
1663 continue;
1664 }
1665 Q_FALLTHROUGH();
1666 default:
1667 Q_ASSERT_X(false, "expandVariableReferences", "Unrecognized token");
1668 break;
1669 }
1670 }
1671 }
1672
1673 QMakeEvaluator::VisitReturn QMakeEvaluator::prepareFunctionArgs(
1674 const ushort *&tokPtr, QList<ProStringList> *ret)
1675 {
1676 if (*tokPtr != TokFuncTerminator) {
1677 for (;; tokPtr++) {
1678 ProStringList arg;
1679 if (evaluateExpression(tokPtr, &arg, false) == ReturnError)
1680 return ReturnError;
1681 *ret << arg;
1682 if (*tokPtr == TokFuncTerminator)
1683 break;
1684 Q_ASSERT(*tokPtr == TokArgSeparator);
1685 }
1686 }
1687 tokPtr++;
1688 return ReturnTrue;
1689 }
1690
1691 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFunction(
1692 const ProFunctionDef &func, const QList<ProStringList> &argumentsList, ProStringList *ret)
1693 {
1694 VisitReturn vr;
1695
1696 if (m_valuemapStack.size() >= 100) {
1697 evalError(fL1S("Ran into infinite recursion (depth > 100)."));
1698 vr = ReturnError;
1699 } else {
1700 m_valuemapStack.push(ProValueMap());
1701 m_locationStack.push(m_current);
1702
1703 ProStringList args;
1704 for (int i = 0; i < argumentsList.size(); ++i) {
1705 args += argumentsList[i];
1706 m_valuemapStack.top()[ProKey(QString::number(i+1))] = argumentsList[i];
1707 }
1708 m_valuemapStack.top()[statics.strARGS] = args;
1709 m_valuemapStack.top()[statics.strARGC] = ProStringList(ProString(QString::number(argumentsList.size())));
1710 vr = visitProBlock(func.pro(), func.tokPtr());
1711 if (vr == ReturnReturn)
1712 vr = ReturnTrue;
1713 if (vr == ReturnTrue)
1714 *ret = m_returnValue;
1715 m_returnValue.clear();
1716
1717 m_current = m_locationStack.pop();
1718 m_valuemapStack.pop();
1719 }
1720 return vr;
1721 }
1722
1723 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBoolFunction(
1724 const ProFunctionDef &func, const QList<ProStringList> &argumentsList,
1725 const ProString &function)
1726 {
1727 ProStringList ret;
1728 VisitReturn vr = evaluateFunction(func, argumentsList, &ret);
1729 if (vr == ReturnTrue) {
1730 if (ret.isEmpty())
1731 return ReturnTrue;
1732 if (ret.at(0) != statics.strfalse) {
1733 if (ret.at(0) == statics.strtrue)
1734 return ReturnTrue;
1735 bool ok;
1736 int val = ret.at(0).toInt(&ok);
1737 if (ok) {
1738 if (val)
1739 return ReturnTrue;
1740 } else {
1741 ProStringRoUser u1(function, m_tmp1);
1742 evalError(fL1S("Unexpected return value from test '%1': %2.")
1743 .arg(u1.str(), ret.join(QLatin1String(" :: "))));
1744 }
1745 }
1746 return ReturnFalse;
1747 }
1748 return vr;
1749 }
1750
1751 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateConditionalFunction(
1752 const ProKey &func, const ushort *&tokPtr)
1753 {
1754 auto adef = statics.functions.constFind(func);
1755 if (adef != statics.functions.constEnd()) {
1756 //why don't the builtin functions just use args_list? --Sam
1757 ProStringList args;
1758 if (expandVariableReferences(tokPtr, 5, &args, true) == ReturnError)
1759 return ReturnError;
1760 return evaluateBuiltinConditional(*adef, func, args);
1761 }
1762
1763 QHash<ProKey, ProFunctionDef>::ConstIterator it =
1764 m_functionDefs.testFunctions.constFind(func);
1765 if (it != m_functionDefs.testFunctions.constEnd()) {
1766 QList<ProStringList> args;
1767 if (prepareFunctionArgs(tokPtr, &args) == ReturnError)
1768 return ReturnError;
1769 traceMsg("calling %s(%s)", dbgKey(func), dbgStrListList(args));
1770 return evaluateBoolFunction(*it, args, func);
1771 }
1772
1773 skipExpression(tokPtr);
1774 evalError(fL1S("'%1' is not a recognized test function.").arg(func.toQStringView()));
1775 return ReturnFalse;
1776 }
1777
1778 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateExpandFunction(
1779 const ProKey &func, const ushort *&tokPtr, ProStringList *ret)
1780 {
1781 auto adef = statics.expands.constFind(func);
1782 if (adef != statics.expands.constEnd()) {
1783 //why don't the builtin functions just use args_list? --Sam
1784 ProStringList args;
1785 if (expandVariableReferences(tokPtr, 5, &args, true) == ReturnError)
1786 return ReturnError;
1787 return evaluateBuiltinExpand(*adef, func, args, *ret);
1788 }
1789
1790 QHash<ProKey, ProFunctionDef>::ConstIterator it =
1791 m_functionDefs.replaceFunctions.constFind(func);
1792 if (it != m_functionDefs.replaceFunctions.constEnd()) {
1793 QList<ProStringList> args;
1794 if (prepareFunctionArgs(tokPtr, &args) == ReturnError)
1795 return ReturnError;
1796 traceMsg("calling $$%s(%s)", dbgKey(func), dbgStrListList(args));
1797 return evaluateFunction(*it, args, ret);
1798 }
1799
1800 skipExpression(tokPtr);
1801 evalError(fL1S("'%1' is not a recognized replace function.").arg(func.toQStringView()));
1802 return ReturnFalse;
1803 }
1804
1805 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateConditional(
1806 QStringView cond, const QString &where, int line)
1807 {
1808 VisitReturn ret = ReturnFalse;
1809 ProFile *pro = m_parser->parsedProBlock(cond, 0, where, line, QMakeParser::TestGrammar);
1810 if (pro->isOk()) {
1811 m_locationStack.push(m_current);
1812 ret = visitProBlock(pro, pro->tokPtr());
1813 m_current = m_locationStack.pop();
1814 }
1815 pro->deref();
1816 return ret;
1817 }
1818
1819 #ifdef PROEVALUATOR_FULL
1820 QMakeEvaluator::VisitReturn QMakeEvaluator::checkRequirements(const ProStringList &deps)
1821 {
1822 ProStringList &failed = valuesRef(ProKey("QMAKE_FAILED_REQUIREMENTS"));
1823 for (const ProString &dep : deps) {
1824 VisitReturn vr = evaluateConditional(dep.toQStringView(), m_current.pro->fileName(), m_current.line);
1825 if (vr == ReturnError)
1826 return ReturnError;
1827 if (vr != ReturnTrue)
1828 failed << dep;
1829 }
1830 return ReturnTrue;
1831 }
1832 #endif
1833
1834 static bool isFunctParam(const ProKey &variableName)
1835 {
1836 const int len = variableName.size();
1837 const QChar *data = variableName.constData();
1838 for (int i = 0; i < len; i++) {
1839 ushort c = data[i].unicode();
1840 if (c < '0' || c > '9')
1841 return false;
1842 }
1843 return true;
1844 }
1845
1846 ProValueMap *QMakeEvaluator::findValues(const ProKey &variableName, ProValueMap::Iterator *rit)
1847 {
1848 ProValueMapStack::iterator vmi = m_valuemapStack.end();
1849 for (bool first = true; ; first = false) {
1850 --vmi;
1851 ProValueMap::Iterator it = (*vmi).find(variableName);
1852 if (it != (*vmi).end()) {
1853 if (it->constBegin() == statics.fakeValue.constBegin())
1854 break;
1855 *rit = it;
1856 return &(*vmi);
1857 }
1858 if (vmi == m_valuemapStack.begin())
1859 break;
1860 if (first && isFunctParam(variableName))
1861 break;
1862 }
1863 return nullptr;
1864 }
1865
1866 ProStringList &QMakeEvaluator::valuesRef(const ProKey &variableName)
1867 {
1868 ProValueMap::Iterator it = m_valuemapStack.top().find(variableName);
1869 if (it != m_valuemapStack.top().end()) {
1870 if (it->constBegin() == statics.fakeValue.constBegin())
1871 it->clear();
1872 return *it;
1873 }
1874 if (!isFunctParam(variableName)) {
1875 ProValueMapStack::iterator vmi = m_valuemapStack.end();
1876 if (--vmi != m_valuemapStack.begin()) {
1877 do {
1878 --vmi;
1879 ProValueMap::ConstIterator it = (*vmi).constFind(variableName);
1880 if (it != (*vmi).constEnd()) {
1881 ProStringList &ret = m_valuemapStack.top()[variableName];
1882 if (it->constBegin() != statics.fakeValue.constBegin())
1883 ret = *it;
1884 return ret;
1885 }
1886 } while (vmi != m_valuemapStack.begin());
1887 }
1888 }
1889 return m_valuemapStack.top()[variableName];
1890 }
1891
1892 ProStringList QMakeEvaluator::values(const ProKey &variableName) const
1893 {
1894 ProValueMapStack::const_iterator vmi = m_valuemapStack.cend();
1895 for (bool first = true; ; first = false) {
1896 --vmi;
1897 ProValueMap::ConstIterator it = (*vmi).constFind(variableName);
1898 if (it != (*vmi).constEnd()) {
1899 if (it->constBegin() == statics.fakeValue.constBegin())
1900 break;
1901 return *it;
1902 }
1903 if (vmi == m_valuemapStack.cbegin())
1904 break;
1905 if (first && isFunctParam(variableName))
1906 break;
1907 }
1908 return ProStringList();
1909 }
1910
1911 ProString QMakeEvaluator::first(const ProKey &variableName) const
1912 {
1913 const ProStringList &vals = values(variableName);
1914 if (!vals.isEmpty())
1915 return vals.first();
1916 return ProString();
1917 }
1918
1919 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFile(
1920 const QString &fileName, QMakeHandler::EvalFileType type, LoadFlags flags)
1921 {
1922 QMakeParser::ParseFlags pflags = QMakeParser::ParseUseCache;
1923 if (!(flags & LoadSilent))
1924 pflags |= QMakeParser::ParseReportMissing;
1925 if (ProFile *pro = m_parser->parsedProFile(fileName, pflags)) {
1926 m_locationStack.push(m_current);
1927 VisitReturn ok = visitProFile(pro, type, flags);
1928 m_current = m_locationStack.pop();
1929 pro->deref();
1930 if (ok == ReturnTrue && !(flags & LoadHidden)) {
1931 ProStringList &iif = m_valuemapStack.front()[ProKey("QMAKE_INTERNAL_INCLUDED_FILES")];
1932 ProString ifn(fileName);
1933 if (!iif.contains(ifn))
1934 iif << ifn;
1935 }
1936 return ok;
1937 } else {
1938 return ReturnFalse;
1939 }
1940 }
1941
1942 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFileChecked(
1943 const QString &fileName, QMakeHandler::EvalFileType type, LoadFlags flags)
1944 {
1945 if (fileName.isEmpty())
1946 return ReturnFalse;
1947 const QMakeEvaluator *ref = this;
1948 do {
1949 for (const ProFile *pf : ref->m_profileStack)
1950 if (pf->fileName() == fileName) {
1951 evalError(fL1S("Circular inclusion of %1.").arg(fileName));
1952 return ReturnFalse;
1953 }
1954 } while ((ref = ref->m_caller));
1955 return evaluateFile(fileName, type, flags);
1956 }
1957
1958 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFeatureFile(
1959 const QString &fileName, bool silent)
1960 {
1961 QString fn = fileName;
1962 if (!fn.endsWith(QLatin1String(".prf")))
1963 fn += QLatin1String(".prf");
1964
1965 if (!m_featureRoots)
1966 updateFeaturePaths();
1967 #ifdef PROEVALUATOR_THREAD_SAFE
1968 m_featureRoots->mutex.lock();
1969 #endif
1970 QString currFn = currentFileName();
1971 if (IoUtils::fileName(currFn) != IoUtils::fileName(fn))
1972 currFn.clear();
1973 // Null values cannot regularly exist in the hash, so they indicate that the value still
1974 // needs to be determined. Failed lookups are represented via non-null empty strings.
1975 QString *fnp = &m_featureRoots->cache[qMakePair(fn, currFn)];
1976 if (fnp->isNull()) {
1977 #ifdef QMAKE_OVERRIDE_PRFS
1978 {
1979 QString ovrfn(QLatin1String(":/qmake/override_features/") + fn);
1980 if (QFileInfo::exists(ovrfn)) {
1981 fn = ovrfn;
1982 goto cool;
1983 }
1984 }
1985 #endif
1986 {
1987 int start_root = 0;
1988 const QStringList &paths = m_featureRoots->paths;
1989 if (!currFn.isEmpty()) {
1990 QStringView currPath = IoUtils::pathName(currFn);
1991 for (int root = 0; root < paths.size(); ++root)
1992 if (currPath == paths.at(root)) {
1993 start_root = root + 1;
1994 break;
1995 }
1996 }
1997 for (int root = start_root; root < paths.size(); ++root) {
1998 QString fname = paths.at(root) + fn;
1999 if (IoUtils::exists(fname)) {
2000 fn = fname;
2001 goto cool;
2002 }
2003 }
2004 }
2005 #ifdef QMAKE_BUILTIN_PRFS
2006 fn.prepend(QLatin1String(":/qmake/features/"));
2007 if (QFileInfo::exists(fn))
2008 goto cool;
2009 #endif
2010 fn = QLatin1String(""); // Indicate failed lookup. See comment above.
2011
2012 cool:
2013 *fnp = fn;
2014 } else {
2015 fn = *fnp;
2016 }
2017 #ifdef PROEVALUATOR_THREAD_SAFE
2018 m_featureRoots->mutex.unlock();
2019 #endif
2020 if (fn.isEmpty()) {
2021 if (!silent)
2022 evalError(fL1S("Cannot find feature %1").arg(fileName));
2023 return ReturnFalse;
2024 }
2025 ProStringList &already = valuesRef(ProKey("QMAKE_INTERNAL_INCLUDED_FEATURES"));
2026 ProString afn(fn);
2027 if (already.contains(afn)) {
2028 if (!silent)
2029 languageWarning(fL1S("Feature %1 already included").arg(fileName));
2030 return ReturnTrue;
2031 }
2032 already.append(afn);
2033
2034 #ifdef PROEVALUATOR_CUMULATIVE
2035 bool cumulative = m_cumulative;
2036 // Even when evaluating the project in cumulative mode to maximize the
2037 // chance of collecting all source declarations, prfs are evaluated in
2038 // exact mode to maximize the chance of them successfully executing
2039 // their programmatic function.
2040 m_cumulative = false;
2041 #endif
2042
2043 // The path is fully normalized already.
2044 VisitReturn ok = evaluateFile(fn, QMakeHandler::EvalFeatureFile, LoadProOnly);
2045
2046 #ifdef PROEVALUATOR_CUMULATIVE
2047 m_cumulative = cumulative;
2048 if (cumulative) {
2049 // As the data collected in cumulative mode is potentially total
2050 // garbage, yet the prfs fed with it are executed in exact mode,
2051 // we must ignore their results to avoid that evaluation is unduly
2052 // aborted.
2053 ok = ReturnTrue;
2054 }
2055 #endif
2056 return ok;
2057 }
2058
2059 QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateFileInto(
2060 const QString &fileName, ProValueMap *values, LoadFlags flags)
2061 {
2062 QMakeEvaluator visitor(m_option, m_parser, m_vfs, m_handler);
2063 visitor.m_caller = this;
2064 visitor.m_outputDir = m_outputDir;
2065 visitor.m_featureRoots = m_featureRoots;
2066 VisitReturn ret = visitor.evaluateFileChecked(fileName, QMakeHandler::EvalAuxFile, flags);
2067 if (ret != ReturnTrue)
2068 return ret;
2069 *values = visitor.m_valuemapStack.top();
2070 ProKey qiif("QMAKE_INTERNAL_INCLUDED_FILES");
2071 ProStringList &iif = m_valuemapStack.front()[qiif];
2072 const auto ifns = values->value(qiif);
2073 for (const ProString &ifn : ifns)
2074 if (!iif.contains(ifn))
2075 iif << ifn;
2076 return ReturnTrue;
2077 }
2078
2079 void QMakeEvaluator::message(int type, const QString &msg) const
2080 {
2081 if (!m_skipLevel)
2082 m_handler->message(type | (m_cumulative ? QMakeHandler::CumulativeEvalMessage : 0), msg,
2083 m_current.line ? m_current.pro->fileName() : QString(),
2084 m_current.line != 0xffff ? m_current.line : -1);
2085 }
2086
2087 #ifdef PROEVALUATOR_DEBUG
2088 void QMakeEvaluator::debugMsgInternal(int level, const char *fmt, ...) const
2089 {
2090 va_list ap;
2091
2092 if (level <= m_debugLevel) {
2093 fprintf(stderr, "DEBUG %d: ", level);
2094 va_start(ap, fmt);
2095 vfprintf(stderr, fmt, ap);
2096 va_end(ap);
2097 fputc('\n', stderr);
2098 }
2099 }
2100
2101 void QMakeEvaluator::traceMsgInternal(const char *fmt, ...) const
2102 {
2103 va_list ap;
2104
2105 if (!m_current.pro)
2106 fprintf(stderr, "DEBUG 1: ");
2107 else if (m_current.line <= 0)
2108 fprintf(stderr, "DEBUG 1: %s: ", qPrintable(m_current.pro->fileName()));
2109 else
2110 fprintf(stderr, "DEBUG 1: %s:%d: ", qPrintable(m_current.pro->fileName()), m_current.line);
2111 va_start(ap, fmt);
2112 vfprintf(stderr, fmt, ap);
2113 va_end(ap);
2114 fputc('\n', stderr);
2115 }
2116
2117 QString QMakeEvaluator::formatValue(const ProString &val, bool forceQuote)
2118 {
2119 QString ret;
2120 ret.reserve(val.size() + 2);
2121 const QChar *chars = val.constData();
2122 bool quote = forceQuote || val.isEmpty();
2123 for (int i = 0, l = val.size(); i < l; i++) {
2124 QChar c = chars[i];
2125 ushort uc = c.unicode();
2126 if (uc < 32) {
2127 switch (uc) {
2128 case '\r':
2129 ret += QLatin1String("\\r");
2130 break;
2131 case '\n':
2132 ret += QLatin1String("\\n");
2133 break;
2134 case '\t':
2135 ret += QLatin1String("\\t");
2136 break;
2137 default:
2138 ret += QString::fromLatin1("\\x%1").arg(uc, 2, 16, QLatin1Char('0'));
2139 break;
2140 }
2141 } else {
2142 switch (uc) {
2143 case '\\':
2144 ret += QLatin1String("\\\\");
2145 break;
2146 case '"':
2147 ret += QLatin1String("\\\"");
2148 break;
2149 case '\'':
2150 ret += QLatin1String("\\'");
2151 break;
2152 case 32:
2153 quote = true;
2154 Q_FALLTHROUGH();
2155 default:
2156 ret += c;
2157 break;
2158 }
2159 }
2160 }
2161 if (quote) {
2162 ret.prepend(QLatin1Char('"'));
2163 ret.append(QLatin1Char('"'));
2164 }
2165 return ret;
2166 }
2167
2168 QString QMakeEvaluator::formatValueList(const ProStringList &vals, bool commas)
2169 {
2170 QString ret;
2171
2172 for (const ProString &str : vals) {
2173 if (!ret.isEmpty()) {
2174 if (commas)
2175 ret += QLatin1Char(',');
2176 ret += QLatin1Char(' ');
2177 }
2178 ret += formatValue(str);
2179 }
2180 return ret;
2181 }
2182
2183 QString QMakeEvaluator::formatValueListList(const QList<ProStringList> &lists)
2184 {
2185 QString ret;
2186
2187 for (const ProStringList &list : lists) {
2188 if (!ret.isEmpty())
2189 ret += QLatin1String(", ");
2190 ret += formatValueList(list);
2191 }
2192 return ret;
2193 }
2194 #endif
2195
2196 QT_END_NAMESPACE