1 /****************************************************************************
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
7 ** This file is part of the qmake application of the Qt Toolkit.
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
45 #include "cachekeys.h"
46 #include "generators/metamakefile.h"
48 #include <qdatetime.h>
50 #include <qfileinfo.h>
53 #include <qtextstream.h>
59 #include <sys/utsname.h>
60 #elif defined(Q_OS_WIN32)
67 #define QT_POPEN _popen
68 #define QT_PCLOSE _pclose
70 #define QT_POPEN popen
71 #define QT_PCLOSE pclose
77 enum ExpandFunc { E_MEMBER=1, E_FIRST, E_LAST, E_CAT, E_FROMFILE, E_EVAL, E_LIST,
78 E_SPRINTF, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION,
79 E_FIND, E_SYSTEM, E_UNIQUE, E_QUOTE, E_ESCAPE_EXPAND,
80 E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,
81 E_SIZE, E_SORT_DEPENDS, E_RESOLVE_DEPENDS };
82 QMap<QString, ExpandFunc> qmake_expandFunctions()
84 static QMap<QString, ExpandFunc> *qmake_expand_functions = 0;
85 if(!qmake_expand_functions) {
86 qmake_expand_functions = new QMap<QString, ExpandFunc>;
87 qmakeAddCacheClear(qmakeDeleteCacheClear<QMap<QString, ExpandFunc> >, (void**)&qmake_expand_functions);
88 qmake_expand_functions->insert("member", E_MEMBER);
89 qmake_expand_functions->insert("first", E_FIRST);
90 qmake_expand_functions->insert("last", E_LAST);
91 qmake_expand_functions->insert("cat", E_CAT);
92 qmake_expand_functions->insert("fromfile", E_FROMFILE);
93 qmake_expand_functions->insert("eval", E_EVAL);
94 qmake_expand_functions->insert("list", E_LIST);
95 qmake_expand_functions->insert("sprintf", E_SPRINTF);
96 qmake_expand_functions->insert("join", E_JOIN);
97 qmake_expand_functions->insert("split", E_SPLIT);
98 qmake_expand_functions->insert("basename", E_BASENAME);
99 qmake_expand_functions->insert("dirname", E_DIRNAME);
100 qmake_expand_functions->insert("section", E_SECTION);
101 qmake_expand_functions->insert("find", E_FIND);
102 qmake_expand_functions->insert("system", E_SYSTEM);
103 qmake_expand_functions->insert("unique", E_UNIQUE);
104 qmake_expand_functions->insert("quote", E_QUOTE);
105 qmake_expand_functions->insert("escape_expand", E_ESCAPE_EXPAND);
106 qmake_expand_functions->insert("upper", E_UPPER);
107 qmake_expand_functions->insert("lower", E_LOWER);
108 qmake_expand_functions->insert("re_escape", E_RE_ESCAPE);
109 qmake_expand_functions->insert("files", E_FILES);
110 qmake_expand_functions->insert("prompt", E_PROMPT);
111 qmake_expand_functions->insert("replace", E_REPLACE);
112 qmake_expand_functions->insert("size", E_SIZE);
113 qmake_expand_functions->insert("sort_depends", E_SORT_DEPENDS);
114 qmake_expand_functions->insert("resolve_depends", E_RESOLVE_DEPENDS);
116 return *qmake_expand_functions;
119 enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,
120 T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,
121 T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,
122 T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,
123 T_MESSAGE, T_WARNING, T_IF, T_OPTION };
124 QMap<QString, TestFunc> qmake_testFunctions()
126 static QMap<QString, TestFunc> *qmake_test_functions = 0;
127 if(!qmake_test_functions) {
128 qmake_test_functions = new QMap<QString, TestFunc>;
129 qmake_test_functions->insert("requires", T_REQUIRES);
130 qmake_test_functions->insert("greaterThan", T_GREATERTHAN);
131 qmake_test_functions->insert("lessThan", T_LESSTHAN);
132 qmake_test_functions->insert("equals", T_EQUALS);
133 qmake_test_functions->insert("isEqual", T_EQUALS);
134 qmake_test_functions->insert("exists", T_EXISTS);
135 qmake_test_functions->insert("export", T_EXPORT);
136 qmake_test_functions->insert("clear", T_CLEAR);
137 qmake_test_functions->insert("unset", T_UNSET);
138 qmake_test_functions->insert("eval", T_EVAL);
139 qmake_test_functions->insert("CONFIG", T_CONFIG);
140 qmake_test_functions->insert("if", T_IF);
141 qmake_test_functions->insert("isActiveConfig", T_CONFIG);
142 qmake_test_functions->insert("system", T_SYSTEM);
143 qmake_test_functions->insert("return", T_RETURN);
144 qmake_test_functions->insert("break", T_BREAK);
145 qmake_test_functions->insert("next", T_NEXT);
146 qmake_test_functions->insert("defined", T_DEFINED);
147 qmake_test_functions->insert("contains", T_CONTAINS);
148 qmake_test_functions->insert("infile", T_INFILE);
149 qmake_test_functions->insert("count", T_COUNT);
150 qmake_test_functions->insert("isEmpty", T_ISEMPTY);
151 qmake_test_functions->insert("include", T_INCLUDE);
152 qmake_test_functions->insert("load", T_LOAD);
153 qmake_test_functions->insert("debug", T_DEBUG);
154 qmake_test_functions->insert("error", T_ERROR);
155 qmake_test_functions->insert("message", T_MESSAGE);
156 qmake_test_functions->insert("warning", T_WARNING);
157 qmake_test_functions->insert("option", T_OPTION);
159 return *qmake_test_functions;
168 static QString remove_quotes(const QString &arg)
170 const ushort SINGLEQUOTE = '\'';
171 const ushort DOUBLEQUOTE = '"';
173 const QChar *arg_data = arg.data();
174 const ushort first = arg_data->unicode();
175 const int arg_len = arg.length();
176 if(first == SINGLEQUOTE || first == DOUBLEQUOTE) {
177 const ushort last = (arg_data+arg_len-1)->unicode();
179 return arg.mid(1, arg_len-2);
184 static QString varMap(const QString &x)
187 if(ret == "INTERFACES")
189 else if(ret == "QMAKE_POST_BUILD")
190 ret = "QMAKE_POST_LINK";
191 else if(ret == "TARGETDEPS")
192 ret = "POST_TARGETDEPS";
193 else if(ret == "LIBPATH")
194 ret = "QMAKE_LIBDIR";
195 else if(ret == "QMAKE_EXT_MOC")
196 ret = "QMAKE_EXT_CPP_MOC";
197 else if(ret == "QMAKE_MOD_MOC")
198 ret = "QMAKE_H_MOD_MOC";
199 else if(ret == "QMAKE_LFLAGS_SHAPP")
200 ret = "QMAKE_LFLAGS_APP";
201 else if(ret == "PRECOMPH")
202 ret = "PRECOMPILED_HEADER";
203 else if(ret == "PRECOMPCPP")
204 ret = "PRECOMPILED_SOURCE";
205 else if(ret == "INCPATH")
207 else if(ret == "QMAKE_EXTRA_WIN_COMPILERS" || ret == "QMAKE_EXTRA_UNIX_COMPILERS")
208 ret = "QMAKE_EXTRA_COMPILERS";
209 else if(ret == "QMAKE_EXTRA_WIN_TARGETS" || ret == "QMAKE_EXTRA_UNIX_TARGETS")
210 ret = "QMAKE_EXTRA_TARGETS";
211 else if(ret == "QMAKE_EXTRA_UNIX_INCLUDES")
212 ret = "QMAKE_EXTRA_INCLUDES";
213 else if(ret == "QMAKE_EXTRA_UNIX_VARIABLES")
214 ret = "QMAKE_EXTRA_VARIABLES";
215 else if(ret == "QMAKE_RPATH")
216 ret = "QMAKE_LFLAGS_RPATH";
217 else if(ret == "QMAKE_FRAMEWORKDIR")
218 ret = "QMAKE_FRAMEWORKPATH";
219 else if(ret == "QMAKE_FRAMEWORKDIR_FLAGS")
220 ret = "QMAKE_FRAMEWORKPATH_FLAGS";
223 warn_msg(WarnDeprecated, "%s:%d: Variable %s is deprecated; use %s instead.",
224 parser.file.toLatin1().constData(), parser.line_no,
225 x.toLatin1().constData(), ret.toLatin1().constData());
229 static QStringList split_arg_list(const QString ¶ms)
234 const ushort LPAREN = '(';
235 const ushort RPAREN = ')';
236 const ushort SINGLEQUOTE = '\'';
237 const ushort DOUBLEQUOTE = '"';
238 const ushort BACKSLASH = '\\';
239 const ushort COMMA = ',';
240 const ushort SPACE = ' ';
241 //const ushort TAB = '\t';
243 const QChar *params_data = params.data();
244 const int params_len = params.length();
245 for(int last = 0; ;) {
246 while(last < params_len && (params_data[last].unicode() == SPACE
247 /*|| params_data[last].unicode() == TAB*/))
249 for(int x = last, parens = 0; ; x++) {
250 if(x == params_len) {
251 while(x > last && params_data[x-1].unicode() == SPACE)
253 args << params.mid(last, x - last);
254 // Could do a check for unmatched parens here, but split_value_list()
255 // is called on all our output, so mistakes will be caught anyway.
258 ushort unicode = params_data[x].unicode();
259 if(x != (int)params_len-1 && unicode == BACKSLASH &&
260 (params_data[x+1].unicode() == SINGLEQUOTE || params_data[x+1].unicode() == DOUBLEQUOTE)) {
261 x++; //get that 'escape'
262 } else if(quote && unicode == quote) {
264 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
266 } else if(unicode == RPAREN) {
268 } else if(unicode == LPAREN) {
271 if(!parens && !quote && unicode == COMMA) {
274 while(x > prev && params_data[x-1].unicode() == SPACE)
276 args << params.mid(prev, x - prev);
283 static QStringList split_value_list(const QString &vals)
290 const ushort LPAREN = '(';
291 const ushort RPAREN = ')';
292 const ushort SINGLEQUOTE = '\'';
293 const ushort DOUBLEQUOTE = '"';
294 const ushort BACKSLASH = '\\';
297 const QChar *vals_data = vals.data();
298 const int vals_len = vals.length();
299 for(int x = 0; x < vals_len; x++) {
300 unicode = vals_data[x].unicode();
301 if(x != (int)vals_len-1 && unicode == BACKSLASH &&
302 (vals_data[x+1].unicode() == SINGLEQUOTE || vals_data[x+1].unicode() == DOUBLEQUOTE)) {
303 build += vals_data[x++]; //get that 'escape'
304 } else if(quote && unicode == quote) {
306 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
308 } else if(unicode == RPAREN) {
310 } else if(unicode == LPAREN) {
314 if(!parens && !quote && (vals_data[x] == Option::field_sep)) {
318 build += vals_data[x];
324 warn_msg(WarnDeprecated, "%s:%d: Unmatched parentheses are deprecated.",
325 parser.file.toLatin1().constData(), parser.line_no);
326 // Could do a check for unmatched quotes here, but doVariableReplaceExpand()
327 // is called on all our output, so mistakes will be caught anyway.
331 //just a parsable entity
334 ParsableBlock() : ref_cnt(1) { }
335 virtual ~ParsableBlock() { }
340 Parse(const QString &t) : text(t){ pi = parser; }
342 QList<Parse> parselist;
344 inline int ref() { return ++ref_cnt; }
345 inline int deref() { return --ref_cnt; }
349 virtual bool continueBlock() = 0;
350 bool eval(QMakeProject *p, QMap<QString, QStringList> &place);
353 bool ParsableBlock::eval(QMakeProject *p, QMap<QString, QStringList> &place)
356 parser_info pi = parser;
357 const int block_count = p->scope_blocks.count();
361 for(int i = 0; i < parselist.count(); i++) {
362 parser = parselist.at(i).pi;
363 if(!(ret = p->parse(parselist.at(i).text, place)) || !continueBlock())
369 while(p->scope_blocks.count() > block_count)
370 p->scope_blocks.pop();
375 struct FunctionBlock : public ParsableBlock
377 FunctionBlock() : calling_place(0), scope_level(1), cause_return(false) { }
379 QMap<QString, QStringList> vars;
380 QMap<QString, QStringList> *calling_place;
381 QStringList return_value;
385 bool exec(const QList<QStringList> &args,
386 QMakeProject *p, QMap<QString, QStringList> &place, QStringList &functionReturn);
387 virtual bool continueBlock() { return !cause_return; }
390 bool FunctionBlock::exec(const QList<QStringList> &args,
391 QMakeProject *proj, QMap<QString, QStringList> &place,
392 QStringList &functionReturn)
396 calling_place = &place;
398 calling_place = &proj->variables();
400 return_value.clear();
401 cause_return = false;
405 vars = proj->variables(); // should be place so that local variables can be inherited
409 vars["ARGS"].clear();
410 for(int i = 0; i < args.count(); i++) {
411 vars["ARGS"] += args[i];
412 vars[QString::number(i+1)] = args[i];
414 bool ret = ParsableBlock::eval(proj, vars);
415 functionReturn = return_value;
419 return_value.clear();
425 struct IteratorBlock : public ParsableBlock
427 IteratorBlock() : scope_level(1), loop_forever(false), cause_break(false), cause_next(false) { }
436 Test(const QString &f, QStringList &a, bool i) : func(f), args(a), invert(i) { pi = parser; }
442 bool loop_forever, cause_break, cause_next;
445 bool exec(QMakeProject *p, QMap<QString, QStringList> &place);
446 virtual bool continueBlock() { return !cause_next && !cause_break; }
448 bool IteratorBlock::exec(QMakeProject *p, QMap<QString, QStringList> &place)
451 QStringList::Iterator it;
454 int iterate_count = 0;
456 IteratorBlock *saved_iterator = p->iterator;
460 while(loop_forever || it != list.end()) {
461 cause_next = cause_break = false;
462 if(!loop_forever && (*it).isEmpty()) { //ignore empty items
467 //set up the loop variable
469 if(!variable.isEmpty()) {
470 va = place[variable];
472 place[variable] = QStringList(QString::number(iterate_count));
474 place[variable] = QStringList(*it);
478 for(QList<Test>::Iterator test_it = test.begin(); test_it != test.end(); ++test_it) {
479 parser = (*test_it).pi;
480 succeed = p->doProjectTest((*test_it).func, (*test_it).args, place);
481 if((*test_it).invert)
487 ret = ParsableBlock::eval(p, place);
488 //restore the variable in the map
489 if(!variable.isEmpty())
490 place[variable] = va;
495 if(!ret || cause_break)
500 p->iterator = saved_iterator;
504 QMakeProject::ScopeBlock::~ScopeBlock()
512 static void qmake_error_msg(const QString &msg)
514 fprintf(stderr, "%s:%d: %s\n", parser.file.toLatin1().constData(), parser.line_no,
515 msg.toLatin1().constData());
519 1) environment variable QMAKEFEATURES (as separated by colons)
520 2) property variable QMAKEFEATURES (as separated by colons)
521 3) <project_root> (where .qmake.cache lives) + FEATURES_DIR
522 4) environment variable QMAKEPATH (as separated by colons) + /mkspecs/FEATURES_DIR
523 5) your QMAKESPEC/features dir
524 6) your data_install/mkspecs/FEATURES_DIR
525 7) your QMAKESPEC/../FEATURES_DIR dir
527 FEATURES_DIR is defined as:
529 1) features/(unix|win32|macx)/
532 QStringList qmake_feature_paths(QMakeProperty *prop=0)
536 const QString base_concat = QDir::separator() + QString("features");
537 switch(Option::target_mode) {
538 case Option::TARG_MACX_MODE: //also a unix
539 concat << base_concat + QDir::separator() + "mac";
540 concat << base_concat + QDir::separator() + "macx";
541 concat << base_concat + QDir::separator() + "unix";
543 default: // Can't happen, just make the compiler shut up
544 case Option::TARG_UNIX_MODE:
545 concat << base_concat + QDir::separator() + "unix";
547 case Option::TARG_WIN_MODE:
548 concat << base_concat + QDir::separator() + "win32";
551 concat << base_concat;
553 const QString mkspecs_concat = QDir::separator() + QString("mkspecs");
554 QStringList feature_roots;
555 QByteArray mkspec_path = qgetenv("QMAKEFEATURES");
556 if(!mkspec_path.isNull())
557 feature_roots += splitPathList(QString::fromLocal8Bit(mkspec_path));
559 feature_roots += splitPathList(prop->value("QMAKEFEATURES"));
560 if(!Option::mkfile::cachefile.isEmpty()) {
562 int last_slash = Option::mkfile::cachefile.lastIndexOf(QDir::separator());
564 path = Option::fixPathToLocalOS(Option::mkfile::cachefile.left(last_slash), false);
565 for(QStringList::Iterator concat_it = concat.begin();
566 concat_it != concat.end(); ++concat_it)
567 feature_roots << (path + (*concat_it));
569 QByteArray qmakepath = qgetenv("QMAKEPATH");
570 if (!qmakepath.isNull()) {
571 const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));
572 for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it) {
573 for(QStringList::Iterator concat_it = concat.begin();
574 concat_it != concat.end(); ++concat_it)
575 feature_roots << ((*it) + mkspecs_concat + (*concat_it));
578 if(!Option::mkfile::qmakespec.isEmpty())
579 feature_roots << Option::mkfile::qmakespec + QDir::separator() + "features";
580 if(!Option::mkfile::qmakespec.isEmpty()) {
581 QFileInfo specfi(Option::mkfile::qmakespec);
582 QDir specdir(specfi.absoluteFilePath());
583 while(!specdir.isRoot()) {
584 if(!specdir.cdUp() || specdir.isRoot())
586 if(QFile::exists(specdir.path() + QDir::separator() + "features")) {
587 for(QStringList::Iterator concat_it = concat.begin();
588 concat_it != concat.end(); ++concat_it)
589 feature_roots << (specdir.path() + (*concat_it));
594 for(QStringList::Iterator concat_it = concat.begin();
595 concat_it != concat.end(); ++concat_it)
596 feature_roots << (QLibraryInfo::location(QLibraryInfo::PrefixPath) +
597 mkspecs_concat + (*concat_it));
598 for(QStringList::Iterator concat_it = concat.begin();
599 concat_it != concat.end(); ++concat_it)
600 feature_roots << (QLibraryInfo::location(QLibraryInfo::DataPath) +
601 mkspecs_concat + (*concat_it));
602 return feature_roots;
605 QStringList qmake_mkspec_paths()
608 const QString concat = QDir::separator() + QString("mkspecs");
609 QByteArray qmakepath = qgetenv("QMAKEPATH");
610 if (!qmakepath.isEmpty()) {
611 const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));
612 for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it)
613 ret << ((*it) + concat);
615 ret << QLibraryInfo::location(QLibraryInfo::DataPath) + concat;
620 QMakeProject::~QMakeProject()
624 for(QMap<QString, FunctionBlock*>::iterator it = replaceFunctions.begin(); it != replaceFunctions.end(); ++it) {
625 if(!it.value()->deref())
628 replaceFunctions.clear();
629 for(QMap<QString, FunctionBlock*>::iterator it = testFunctions.begin(); it != testFunctions.end(); ++it) {
630 if(!it.value()->deref())
633 testFunctions.clear();
638 QMakeProject::init(QMakeProperty *p, const QMap<QString, QStringList> *vars)
643 prop = new QMakeProperty;
653 QMakeProject::QMakeProject(QMakeProject *p, const QMap<QString, QStringList> *vars)
655 init(p->properties(), vars ? vars : &p->variables());
656 for(QMap<QString, FunctionBlock*>::iterator it = p->replaceFunctions.begin(); it != p->replaceFunctions.end(); ++it) {
658 replaceFunctions.insert(it.key(), it.value());
660 for(QMap<QString, FunctionBlock*>::iterator it = p->testFunctions.begin(); it != p->testFunctions.end(); ++it) {
662 testFunctions.insert(it.key(), it.value());
667 QMakeProject::reset()
669 // scope_blocks starts with one non-ignoring entity
670 scope_blocks.clear();
671 scope_blocks.push(ScopeBlock());
674 backslashWarned = false;
678 QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int numLines)
680 // To preserve the integrity of any UTF-8 characters in .pro file, temporarily replace the
681 // non-breaking space (0xA0) characters with another non-space character, so that
682 // QString::simplified() call will not replace it with space.
683 // Note: There won't be any two byte characters in .pro files, so 0x10A0 should be a safe
684 // replacement character.
685 static QChar nbsp(0xA0);
686 static QChar nbspFix(0x01A0);
688 if (t.indexOf(nbsp) != -1) {
690 s.replace(nbsp, nbspFix);
692 s.replace(nbspFix, nbsp);
697 int hash_mark = s.indexOf("#");
698 if(hash_mark != -1) //good bye comments
699 s = s.left(hash_mark);
700 if(s.isEmpty()) // blank_line
703 if(scope_blocks.top().ignore) {
704 bool continue_parsing = false;
705 // adjust scope for each block which appears on a single line
706 for(int i = 0; i < s.length(); i++) {
708 scope_blocks.push(ScopeBlock(true));
709 } else if(s[i] == '}') {
710 if(scope_blocks.count() == 1) {
711 fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
714 ScopeBlock sb = scope_blocks.pop();
716 sb.iterate->exec(this, place);
720 if(!scope_blocks.top().ignore) {
721 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
722 parser.line_no, scope_blocks.count()+1);
723 s = s.mid(i+1).trimmed();
724 continue_parsing = !s.isEmpty();
729 if(!continue_parsing) {
730 debug_msg(1, "Project Parser: %s:%d : Ignored due to block being false.",
731 parser.file.toLatin1().constData(), parser.line_no);
739 const QChar *d = s.unicode();
740 bool function_finished = false;
741 while(d_off < s.length()) {
742 if(*(d+d_off) == QLatin1Char('}')) {
743 function->scope_level--;
744 if(!function->scope_level) {
745 function_finished = true;
748 } else if(*(d+d_off) == QLatin1Char('{')) {
749 function->scope_level++;
751 append += *(d+d_off);
754 if(!append.isEmpty())
755 function->parselist.append(IteratorBlock::Parse(append));
756 if(function_finished) {
758 s = QString(d+d_off, s.length()-d_off);
762 } else if(IteratorBlock *it = scope_blocks.top().iterate) {
765 const QChar *d = s.unicode();
766 bool iterate_finished = false;
767 while(d_off < s.length()) {
768 if(*(d+d_off) == QLatin1Char('}')) {
770 if(!it->scope_level) {
771 iterate_finished = true;
774 } else if(*(d+d_off) == QLatin1Char('{')) {
777 append += *(d+d_off);
780 if(!append.isEmpty())
781 scope_blocks.top().iterate->parselist.append(IteratorBlock::Parse(append));
782 if(iterate_finished) {
783 scope_blocks.top().iterate = 0;
784 bool ret = it->exec(this, place);
794 QString scope, var, op;
796 #define SKIP_WS(d, o, l) while(o < l && (*(d+o) == QLatin1Char(' ') || *(d+o) == QLatin1Char('\t'))) ++o
797 const QChar *d = s.unicode();
799 SKIP_WS(d, d_off, s.length());
800 IteratorBlock *iterator = 0;
801 bool scope_failed = false, else_line = false, or_op=false;
803 int parens = 0, scope_count=0, start_block = 0;
804 while(d_off < s.length()) {
806 if(*(d+d_off) == QLatin1Char('='))
808 if(*(d+d_off) == QLatin1Char('+') || *(d+d_off) == QLatin1Char('-') ||
809 *(d+d_off) == QLatin1Char('*') || *(d+d_off) == QLatin1Char('~')) {
810 if(*(d+d_off+1) == QLatin1Char('=')) {
812 } else if(*(d+d_off+1) == QLatin1Char(' ')) {
813 const QChar *k = d+d_off+1;
815 SKIP_WS(k, k_off, s.length()-d_off);
816 if(*(k+k_off) == QLatin1Char('=')) {
818 qmake_error_msg(QString(d+d_off, 1) + "must be followed immediately by =");
825 if(!quote.isNull()) {
826 if(*(d+d_off) == quote)
828 } else if(*(d+d_off) == '(') {
830 } else if(*(d+d_off) == ')') {
832 } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {
836 if(!parens && quote.isNull() &&
837 (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('{') ||
838 *(d+d_off) == QLatin1Char(')') || *(d+d_off) == QLatin1Char('|'))) {
840 scope = var.trimmed();
841 if(*(d+d_off) == QLatin1Char(')'))
842 scope += *(d+d_off); // need this
845 bool test = scope_failed;
846 if(scope.isEmpty()) {
848 } else if(scope.toLower() == "else") { //else is a builtin scope here as it modifies state
849 if(scope_count != 1 || scope_blocks.top().else_status == ScopeBlock::TestNone) {
850 qmake_error_msg(("Unexpected " + scope + " ('" + s + "')").toLatin1());
854 test = (scope_blocks.top().else_status == ScopeBlock::TestSeek);
855 debug_msg(1, "Project Parser: %s:%d : Else%s %s.", parser.file.toLatin1().constData(), parser.line_no,
856 scope == "else" ? "" : QString(" (" + scope + ")").toLatin1().constData(),
857 test ? "considered" : "excluded");
859 QString comp_scope = scope;
860 bool invert_test = (comp_scope.at(0) == QLatin1Char('!'));
862 comp_scope = comp_scope.mid(1);
863 int lparen = comp_scope.indexOf('(');
864 if(or_op == scope_failed) {
865 if(lparen != -1) { // if there is an lparen in the scope, it IS a function
866 int rparen = comp_scope.lastIndexOf(')');
868 qmake_error_msg("Function missing right paren: " + comp_scope);
871 QString func = comp_scope.left(lparen);
872 QStringList args = split_arg_list(comp_scope.mid(lparen+1, rparen - lparen - 1));
874 fprintf(stderr, "%s:%d: No tests can come after a function definition!\n",
875 parser.file.toLatin1().constData(), parser.line_no);
877 } else if(func == "for") { //for is a builtin function here, as it modifies state
878 if(args.count() > 2 || args.count() < 1) {
879 fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",
880 parser.file.toLatin1().constData(), parser.line_no);
882 } else if(iterator) {
883 fprintf(stderr, "%s:%d unexpected nested for()\n",
884 parser.file.toLatin1().constData(), parser.line_no);
888 iterator = new IteratorBlock;
890 if(args.count() == 1) {
891 doVariableReplace(args[0], place);
893 if(args[0] != "ever") {
896 fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",
897 parser.file.toLatin1().constData(), parser.line_no);
901 } else if(args.count() == 2) {
902 iterator->variable = args[0];
903 doVariableReplace(args[1], place);
906 QStringList list = place[it_list];
908 if(it_list == "forever") {
909 iterator->loop_forever = true;
911 int dotdot = it_list.indexOf("..");
914 int start = it_list.left(dotdot).toInt(&ok);
916 int end = it_list.mid(dotdot+2).toInt(&ok);
919 for(int i = start; i <= end; i++)
920 list << QString::number(i);
922 for(int i = start; i >= end; i--)
923 list << QString::number(i);
930 iterator->list = list;
932 } else if(iterator) {
933 iterator->test.append(IteratorBlock::Test(func, args, invert_test));
935 } else if(func == "defineTest" || func == "defineReplace") {
936 if(!function_blocks.isEmpty()) {
938 "%s:%d: cannot define a function within another definition.\n",
939 parser.file.toLatin1().constData(), parser.line_no);
942 if(args.count() != 1) {
943 fprintf(stderr, "%s:%d: %s(function_name) requires one argument.\n",
944 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
947 QMap<QString, FunctionBlock*> *map = 0;
948 if(func == "defineTest")
949 map = &testFunctions;
951 map = &replaceFunctions;
953 if(!map || map->contains(args[0])) {
954 fprintf(stderr, "%s:%d: Function[%s] multiply defined.\n",
955 parser.file.toLatin1().constData(), parser.line_no, args[0].toLatin1().constData());
959 function = new FunctionBlock;
960 map->insert(args[0], function);
963 test = doProjectTest(func, args, place);
964 if(*(d+d_off) == QLatin1Char(')') && d_off == s.length()-1) {
967 scope_blocks.top().else_status =
968 (test ? ScopeBlock::TestFound : ScopeBlock::TestSeek);
969 return true; // assume we are done
973 QString cscope = comp_scope.trimmed();
974 doVariableReplace(cscope, place);
975 test = isActiveConfig(cscope.trimmed(), true, &place);
981 if(!test && !scope_failed)
982 debug_msg(1, "Project Parser: %s:%d : Test (%s) failed.", parser.file.toLatin1().constData(),
983 parser.line_no, scope.toLatin1().constData());
985 scope_failed = !test;
986 or_op = (*(d+d_off) == QLatin1Char('|'));
988 if(*(d+d_off) == QLatin1Char('{')) { // scoping block
991 for(int off = 0, braces = 0; true; ++off) {
992 if(*(d+d_off+off) == QLatin1Char('{'))
994 else if(*(d+d_off+off) == QLatin1Char('}') && braces)
996 if(!braces || d_off+off == s.length()) {
997 iterator->parselist.append(s.mid(d_off, off-1));
999 iterator->scope_level += braces-1;
1006 } else if(!parens && *(d+d_off) == QLatin1Char('}')) {
1009 } else if(!scope_blocks.count()) {
1010 warn_msg(WarnParser, "Possible braces mismatch %s:%d", parser.file.toLatin1().constData(), parser.line_no);
1012 if(scope_blocks.count() == 1) {
1013 fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
1016 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
1017 parser.line_no, scope_blocks.count());
1018 ScopeBlock sb = scope_blocks.pop();
1020 sb.iterate->exec(this, place);
1027 var = var.trimmed();
1029 if(!else_line || (else_line && !scope_failed))
1030 scope_blocks.top().else_status = (!scope_failed ? ScopeBlock::TestFound : ScopeBlock::TestSeek);
1032 ScopeBlock next_block(scope_failed);
1033 next_block.iterate = iterator;
1035 next_block.else_status = ScopeBlock::TestNone;
1036 else if(scope_failed)
1037 next_block.else_status = ScopeBlock::TestSeek;
1039 next_block.else_status = ScopeBlock::TestFound;
1040 scope_blocks.push(next_block);
1041 debug_msg(1, "Project Parser: %s:%d : Entering block %d (%d). [%s]", parser.file.toLatin1().constData(),
1042 parser.line_no, scope_blocks.count(), scope_failed, s.toLatin1().constData());
1043 } else if(iterator) {
1044 iterator->parselist.append(var+s.mid(d_off));
1045 bool ret = iterator->exec(this, place);
1050 if((!scope_count && !var.isEmpty()) || (scope_count == 1 && else_line))
1051 scope_blocks.top().else_status = ScopeBlock::TestNone;
1052 if(d_off == s.length()) {
1053 if(!var.trimmed().isEmpty())
1054 qmake_error_msg(("Parse Error ('" + s + "')").toLatin1());
1055 return var.isEmpty(); // allow just a scope
1058 SKIP_WS(d, d_off, s.length());
1059 for(; d_off < s.length() && op.indexOf('=') == -1; op += *(d+(d_off++)))
1061 op.replace(QRegExp("\\s"), "");
1063 SKIP_WS(d, d_off, s.length());
1064 QString vals = s.mid(d_off); // vals now contains the space separated list of values
1065 int rbraces = vals.count('}'), lbraces = vals.count('{');
1066 if(scope_blocks.count() > 1 && rbraces - lbraces == 1 && vals.endsWith('}')) {
1067 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
1068 parser.line_no, scope_blocks.count());
1069 ScopeBlock sb = scope_blocks.pop();
1071 sb.iterate->exec(this, place);
1072 vals.truncate(vals.length()-1);
1073 } else if(rbraces != lbraces) {
1074 warn_msg(WarnParser, "Possible braces mismatch {%s} %s:%d",
1075 vals.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1078 return true; // oh well
1081 doVariableReplace(var, place);
1082 var = varMap(var); //backwards compatibility
1083 if(!var.isEmpty() && Option::mkfile::do_preprocess) {
1084 static QString last_file("*none*");
1085 if(parser.file != last_file) {
1086 fprintf(stdout, "#file %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
1087 last_file = parser.file;
1089 fprintf(stdout, "%s %s %s\n", var.toLatin1().constData(), op.toLatin1().constData(), vals.toLatin1().constData());
1092 if(vals.contains('=') && numLines > 1)
1093 warn_msg(WarnParser, "Possible accidental line continuation: {%s} at %s:%d",
1094 var.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1096 QStringList &varlist = place[var]; // varlist is the list in the symbol table
1098 if(Option::debug_level >= 1) {
1099 QString tmp_vals = vals;
1100 doVariableReplace(tmp_vals, place);
1101 debug_msg(1, "Project Parser: %s:%d :%s: :%s: (%s)", parser.file.toLatin1().constData(), parser.line_no,
1102 var.toLatin1().constData(), op.toLatin1().constData(), tmp_vals.toLatin1().constData());
1105 // now do the operation
1107 doVariableReplace(vals, place);
1108 if(vals.length() < 4 || vals.at(0) != 's') {
1109 qmake_error_msg(("~= operator only can handle s/// function ('" +
1110 s + "')").toLatin1());
1113 QChar sep = vals.at(1);
1114 QStringList func = vals.split(sep);
1115 if(func.count() < 3 || func.count() > 4) {
1116 qmake_error_msg(("~= operator only can handle s/// function ('" +
1117 s + "')").toLatin1());
1120 bool global = false, case_sense = true, quote = false;
1121 if(func.count() == 4) {
1122 global = func[3].indexOf('g') != -1;
1123 case_sense = func[3].indexOf('i') == -1;
1124 quote = func[3].indexOf('q') != -1;
1126 QString from = func[1], to = func[2];
1128 from = QRegExp::escape(from);
1129 QRegExp regexp(from, case_sense ? Qt::CaseSensitive : Qt::CaseInsensitive);
1130 for(QStringList::Iterator varit = varlist.begin(); varit != varlist.end();) {
1131 if((*varit).contains(regexp)) {
1132 (*varit) = (*varit).replace(regexp, to);
1133 if ((*varit).isEmpty())
1134 varit = varlist.erase(varit);
1143 QStringList vallist;
1145 //doVariableReplace(vals, place);
1146 QStringList tmp = split_value_list(vals);
1147 for(int i = 0; i < tmp.size(); ++i)
1148 vallist += doVariableReplaceExpand(tmp[i], place);
1152 if(!varlist.isEmpty()) {
1153 bool send_warning = false;
1154 if(var != "TEMPLATE" && var != "TARGET") {
1155 QSet<QString> incoming_vals = vallist.toSet();
1156 for(int i = 0; i < varlist.size(); ++i) {
1157 const QString var = varlist.at(i).trimmed();
1158 if(!var.isEmpty() && !incoming_vals.contains(var)) {
1159 send_warning = true;
1165 warn_msg(WarnParser, "Operator=(%s) clears variables previously set: %s:%d",
1166 var.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1170 for(QStringList::ConstIterator valit = vallist.begin();
1171 valit != vallist.end(); ++valit) {
1172 if((*valit).isEmpty())
1174 if((op == "*=" && !varlist.contains((*valit))) ||
1175 op == "=" || op == "+=")
1176 varlist.append((*valit));
1178 varlist.removeAll((*valit));
1180 if(var == "REQUIRES") // special case to get communicated to backends!
1181 doProjectCheckReqs(vallist, place);
1187 QMakeProject::read(QTextStream &file, QMap<QString, QStringList> &place)
1192 while(!file.atEnd()) {
1194 QString line = file.readLine().trimmed();
1195 int prelen = line.length();
1197 int hash_mark = line.indexOf("#");
1198 if(hash_mark != -1) //good bye comments
1199 line = line.left(hash_mark).trimmed();
1200 if(!line.isEmpty() && line.right(1) == "\\") {
1201 if(!line.startsWith("#")) {
1202 line.truncate(line.length() - 1);
1203 s += line + Option::field_sep;
1206 } else if(!line.isEmpty() || (line.isEmpty() && !prelen)) {
1207 if(s.isEmpty() && line.isEmpty())
1209 if(!line.isEmpty()) {
1214 if(!(ret = parse(s, place, numLines))) {
1225 ret = parse(s, place, numLines);
1230 QMakeProject::read(const QString &file, QMap<QString, QStringList> &place)
1232 parser_info pi = parser;
1235 const QString oldpwd = qmake_getpwd();
1236 QString filename = Option::fixPathToLocalOS(file, false);
1237 bool ret = false, using_stdin = false;
1239 if(!strcmp(filename.toLatin1(), "-")) {
1240 qfile.setFileName("");
1241 ret = qfile.open(stdin, QIODevice::ReadOnly);
1243 } else if(QFileInfo(file).isDir()) {
1246 qfile.setFileName(filename);
1247 ret = qfile.open(QIODevice::ReadOnly);
1248 qmake_setpwd(QFileInfo(filename).absolutePath());
1251 parser_info pi = parser;
1252 parser.from_file = true;
1253 parser.file = filename;
1255 QTextStream t(&qfile);
1256 ret = read(t, place);
1260 if(scope_blocks.count() != 1) {
1261 qmake_error_msg("Unterminated conditional block at end of file");
1265 qmake_setpwd(oldpwd);
1270 QMakeProject::read(const QString &project, uchar cmd)
1272 pfile = QFileInfo(project).absoluteFilePath();
1277 QMakeProject::read(uchar cmd)
1279 if(cfile.isEmpty()) {
1280 // hack to get the Option stuff in there
1281 base_vars["QMAKE_EXT_CPP"] = Option::cpp_ext;
1282 base_vars["QMAKE_EXT_C"] = Option::c_ext;
1283 base_vars["QMAKE_EXT_H"] = Option::h_ext;
1284 base_vars["QMAKE_SH"] = Option::shellPath;
1285 if(!Option::user_template_prefix.isEmpty())
1286 base_vars["TEMPLATE_PREFIX"] = QStringList(Option::user_template_prefix);
1288 if(cmd & ReadCache && Option::mkfile::do_cache) { // parse the cache
1289 int cache_depth = -1;
1290 QString qmake_cache = Option::mkfile::cachefile;
1291 if(qmake_cache.isEmpty()) { //find it as it has not been specified
1292 QString dir = QDir::toNativeSeparators(Option::output_dir);
1293 while(!QFile::exists((qmake_cache = dir + QDir::separator() + ".qmake.cache"))) {
1294 dir = dir.left(dir.lastIndexOf(QDir::separator()));
1295 if(dir.isEmpty() || dir.indexOf(QDir::separator()) == -1) {
1299 if(cache_depth == -1)
1305 QString abs_cache = QFileInfo(Option::mkfile::cachefile).absoluteDir().path();
1306 if(Option::output_dir.startsWith(abs_cache))
1307 cache_depth = Option::output_dir.mid(abs_cache.length()).count('/');
1309 if(!qmake_cache.isEmpty()) {
1310 if(read(qmake_cache, cache)) {
1311 Option::mkfile::cachefile_depth = cache_depth;
1312 Option::mkfile::cachefile = qmake_cache;
1313 if(Option::mkfile::qmakespec.isEmpty() && !cache["QMAKESPEC"].isEmpty())
1314 Option::mkfile::qmakespec = cache["QMAKESPEC"].first();
1318 if(cmd & ReadConf) { // parse mkspec
1319 QString qmakespec = fixEnvVariables(Option::mkfile::qmakespec);
1320 QStringList mkspec_roots = qmake_mkspec_paths();
1321 debug_msg(2, "Looking for mkspec %s in (%s)", qmakespec.toLatin1().constData(),
1322 mkspec_roots.join("::").toLatin1().constData());
1323 if(qmakespec.isEmpty()) {
1324 for(QStringList::ConstIterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
1325 QString mkspec = (*it) + QDir::separator() + "default";
1326 QFileInfo default_info(mkspec);
1327 if(default_info.exists() && default_info.isDir()) {
1332 if(qmakespec.isEmpty()) {
1333 fprintf(stderr, "QMAKESPEC has not been set, so configuration cannot be deduced.\n");
1336 Option::mkfile::qmakespec = qmakespec;
1339 if(QDir::isRelativePath(qmakespec)) {
1340 if (QFile::exists(Option::output_dir+"/"+qmakespec+"/qmake.conf")) {
1341 qmakespec = Option::mkfile::qmakespec = QFileInfo(Option::output_dir+"/"+qmakespec).absoluteFilePath();
1342 } else if (QFile::exists(qmakespec+"/qmake.conf")) {
1343 Option::mkfile::qmakespec = QFileInfo(Option::mkfile::qmakespec).absoluteFilePath();
1345 bool found_mkspec = false;
1346 for(QStringList::ConstIterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
1347 QString mkspec = (*it) + QDir::separator() + qmakespec;
1348 if(QFile::exists(mkspec)) {
1349 found_mkspec = true;
1350 Option::mkfile::qmakespec = qmakespec = mkspec;
1355 fprintf(stderr, "Could not find mkspecs for your QMAKESPEC(%s) after trying:\n\t%s\n",
1356 qmakespec.toLatin1().constData(), mkspec_roots.join("\n\t").toLatin1().constData());
1362 // parse qmake configuration
1363 while(qmakespec.endsWith(QString(QChar(QDir::separator()))))
1364 qmakespec.truncate(qmakespec.length()-1);
1365 QString spec = qmakespec + QDir::separator() + "qmake.conf";
1366 debug_msg(1, "QMAKESPEC conf: reading %s", spec.toLatin1().constData());
1367 if(!read(spec, base_vars)) {
1368 fprintf(stderr, "Failure to read QMAKESPEC conf file %s.\n", spec.toLatin1().constData());
1373 if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty()) {
1374 debug_msg(1, "QMAKECACHE file: reading %s", Option::mkfile::cachefile.toLatin1().constData());
1375 read(Option::mkfile::cachefile, base_vars);
1380 vars = base_vars; // start with the base
1382 if(cmd & ReadFeatures) {
1383 debug_msg(1, "Processing default_pre: %s", vars["CONFIG"].join("::").toLatin1().constData());
1384 doProjectInclude("default_pre", IncludeFlagFeature, vars);
1388 if(pfile != "-" && vars["TARGET"].isEmpty())
1389 vars["TARGET"].append(QFileInfo(pfile).baseName());
1391 //before commandline
1392 if(cmd & ReadCmdLine) {
1394 parser.file = "(internal)";
1395 parser.from_file = false;
1396 parser.line_no = 1; //really arg count now.. duh
1398 for(QStringList::ConstIterator it = Option::before_user_vars.begin();
1399 it != Option::before_user_vars.end(); ++it) {
1400 if(!parse((*it), vars)) {
1401 fprintf(stderr, "Argument failed to parse: %s\n", (*it).toLatin1().constData());
1408 //commandline configs
1409 if(cmd & ReadConfigs && !Option::user_configs.isEmpty()) {
1410 parser.file = "(configs)";
1411 parser.from_file = false;
1412 parser.line_no = 1; //really arg count now.. duh
1413 parse("CONFIG += " + Option::user_configs.join(" "), vars);
1416 if(cmd & ReadProFile) { // parse project file
1417 debug_msg(1, "Project file: reading %s", pfile.toLatin1().constData());
1418 if(pfile != "-" && !QFile::exists(pfile) && !pfile.endsWith(Option::pro_ext))
1419 pfile += Option::pro_ext;
1420 if(!read(pfile, vars))
1424 if(cmd & ReadCmdLine) {
1425 parser.file = "(internal)";
1426 parser.from_file = false;
1427 parser.line_no = 1; //really arg count now.. duh
1429 for(QStringList::ConstIterator it = Option::after_user_vars.begin();
1430 it != Option::after_user_vars.end(); ++it) {
1431 if(!parse((*it), vars)) {
1432 fprintf(stderr, "Argument failed to parse: %s\n", (*it).toLatin1().constData());
1439 //after configs (set in BUILDS)
1440 if(cmd & ReadConfigs && !Option::after_user_configs.isEmpty()) {
1441 parser.file = "(configs)";
1442 parser.from_file = false;
1443 parser.line_no = 1; //really arg count now.. duh
1444 parse("CONFIG += " + Option::after_user_configs.join(" "), vars);
1447 if(pfile != "-" && vars["TARGET"].isEmpty())
1448 vars["TARGET"].append(QFileInfo(pfile).baseName());
1450 if(cmd & ReadConfigs && !Option::user_configs.isEmpty()) {
1451 parser.file = "(configs)";
1452 parser.from_file = false;
1453 parser.line_no = 1; //really arg count now.. duh
1454 parse("CONFIG += " + Option::user_configs.join(" "), base_vars);
1457 if(cmd & ReadFeatures) {
1458 debug_msg(1, "Processing default_post: %s", vars["CONFIG"].join("::").toLatin1().constData());
1459 doProjectInclude("default_post", IncludeFlagFeature, vars);
1461 QHash<QString, bool> processed;
1462 const QStringList &configs = vars["CONFIG"];
1463 debug_msg(1, "Processing CONFIG features: %s", configs.join("::").toLatin1().constData());
1465 bool finished = true;
1466 for(int i = configs.size()-1; i >= 0; --i) {
1467 const QString config = configs[i].toLower();
1468 if(!processed.contains(config)) {
1469 processed.insert(config, true);
1470 if(doProjectInclude(config, IncludeFlagFeature, vars) == IncludeSuccess) {
1480 Option::postProcessProject(this); // let Option post-process
1484 void QMakeProject::validateModes()
1486 if (Option::host_mode == Option::HOST_UNKNOWN_MODE
1487 || Option::target_mode == Option::TARG_UNKNOWN_MODE) {
1488 Option::HOST_MODE host_mode;
1489 Option::TARG_MODE target_mode;
1490 const QStringList &gen = base_vars.value("MAKEFILE_GENERATOR");
1491 if (gen.isEmpty()) {
1492 fprintf(stderr, "%s:%d: Using OS scope before setting MAKEFILE_GENERATOR\n",
1493 parser.file.toLatin1().constData(), parser.line_no);
1494 } else if (MetaMakefileGenerator::modesForGenerator(gen.first(),
1495 &host_mode, &target_mode)) {
1496 if (Option::host_mode == Option::HOST_UNKNOWN_MODE) {
1497 Option::host_mode = host_mode;
1498 Option::applyHostMode();
1501 if (Option::target_mode == Option::TARG_UNKNOWN_MODE) {
1502 const QStringList &tgt = base_vars.value("TARGET_PLATFORM");
1503 if (!tgt.isEmpty()) {
1504 const QString &os = tgt.first();
1506 Option::target_mode = Option::TARG_UNIX_MODE;
1507 else if (os == "macx")
1508 Option::target_mode = Option::TARG_MACX_MODE;
1509 else if (os == "win32")
1510 Option::target_mode = Option::TARG_WIN_MODE;
1512 fprintf(stderr, "Unknown target platform specified: %s\n",
1513 os.toLatin1().constData());
1515 Option::target_mode = target_mode;
1523 QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QStringList> *place)
1528 //magic types for easy flipping
1531 else if(x == "false")
1536 return Option::target_mode == Option::TARG_UNIX_MODE
1537 || Option::target_mode == Option::TARG_MACX_MODE;
1538 } else if (x == "macx" || x == "mac") {
1540 return Option::target_mode == Option::TARG_MACX_MODE;
1541 } else if (x == "win32") {
1543 return Option::target_mode == Option::TARG_WIN_MODE;
1547 static QString spec;
1549 spec = QFileInfo(Option::mkfile::qmakespec).fileName();
1550 QRegExp re(x, Qt::CaseSensitive, QRegExp::Wildcard);
1551 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1554 else if(spec == "default") {
1555 static char *buffer = NULL;
1557 buffer = (char *)malloc(1024);
1558 qmakeAddCacheClear(qmakeFreeCacheClear, (void**)&buffer);
1560 int l = readlink(Option::mkfile::qmakespec.toLatin1(), buffer, 1024);
1564 if(r.lastIndexOf('/') != -1)
1565 r = r.mid(r.lastIndexOf('/') + 1);
1566 if((regex && re.exactMatch(r)) || (!regex && r == x))
1570 #elif defined(Q_OS_WIN)
1571 else if(spec == "default") {
1572 // We can't resolve symlinks as they do on Unix, so configure.exe puts the source of the
1573 // qmake.conf at the end of the default/qmake.conf in the QMAKESPEC_ORG variable.
1574 const QStringList &spec_org = (place ? (*place)["QMAKESPEC_ORIGINAL"]
1575 : vars["QMAKESPEC_ORIGINAL"]);
1576 if (!spec_org.isEmpty()) {
1577 spec = spec_org.at(0);
1578 int lastSlash = spec.lastIndexOf('/');
1580 spec = spec.mid(lastSlash + 1);
1581 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1588 const QStringList &configs = (place ? (*place)["CONFIG"] : vars["CONFIG"]);
1589 for(QStringList::ConstIterator it = configs.begin(); it != configs.end(); ++it) {
1590 if(((regex && re.exactMatch((*it))) || (!regex && (*it) == x)) && re.exactMatch((*it)))
1597 QMakeProject::doProjectTest(QString str, QMap<QString, QStringList> &place)
1599 QString chk = remove_quotes(str);
1602 bool invert_test = (chk.left(1) == "!");
1607 int lparen = chk.indexOf('(');
1608 if(lparen != -1) { // if there is an lparen in the chk, it IS a function
1609 int rparen = chk.indexOf(')', lparen);
1611 qmake_error_msg("Function missing right paren: " + chk);
1613 QString func = chk.left(lparen);
1614 test = doProjectTest(func, chk.mid(lparen+1, rparen - lparen - 1), place);
1617 test = isActiveConfig(chk, true, &place);
1625 QMakeProject::doProjectTest(QString func, const QString ¶ms,
1626 QMap<QString, QStringList> &place)
1628 return doProjectTest(func, split_arg_list(params), place);
1631 QMakeProject::IncludeStatus
1632 QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringList> &place)
1634 enum { UnknownFormat, ProFormat, JSFormat } format = UnknownFormat;
1635 if(flags & IncludeFlagFeature) {
1636 if(!file.endsWith(Option::prf_ext))
1637 file += Option::prf_ext;
1638 validateModes(); // init dir_sep
1639 if(file.indexOf(Option::dir_sep) == -1 || !QFile::exists(file)) {
1640 static QStringList *feature_roots = 0;
1641 if(!feature_roots) {
1642 feature_roots = new QStringList(qmake_feature_paths(prop));
1643 qmakeAddCacheClear(qmakeDeleteCacheClear<QStringList>, (void**)&feature_roots);
1645 debug_msg(2, "Looking for feature '%s' in (%s)", file.toLatin1().constData(),
1646 feature_roots->join("::").toLatin1().constData());
1648 if(parser.from_file) {
1649 QFileInfo currFile(parser.file), prfFile(file);
1650 if(currFile.fileName() == prfFile.fileName()) {
1651 currFile = QFileInfo(currFile.canonicalFilePath());
1652 for(int root = 0; root < feature_roots->size(); ++root) {
1653 prfFile = QFileInfo(feature_roots->at(root) +
1654 QDir::separator() + file).canonicalFilePath();
1655 if(prfFile == currFile) {
1656 start_root = root+1;
1662 for(int root = start_root; root < feature_roots->size(); ++root) {
1663 QString prf(feature_roots->at(root) + QDir::separator() + file);
1664 if(QFile::exists(prf + Option::js_ext)) {
1666 file = prf + Option::js_ext;
1668 } else if(QFile::exists(prf)) {
1674 if(format == UnknownFormat)
1675 return IncludeNoExist;
1677 if(place["QMAKE_INTERNAL_INCLUDED_FEATURES"].indexOf(file) != -1)
1678 return IncludeFeatureAlreadyLoaded;
1679 place["QMAKE_INTERNAL_INCLUDED_FEATURES"].append(file);
1681 if(QDir::isRelativePath(file)) {
1682 QStringList include_roots;
1683 if(Option::output_dir != qmake_getpwd())
1684 include_roots << qmake_getpwd();
1685 include_roots << Option::output_dir;
1686 for(int root = 0; root < include_roots.size(); ++root) {
1687 QString testName = QDir::toNativeSeparators(include_roots[root]);
1688 if (!testName.endsWith(QString(QDir::separator())))
1689 testName += QDir::separator();
1691 if(QFile::exists(testName)) {
1697 if(format == UnknownFormat) {
1698 if(QFile::exists(file)) {
1699 if(file.endsWith(Option::js_ext))
1704 return IncludeNoExist;
1707 if(Option::mkfile::do_preprocess) //nice to see this first..
1708 fprintf(stderr, "#switching file %s(%s) - %s:%d\n", (flags & IncludeFlagFeature) ? "load" : "include",
1709 file.toLatin1().constData(),
1710 parser.file.toLatin1().constData(), parser.line_no);
1711 debug_msg(1, "Project Parser: %s'ing file %s.", (flags & IncludeFlagFeature) ? "load" : "include",
1712 file.toLatin1().constData());
1714 QString orig_file = file;
1715 int di = file.lastIndexOf(QDir::separator());
1716 QString oldpwd = qmake_getpwd();
1718 if(!qmake_setpwd(file.left(file.lastIndexOf(QDir::separator())))) {
1719 fprintf(stderr, "Cannot find directory: %s\n", file.left(di).toLatin1().constData());
1720 return IncludeFailure;
1723 bool parsed = false;
1724 parser_info pi = parser;
1725 if(format == JSFormat) {
1726 warn_msg(WarnParser, "%s:%d: QtScript support disabled for %s.",
1727 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1729 QStack<ScopeBlock> sc = scope_blocks;
1730 IteratorBlock *it = iterator;
1731 FunctionBlock *fu = function;
1732 if(flags & (IncludeFlagNewProject|IncludeFlagNewParser)) {
1733 // The "project's variables" are used in other places (eg. export()) so it's not
1734 // possible to use "place" everywhere. Instead just set variables and grab them later
1735 QMakeProject proj(this, &place);
1736 if(flags & IncludeFlagNewParser) {
1738 if(proj.doProjectInclude("default_pre", IncludeFlagFeature, proj.variables()) == IncludeNoExist)
1739 proj.doProjectInclude("default", IncludeFlagFeature, proj.variables());
1741 parsed = proj.read(file, proj.variables()); // parse just that file (fromfile, infile)
1743 parsed = proj.read(file); // parse all aux files (load/include into)
1745 place = proj.variables();
1747 parsed = read(file, place);
1754 if(place["QMAKE_INTERNAL_INCLUDED_FILES"].indexOf(orig_file) == -1)
1755 place["QMAKE_INTERNAL_INCLUDED_FILES"].append(orig_file);
1757 warn_msg(WarnParser, "%s:%d: Failure to include file %s.",
1758 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1761 qmake_setpwd(oldpwd);
1763 return IncludeParseFailure;
1764 return IncludeSuccess;
1768 QMakeProject::doProjectExpand(QString func, const QString ¶ms,
1769 QMap<QString, QStringList> &place)
1771 return doProjectExpand(func, split_arg_list(params), place);
1775 QMakeProject::doProjectExpand(QString func, QStringList args,
1776 QMap<QString, QStringList> &place)
1778 QList<QStringList> args_list;
1779 for(int i = 0; i < args.size(); ++i) {
1780 QStringList arg = split_value_list(args[i]), tmp;
1781 for(int i = 0; i < arg.size(); ++i)
1782 tmp += doVariableReplaceExpand(arg[i], place);;
1785 return doProjectExpand(func, args_list, place);
1789 populateDeps(const QStringList &deps, const QString &prefix,
1790 QHash<QString, QSet<QString> > &dependencies, QHash<QString, QStringList> &dependees,
1791 QStringList &rootSet, QMap<QString, QStringList> &place)
1793 foreach (const QString &item, deps)
1794 if (!dependencies.contains(item)) {
1795 QSet<QString> &dset = dependencies[item]; // Always create entry
1796 QStringList depends = place.value(prefix + item + ".depends");
1797 if (depends.isEmpty()) {
1800 foreach (const QString &dep, depends) {
1802 dependees[dep] << item;
1804 populateDeps(depends, prefix, dependencies, dependees, rootSet, place);
1810 QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
1811 QMap<QString, QStringList> &place)
1813 func = func.trimmed();
1814 if(replaceFunctions.contains(func)) {
1815 FunctionBlock *defined = replaceFunctions[func];
1816 function_blocks.push(defined);
1818 defined->exec(args_list, this, place, ret);
1819 Q_ASSERT(function_blocks.pop() == defined);
1823 QStringList args; //why don't the builtin functions just use args_list? --Sam
1824 for(int i = 0; i < args_list.size(); ++i)
1825 args += args_list[i].join(QString(Option::field_sep));
1827 ExpandFunc func_t = qmake_expandFunctions().value(func);
1828 if (!func_t && (func_t = qmake_expandFunctions().value(func.toLower())))
1829 warn_msg(WarnDeprecated, "%s:%d: Using uppercased builtin functions is deprecated.",
1830 parser.file.toLatin1().constData(), parser.line_no);
1831 debug_msg(1, "Running project expand: %s(%s) [%d]",
1832 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
1837 if(args.count() < 1 || args.count() > 3) {
1838 fprintf(stderr, "%s:%d: member(var, start, end) requires three arguments.\n",
1839 parser.file.toLatin1().constData(), parser.line_no);
1842 const QStringList &var = values(args.first(), place);
1843 int start = 0, end = 0;
1844 if(args.count() >= 2) {
1845 QString start_str = args[1];
1846 start = start_str.toInt(&ok);
1848 if(args.count() == 2) {
1849 int dotdot = start_str.indexOf("..");
1851 start = start_str.left(dotdot).toInt(&ok);
1853 end = start_str.mid(dotdot+2).toInt(&ok);
1857 fprintf(stderr, "%s:%d: member() argument 2 (start) '%s' invalid.\n",
1858 parser.file.toLatin1().constData(), parser.line_no,
1859 start_str.toLatin1().constData());
1862 if(args.count() == 3)
1863 end = args[2].toInt(&ok);
1865 fprintf(stderr, "%s:%d: member() argument 3 (end) '%s' invalid.\n",
1866 parser.file.toLatin1().constData(), parser.line_no,
1867 args[2].toLatin1().constData());
1872 start += var.count();
1875 if(start < 0 || start >= var.count() || end < 0 || end >= var.count()) {
1877 } else if(start < end) {
1878 for(int i = start; i <= end && (int)var.count() >= i; i++)
1881 for(int i = start; i >= end && (int)var.count() >= i && i >= 0; i--)
1889 if(args.count() != 1) {
1890 fprintf(stderr, "%s:%d: %s(var) requires one argument.\n",
1891 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
1893 const QStringList &var = values(args.first(), place);
1894 if(!var.isEmpty()) {
1895 if(func_t == E_FIRST)
1896 ret = QStringList(var[0]);
1898 ret = QStringList(var[var.size()-1]);
1903 if(args.count() < 1 || args.count() > 2) {
1904 fprintf(stderr, "%s:%d: cat(file) requires one argument.\n",
1905 parser.file.toLatin1().constData(), parser.line_no);
1907 QString file = args[0];
1908 file = Option::fixPathToLocalOS(file);
1910 bool singleLine = true;
1911 if(args.count() > 1)
1912 singleLine = (args[1].toLower() == "true");
1915 if(qfile.open(QIODevice::ReadOnly)) {
1916 QTextStream stream(&qfile);
1917 while(!stream.atEnd()) {
1918 ret += split_value_list(stream.readLine().trimmed());
1927 if(args.count() != 2) {
1928 fprintf(stderr, "%s:%d: fromfile(file, variable) requires two arguments.\n",
1929 parser.file.toLatin1().constData(), parser.line_no);
1931 QString file = args[0], seek_var = args[1];
1932 file = Option::fixPathToLocalOS(file);
1934 QMap<QString, QStringList> tmp;
1935 if(doProjectInclude(file, IncludeFlagNewParser, tmp) == IncludeSuccess) {
1936 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
1937 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
1938 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
1939 for(int i = 0; i < in.size(); ++i) {
1940 if(out.indexOf(in[i]) == -1)
1944 ret = tmp[seek_var];
1949 if(args.count() < 1 || args.count() > 2) {
1950 fprintf(stderr, "%s:%d: eval(variable) requires one argument.\n",
1951 parser.file.toLatin1().constData(), parser.line_no);
1954 const QMap<QString, QStringList> *source = &place;
1955 if(args.count() == 2) {
1956 if(args.at(1) == "Global") {
1958 } else if(args.at(1) == "Local") {
1961 fprintf(stderr, "%s:%d: unexpected source to eval.\n", parser.file.toLatin1().constData(),
1965 ret += source->value(args.at(0));
1971 tmp.sprintf(".QMAKE_INTERNAL_TMP_VAR_%d", x++);
1972 ret = QStringList(tmp);
1973 QStringList &lst = (*((QMap<QString, QStringList>*)&place))[tmp];
1975 for(QStringList::ConstIterator arg_it = args.begin();
1976 arg_it != args.end(); ++arg_it)
1977 lst += split_value_list((*arg_it));
1980 if(args.count() < 1) {
1981 fprintf(stderr, "%s:%d: sprintf(format, ...) requires one argument.\n",
1982 parser.file.toLatin1().constData(), parser.line_no);
1984 QString tmp = args.at(0);
1985 for(int i = 1; i < args.count(); ++i)
1986 tmp = tmp.arg(args.at(i));
1987 ret = split_value_list(tmp);
1991 if(args.count() < 1 || args.count() > 4) {
1992 fprintf(stderr, "%s:%d: join(var, glue, before, after) requires four"
1993 "arguments.\n", parser.file.toLatin1().constData(), parser.line_no);
1995 QString glue, before, after;
1996 if(args.count() >= 2)
1998 if(args.count() >= 3)
2000 if(args.count() == 4)
2002 const QStringList &var = values(args.first(), place);
2004 ret = split_value_list(before + var.join(glue) + after);
2008 if(args.count() < 1 || args.count() > 2) {
2009 fprintf(stderr, "%s:%d split(var, sep) requires one or two arguments\n",
2010 parser.file.toLatin1().constData(), parser.line_no);
2012 QString sep = QString(Option::field_sep);
2013 if(args.count() >= 2)
2015 QStringList var = values(args.first(), place);
2016 for(QStringList::ConstIterator vit = var.begin(); vit != var.end(); ++vit) {
2017 QStringList lst = (*vit).split(sep);
2018 for(QStringList::ConstIterator spltit = lst.begin(); spltit != lst.end(); ++spltit)
2026 bool regexp = false;
2029 if(func_t == E_SECTION) {
2030 if(args.count() != 3 && args.count() != 4) {
2031 fprintf(stderr, "%s:%d section(var, sep, begin, end) requires three argument\n",
2032 parser.file.toLatin1().constData(), parser.line_no);
2036 beg = args[2].toInt();
2037 if(args.count() == 4)
2038 end = args[3].toInt();
2041 if(args.count() != 1) {
2042 fprintf(stderr, "%s:%d %s(var) requires one argument.\n",
2043 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
2047 sep = "[" + QRegExp::escape(Option::dir_sep) + "/]";
2048 if(func_t == E_DIRNAME)
2055 const QStringList &l = values(var, place);
2056 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2057 QString separator = sep;
2059 ret += (*it).section(QRegExp(separator), beg, end);
2061 ret += (*it).section(separator, beg, end);
2066 if(args.count() != 2) {
2067 fprintf(stderr, "%s:%d find(var, str) requires two arguments\n",
2068 parser.file.toLatin1().constData(), parser.line_no);
2070 QRegExp regx(args[1]);
2071 const QStringList &var = values(args.first(), place);
2072 for(QStringList::ConstIterator vit = var.begin();
2073 vit != var.end(); ++vit) {
2074 if(regx.indexIn(*vit) != -1)
2080 if(args.count() < 1 || args.count() > 2) {
2081 fprintf(stderr, "%s:%d system(execut) requires one argument.\n",
2082 parser.file.toLatin1().constData(), parser.line_no);
2085 bool singleLine = true;
2086 if(args.count() > 1)
2087 singleLine = (args[1].toLower() == "true");
2089 FILE *proc = QT_POPEN(args[0].toLatin1(), "r");
2090 while(proc && !feof(proc)) {
2091 int read_in = int(fread(buff, 1, 255, proc));
2094 for(int i = 0; i < read_in; i++) {
2095 if((singleLine && buff[i] == '\n') || buff[i] == '\t')
2098 buff[read_in] = '\0';
2101 ret += split_value_list(output);
2107 if(args.count() != 1) {
2108 fprintf(stderr, "%s:%d unique(var) requires one argument.\n",
2109 parser.file.toLatin1().constData(), parser.line_no);
2111 const QStringList &var = values(args.first(), place);
2112 for(int i = 0; i < var.count(); i++) {
2113 if(!ret.contains(var[i]))
2121 case E_ESCAPE_EXPAND: {
2122 for(int i = 0; i < args.size(); ++i) {
2123 QChar *i_data = args[i].data();
2124 int i_len = args[i].length();
2125 for(int x = 0; x < i_len; ++x) {
2126 if(*(i_data+x) == '\\' && x < i_len-1) {
2127 if(*(i_data+x+1) == '\\') {
2132 } mapped_quotes[] = {
2138 for(int i = 0; mapped_quotes[i].in; ++i) {
2139 if(*(i_data+x+1) == mapped_quotes[i].in) {
2140 *(i_data+x) = mapped_quotes[i].out;
2142 memmove(i_data+x+1, i_data+x+2, (i_len-x-2)*sizeof(QChar));
2150 ret.append(QString(i_data, i_len));
2154 for(int i = 0; i < args.size(); ++i)
2155 ret += QRegExp::escape(args[i]);
2159 for(int i = 0; i < args.size(); ++i) {
2160 if(func_t == E_UPPER)
2161 ret += args[i].toUpper();
2163 ret += args[i].toLower();
2167 if(args.count() != 1 && args.count() != 2) {
2168 fprintf(stderr, "%s:%d files(pattern) requires one argument.\n",
2169 parser.file.toLatin1().constData(), parser.line_no);
2171 bool recursive = false;
2172 if(args.count() == 2)
2173 recursive = (args[1].toLower() == "true" || args[1].toInt());
2175 QString r = Option::fixPathToLocalOS(args[0]);
2176 int slash = r.lastIndexOf(QDir::separator());
2178 dirs.append(r.left(slash));
2184 const QRegExp regex(r, Qt::CaseSensitive, QRegExp::Wildcard);
2185 for(int d = 0; d < dirs.count(); d++) {
2186 QString dir = dirs[d];
2187 if(!dir.isEmpty() && !dir.endsWith(QDir::separator()))
2191 for(int i = 0; i < (int)qdir.count(); ++i) {
2192 if(qdir[i] == "." || qdir[i] == "..")
2194 QString fname = dir + qdir[i];
2195 if(QFileInfo(fname).isDir()) {
2199 if(regex.exactMatch(qdir[i]))
2206 if(args.count() != 1) {
2207 fprintf(stderr, "%s:%d prompt(question) requires one argument.\n",
2208 parser.file.toLatin1().constData(), parser.line_no);
2209 } else if(pfile == "-") {
2210 fprintf(stderr, "%s:%d prompt(question) cannot be used when '-o -' is used.\n",
2211 parser.file.toLatin1().constData(), parser.line_no);
2213 QString msg = fixEnvVariables(args.first());
2214 if(!msg.endsWith("?"))
2216 fprintf(stderr, "Project %s: %s ", func.toUpper().toLatin1().constData(),
2217 msg.toLatin1().constData());
2220 if(qfile.open(stdin, QIODevice::ReadOnly)) {
2221 QTextStream t(&qfile);
2222 ret = split_value_list(t.readLine());
2227 if(args.count() != 3 ) {
2228 fprintf(stderr, "%s:%d replace(var, before, after) requires three arguments\n",
2229 parser.file.toLatin1().constData(), parser.line_no);
2231 const QRegExp before( args[1] );
2232 const QString after( args[2] );
2233 QStringList var = values(args.first(), place);
2234 for(QStringList::Iterator it = var.begin(); it != var.end(); ++it)
2235 ret += it->replace(before, after);
2239 if(args.count() != 1) {
2240 fprintf(stderr, "%s:%d: size(var) requires one argument.\n",
2241 parser.file.toLatin1().constData(), parser.line_no);
2243 int size = values(args[0], place).size();
2244 ret += QString::number(size);
2247 case E_SORT_DEPENDS:
2248 case E_RESOLVE_DEPENDS: {
2249 if(args.count() < 1 || args.count() > 2) {
2250 fprintf(stderr, "%s:%d: %s(var, prefix) requires one or two arguments.\n",
2251 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
2253 QHash<QString, QSet<QString> > dependencies;
2254 QHash<QString, QStringList> dependees;
2255 QStringList rootSet;
2257 QStringList orgList = values(args[0], place);
2258 populateDeps(orgList, (args.count() != 2 ? QString() : args[1]),
2259 dependencies, dependees, rootSet, place);
2261 for (int i = 0; i < rootSet.size(); ++i) {
2262 const QString &item = rootSet.at(i);
2263 if ((func_t == E_RESOLVE_DEPENDS) || orgList.contains(item))
2265 foreach (const QString &dep, dependees[item]) {
2266 QSet<QString> &dset = dependencies[dep];
2267 dset.remove(rootSet.at(i)); // *Don't* use 'item' - rootSet may have changed!
2275 fprintf(stderr, "%s:%d: Unknown replace function: %s\n",
2276 parser.file.toLatin1().constData(), parser.line_no,
2277 func.toLatin1().constData());
2284 QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStringList> &place)
2286 QList<QStringList> args_list;
2287 for(int i = 0; i < args.size(); ++i) {
2288 QStringList arg = split_value_list(args[i]), tmp;
2289 for(int i = 0; i < arg.size(); ++i)
2290 tmp += doVariableReplaceExpand(arg[i], place);
2293 return doProjectTest(func, args_list, place);
2297 QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QString, QStringList> &place)
2299 func = func.trimmed();
2301 if(testFunctions.contains(func)) {
2302 FunctionBlock *defined = testFunctions[func];
2304 function_blocks.push(defined);
2305 defined->exec(args_list, this, place, ret);
2306 Q_ASSERT(function_blocks.pop() == defined);
2311 if(ret.first() == "true") {
2313 } else if(ret.first() == "false") {
2317 int val = ret.first().toInt(&ok);
2320 fprintf(stderr, "%s:%d Unexpected return value from test %s [%s].\n",
2321 parser.file.toLatin1().constData(),
2322 parser.line_no, func.toLatin1().constData(),
2323 ret.join("::").toLatin1().constData());
2330 QStringList args; //why don't the builtin functions just use args_list? --Sam
2331 for(int i = 0; i < args_list.size(); ++i)
2332 args += args_list[i].join(QString(Option::field_sep));
2334 TestFunc func_t = qmake_testFunctions().value(func);
2335 debug_msg(1, "Running project test: %s(%s) [%d]",
2336 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
2340 return doProjectCheckReqs(args, place);
2342 case T_GREATERTHAN: {
2343 if(args.count() != 2) {
2344 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2345 parser.line_no, func.toLatin1().constData());
2348 QString rhs(args[1]), lhs(values(args[0], place).join(QString(Option::field_sep)));
2350 int rhs_int = rhs.toInt(&ok);
2351 if(ok) { // do integer compare
2352 int lhs_int = lhs.toInt(&ok);
2354 if(func_t == T_GREATERTHAN)
2355 return lhs_int > rhs_int;
2356 return lhs_int < rhs_int;
2359 if(func_t == T_GREATERTHAN)
2363 if(args.count() != 1) {
2364 fprintf(stderr, "%s:%d: if(condition) requires one argument.\n", parser.file.toLatin1().constData(),
2368 const QString cond = args.first();
2369 const QChar *d = cond.unicode();
2371 bool ret = true, or_op = false;
2373 for(int d_off = 0, parens = 0, d_len = cond.size(); d_off < d_len; ++d_off) {
2374 if(!quote.isNull()) {
2375 if(*(d+d_off) == quote)
2377 } else if(*(d+d_off) == '(') {
2379 } else if(*(d+d_off) == ')') {
2381 } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {
2384 if(!parens && quote.isNull() && (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('|') || d_off == d_len-1)) {
2385 if(d_off == d_len-1)
2387 if(!test.isEmpty()) {
2389 ret = doProjectTest(test, place);
2392 if(*(d+d_off) == QLatin1Char(':')) {
2394 } else if(*(d+d_off) == QLatin1Char('|')) {
2403 if(args.count() != 2) {
2404 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2405 parser.line_no, func.toLatin1().constData());
2408 return values(args[0], place).join(QString(Option::field_sep)) == args[1];
2410 if(args.count() != 1) {
2411 fprintf(stderr, "%s:%d: exists(file) requires one argument.\n", parser.file.toLatin1().constData(),
2415 QString file = args.first();
2416 file = Option::fixPathToLocalOS(file);
2418 if(QFile::exists(file))
2420 //regular expression I guess
2421 QString dirstr = qmake_getpwd();
2422 int slsh = file.lastIndexOf(QDir::separator());
2424 dirstr = file.left(slsh+1);
2425 file = file.right(file.length() - slsh - 1);
2427 return QDir(dirstr).entryList(QStringList(file)).count(); }
2429 if(args.count() != 1) {
2430 fprintf(stderr, "%s:%d: export(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2434 for(int i = 0; i < function_blocks.size(); ++i) {
2435 FunctionBlock *f = function_blocks.at(i);
2436 f->vars[args[0]] = values(args[0], place);
2437 if(!i && f->calling_place)
2438 (*f->calling_place)[args[0]] = values(args[0], place);
2442 if(args.count() != 1) {
2443 fprintf(stderr, "%s:%d: clear(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2447 if(!place.contains(args[0]))
2449 place[args[0]].clear();
2452 if(args.count() != 1) {
2453 fprintf(stderr, "%s:%d: unset(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2457 if(!place.contains(args[0]))
2459 place.remove(args[0]);
2462 if(args.count() < 1 && 0) {
2463 fprintf(stderr, "%s:%d: eval(project) requires one argument.\n", parser.file.toLatin1().constData(),
2467 QString project = args.join(" ");
2468 parser_info pi = parser;
2469 parser.from_file = false;
2470 parser.file = "(eval)";
2472 QTextStream t(&project, QIODevice::ReadOnly);
2473 bool ret = read(t, place);
2477 if(args.count() < 1 || args.count() > 2) {
2478 fprintf(stderr, "%s:%d: CONFIG(config) requires one argument.\n", parser.file.toLatin1().constData(),
2482 if(args.count() == 1)
2483 return isActiveConfig(args[0]);
2484 const QStringList mutuals = args[1].split('|');
2485 const QStringList &configs = values("CONFIG", place);
2486 for(int i = configs.size()-1; i >= 0; i--) {
2487 for(int mut = 0; mut < mutuals.count(); mut++) {
2488 if(configs[i] == mutuals[mut].trimmed())
2489 return (configs[i] == args[0]);
2494 if(args.count() < 1 || args.count() > 2) {
2495 fprintf(stderr, "%s:%d: system(exec) requires one argument.\n", parser.file.toLatin1().constData(),
2499 if(args.count() == 2) {
2500 const QString sarg = args[1];
2501 if (sarg.toLower() == "true" || sarg.toInt())
2502 warn_msg(WarnParser, "%s:%d: system()'s second argument is now hard-wired to false.\n",
2503 parser.file.toLatin1().constData(), parser.line_no);
2505 return system(args[0].toLatin1().constData()) == 0;
2507 if(function_blocks.isEmpty()) {
2508 fprintf(stderr, "%s:%d unexpected return()\n",
2509 parser.file.toLatin1().constData(), parser.line_no);
2511 FunctionBlock *f = function_blocks.top();
2512 f->cause_return = true;
2513 if(args_list.count() >= 1)
2514 f->return_value += args_list[0];
2519 iterator->cause_break = true;
2521 fprintf(stderr, "%s:%d unexpected break()\n",
2522 parser.file.toLatin1().constData(), parser.line_no);
2526 iterator->cause_next = true;
2528 fprintf(stderr, "%s:%d unexpected next()\n",
2529 parser.file.toLatin1().constData(), parser.line_no);
2532 if(args.count() < 1 || args.count() > 2) {
2533 fprintf(stderr, "%s:%d: defined(function) requires one argument.\n",
2534 parser.file.toLatin1().constData(), parser.line_no);
2536 if(args.count() > 1) {
2537 if(args[1] == "test")
2538 return testFunctions.contains(args[0]);
2539 else if(args[1] == "replace")
2540 return replaceFunctions.contains(args[0]);
2541 fprintf(stderr, "%s:%d: defined(function, type): unexpected type [%s].\n",
2542 parser.file.toLatin1().constData(), parser.line_no,
2543 args[1].toLatin1().constData());
2545 if(replaceFunctions.contains(args[0]) || testFunctions.contains(args[0]))
2551 if(args.count() < 2 || args.count() > 3) {
2552 fprintf(stderr, "%s:%d: contains(var, val) requires at lesat 2 arguments.\n",
2553 parser.file.toLatin1().constData(), parser.line_no);
2556 QRegExp regx(args[1]);
2557 const QStringList &l = values(args[0], place);
2558 if(args.count() == 2) {
2559 for(int i = 0; i < l.size(); ++i) {
2560 const QString val = l[i];
2561 if(regx.exactMatch(val) || val == args[1])
2565 const QStringList mutuals = args[2].split('|');
2566 for(int i = l.size()-1; i >= 0; i--) {
2567 const QString val = l[i];
2568 for(int mut = 0; mut < mutuals.count(); mut++) {
2569 if(val == mutuals[mut].trimmed())
2570 return (regx.exactMatch(val) || val == args[1]);
2576 if(args.count() < 2 || args.count() > 3) {
2577 fprintf(stderr, "%s:%d: infile(file, var, val) requires at least 2 arguments.\n",
2578 parser.file.toLatin1().constData(), parser.line_no);
2583 QMap<QString, QStringList> tmp;
2584 if(doProjectInclude(Option::fixPathToLocalOS(args[0]), IncludeFlagNewParser, tmp) == IncludeSuccess) {
2585 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
2586 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
2587 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
2588 for(int i = 0; i < in.size(); ++i) {
2589 if(out.indexOf(in[i]) == -1)
2593 if(args.count() == 2) {
2594 ret = tmp.contains(args[1]);
2596 QRegExp regx(args[2]);
2597 const QStringList &l = tmp[args[1]];
2598 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2599 if(regx.exactMatch((*it)) || (*it) == args[2]) {
2608 if(args.count() != 2 && args.count() != 3) {
2609 fprintf(stderr, "%s:%d: count(var, count) requires two arguments.\n", parser.file.toLatin1().constData(),
2613 if(args.count() == 3) {
2614 QString comp = args[2];
2615 if(comp == ">" || comp == "greaterThan")
2616 return values(args[0], place).count() > args[1].toInt();
2618 return values(args[0], place).count() >= args[1].toInt();
2619 if(comp == "<" || comp == "lessThan")
2620 return values(args[0], place).count() < args[1].toInt();
2622 return values(args[0], place).count() <= args[1].toInt();
2623 if(comp == "equals" || comp == "isEqual" || comp == "=" || comp == "==")
2624 return values(args[0], place).count() == args[1].toInt();
2625 fprintf(stderr, "%s:%d: unexpected modifier to count(%s)\n", parser.file.toLatin1().constData(),
2626 parser.line_no, comp.toLatin1().constData());
2629 return values(args[0], place).count() == args[1].toInt();
2631 if(args.count() != 1) {
2632 fprintf(stderr, "%s:%d: isEmpty(var) requires one argument.\n", parser.file.toLatin1().constData(),
2636 return values(args[0], place).isEmpty();
2640 const bool include_statement = (func_t == T_INCLUDE);
2641 bool ignore_error = false;
2642 if(args.count() >= 2) {
2643 if(func_t == T_INCLUDE) {
2644 parseInto = args[1];
2645 if (args.count() == 3){
2646 QString sarg = args[2];
2647 if (sarg.toLower() == "true" || sarg.toInt())
2648 ignore_error = true;
2651 QString sarg = args[1];
2652 ignore_error = (sarg.toLower() == "true" || sarg.toInt());
2654 } else if(args.count() != 1) {
2655 QString func_desc = "load(feature)";
2656 if(include_statement)
2657 func_desc = "include(file)";
2658 fprintf(stderr, "%s:%d: %s requires one argument.\n", parser.file.toLatin1().constData(),
2659 parser.line_no, func_desc.toLatin1().constData());
2662 QString file = args.first();
2663 file = Option::fixPathToLocalOS(file);
2664 uchar flags = IncludeFlagNone;
2665 if(!include_statement)
2666 flags |= IncludeFlagFeature;
2667 IncludeStatus stat = IncludeFailure;
2668 if(!parseInto.isEmpty()) {
2669 QMap<QString, QStringList> symbols;
2670 stat = doProjectInclude(file, flags|IncludeFlagNewProject, symbols);
2671 if(stat == IncludeSuccess) {
2672 QMap<QString, QStringList> out_place;
2673 for(QMap<QString, QStringList>::ConstIterator it = place.begin(); it != place.end(); ++it) {
2674 const QString var = it.key();
2675 if(var != parseInto && !var.startsWith(parseInto + "."))
2676 out_place.insert(var, it.value());
2678 for(QMap<QString, QStringList>::ConstIterator it = symbols.begin(); it != symbols.end(); ++it) {
2679 const QString var = it.key();
2680 if(!var.startsWith("."))
2681 out_place.insert(parseInto + "." + it.key(), it.value());
2686 stat = doProjectInclude(file, flags, place);
2688 if(stat == IncludeFeatureAlreadyLoaded) {
2689 warn_msg(WarnParser, "%s:%d: Duplicate of loaded feature %s",
2690 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
2691 } else if(stat == IncludeNoExist && !ignore_error) {
2692 warn_msg(WarnAll, "%s:%d: Unable to find file for inclusion %s",
2693 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
2695 } else if(stat >= IncludeFailure) {
2697 printf("Project LOAD(): Feature %s cannot be found.\n", file.toLatin1().constData());
2699 #if defined(QT_BUILD_QMAKE_LIBRARY)
2709 if(args.count() != 2) {
2710 fprintf(stderr, "%s:%d: debug(level, message) requires one argument.\n", parser.file.toLatin1().constData(),
2714 QString msg = fixEnvVariables(args[1]);
2715 debug_msg(args[0].toInt(), "Project DEBUG: %s", msg.toLatin1().constData());
2720 if(args.count() != 1) {
2721 fprintf(stderr, "%s:%d: %s(message) requires one argument.\n", parser.file.toLatin1().constData(),
2722 parser.line_no, func.toLatin1().constData());
2725 QString msg = fixEnvVariables(args.first());
2726 fprintf(stderr, "Project %s: %s\n", func.toUpper().toLatin1().constData(), msg.toLatin1().constData());
2728 #if defined(QT_BUILD_QMAKE_LIBRARY)
2735 if (args.count() != 1) {
2736 fprintf(stderr, "%s:%d: option() requires one argument.\n",
2737 parser.file.toLatin1().constData(), parser.line_no);
2740 if (args.first() == "recursive") {
2743 fprintf(stderr, "%s:%d: unrecognized option() argument '%s'.\n",
2744 parser.file.toLatin1().constData(), parser.line_no,
2745 args.first().toLatin1().constData());
2750 fprintf(stderr, "%s:%d: Unknown test function: %s\n", parser.file.toLatin1().constData(), parser.line_no,
2751 func.toLatin1().constData());
2757 QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringList> &place)
2760 for(QStringList::ConstIterator it = deps.begin(); it != deps.end(); ++it) {
2761 bool test = doProjectTest((*it), place);
2763 debug_msg(1, "Project Parser: %s:%d Failed test: REQUIRES = %s",
2764 parser.file.toLatin1().constData(), parser.line_no,
2765 (*it).toLatin1().constData());
2766 place["QMAKE_FAILED_REQUIREMENTS"].append((*it));
2774 QMakeProject::test(const QString &v)
2776 QMap<QString, QStringList> tmp = vars;
2777 return doProjectTest(v, tmp);
2781 QMakeProject::test(const QString &func, const QList<QStringList> &args)
2783 QMap<QString, QStringList> tmp = vars;
2784 return doProjectTest(func, args, tmp);
2788 QMakeProject::expand(const QString &str)
2791 QMap<QString, QStringList> tmp = vars;
2792 const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
2795 return QStringList();
2799 QMakeProject::expand(const QString &str, const QString &file, int line)
2802 parser_info pi = parser;
2804 parser.line_no = line;
2805 parser.from_file = false;
2806 QMap<QString, QStringList> tmp = vars;
2807 const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
2809 return ok ? ret.join(QString(Option::field_sep)) : QString();
2813 QMakeProject::expand(const QString &func, const QList<QStringList> &args)
2815 QMap<QString, QStringList> tmp = vars;
2816 return doProjectExpand(func, args, tmp);
2820 QMakeProject::doVariableReplace(QString &str, QMap<QString, QStringList> &place)
2823 str = doVariableReplaceExpand(str, place, &ret).join(QString(Option::field_sep));
2828 QMakeProject::doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok)
2836 const ushort LSQUARE = '[';
2837 const ushort RSQUARE = ']';
2838 const ushort LCURLY = '{';
2839 const ushort RCURLY = '}';
2840 const ushort LPAREN = '(';
2841 const ushort RPAREN = ')';
2842 const ushort DOLLAR = '$';
2843 const ushort SLASH = '\\';
2844 const ushort UNDERSCORE = '_';
2845 const ushort DOT = '.';
2846 const ushort SPACE = ' ';
2847 const ushort TAB = '\t';
2848 const ushort SINGLEQUOTE = '\'';
2849 const ushort DOUBLEQUOTE = '"';
2851 ushort unicode, quote = 0;
2852 const QChar *str_data = str.data();
2853 const int str_len = str.length();
2860 for(int i = 0; i < str_len; ++i) {
2861 unicode = str_data[i].unicode();
2862 const int start_var = i;
2863 if(unicode == DOLLAR && str_len > i+2) {
2864 unicode = str_data[++i].unicode();
2865 if(unicode == DOLLAR) {
2869 enum { VAR, ENVIRON, FUNCTION, PROPERTY } var_type = VAR;
2870 unicode = str_data[++i].unicode();
2871 if(unicode == LSQUARE) {
2872 unicode = str_data[++i].unicode();
2874 var_type = PROPERTY;
2875 } else if(unicode == LCURLY) {
2876 unicode = str_data[++i].unicode();
2879 } else if(unicode == LPAREN) {
2880 unicode = str_data[++i].unicode();
2885 if(!(unicode & (0xFF<<8)) &&
2886 unicode != DOT && unicode != UNDERSCORE &&
2887 //unicode != SINGLEQUOTE && unicode != DOUBLEQUOTE &&
2888 (unicode < 'a' || unicode > 'z') && (unicode < 'A' || unicode > 'Z') &&
2889 (unicode < '0' || unicode > '9'))
2891 var.append(QChar(unicode));
2894 unicode = str_data[i].unicode();
2895 // at this point, i points to either the 'term' or 'next' character (which is in unicode)
2897 if(var_type == VAR && unicode == LPAREN) {
2898 var_type = FUNCTION;
2903 unicode = str_data[i].unicode();
2904 if(unicode == LPAREN) {
2906 } else if(unicode == RPAREN) {
2911 args.append(QChar(unicode));
2914 unicode = str_data[i].unicode();
2917 // at this point i is pointing to the 'next' character (which is in unicode)
2918 // this might actually be a term character since you can do $${func()}
2921 if(unicode != term) {
2922 qmake_error_msg("Missing " + QString(term) + " terminator [found " + (unicode?QString(unicode):QString("end-of-line")) + "]");
2925 return QStringList();
2928 // move the 'cursor' back to the last char of the thing we were looking at
2931 // since i never points to the 'next' character, there is no reason for this to be set
2934 QStringList replacement;
2935 if(var_type == ENVIRON) {
2936 replacement = split_value_list(QString::fromLocal8Bit(qgetenv(var.toLatin1().constData())));
2937 } else if(var_type == PROPERTY) {
2939 replacement = split_value_list(prop->value(var));
2940 } else if(var_type == FUNCTION) {
2941 replacement = doProjectExpand(var, args, place);
2942 } else if(var_type == VAR) {
2943 replacement = values(var, place);
2945 if(!(replaced++) && start_var)
2946 current = str.left(start_var);
2947 if(!replacement.isEmpty()) {
2949 current += replacement.join(QString(Option::field_sep));
2951 current += replacement.takeFirst();
2952 if(!replacement.isEmpty()) {
2953 if(!current.isEmpty())
2954 ret.append(current);
2955 current = replacement.takeLast();
2956 if(!replacement.isEmpty())
2961 debug_msg(2, "Project Parser [var replace]: %s -> %s",
2962 str.toLatin1().constData(), var.toLatin1().constData(),
2963 replacement.join("::").toLatin1().constData());
2966 current.append("$");
2969 if(quote && unicode == quote) {
2972 } else if(unicode == SLASH) {
2973 bool escape = false;
2974 const char *symbols = "[]{}()$\\'\"";
2975 for(const char *s = symbols; *s; ++s) {
2976 if(str_data[i+1].unicode() == (ushort)*s) {
2980 current = str.left(start_var);
2981 current.append(str.at(i));
2985 if(!escape && !backslashWarned) {
2986 backslashWarned = true;
2987 warn_msg(WarnDeprecated, "%s:%d: Unescaped backslashes are deprecated.",
2988 parser.file.toLatin1().constData(), parser.line_no);
2990 if(escape || !replaced)
2992 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
2995 if(!(replaced++) && i)
2996 current = str.left(i);
2997 } else if(!quote && (unicode == SPACE || unicode == TAB)) {
2999 if(!current.isEmpty()) {
3000 ret.append(current);
3004 if(replaced && unicode)
3005 current.append(QChar(unicode));
3008 ret = QStringList(str);
3009 else if(!current.isEmpty())
3010 ret.append(current);
3011 //qDebug() << "REPLACE" << str << ret;
3013 warn_msg(WarnDeprecated, "%s:%d: Unmatched quotes are deprecated.",
3014 parser.file.toLatin1().constData(), parser.line_no);
3018 QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList> &place)
3020 QString var = varMap(_var);
3021 if(var == QLatin1String("LITERAL_WHITESPACE")) { //a real space in a token)
3022 var = ".BUILTIN." + var;
3023 place[var] = QStringList(QLatin1String("\t"));
3024 } else if(var == QLatin1String("LITERAL_DOLLAR")) { //a real $
3025 var = ".BUILTIN." + var;
3026 place[var] = QStringList(QLatin1String("$"));
3027 } else if(var == QLatin1String("LITERAL_HASH")) { //a real #
3028 var = ".BUILTIN." + var;
3029 place[var] = QStringList("#");
3030 } else if(var == QLatin1String("OUT_PWD")) { //the out going dir
3031 var = ".BUILTIN." + var;
3032 place[var] = QStringList(Option::output_dir);
3033 } else if(var == QLatin1String("PWD") || //current working dir (of _FILE_)
3034 var == QLatin1String("IN_PWD")) {
3035 var = ".BUILTIN." + var;
3036 place[var] = QStringList(qmake_getpwd());
3037 } else if(var == QLatin1String("DIR_SEPARATOR")) {
3039 var = ".BUILTIN." + var;
3040 place[var] = QStringList(Option::dir_sep);
3041 } else if(var == QLatin1String("DIRLIST_SEPARATOR")) {
3042 var = ".BUILTIN." + var;
3043 place[var] = QStringList(Option::dirlist_sep);
3044 } else if(var == QLatin1String("_LINE_")) { //parser line number
3045 var = ".BUILTIN." + var;
3046 place[var] = QStringList(QString::number(parser.line_no));
3047 } else if(var == QLatin1String("_FILE_")) { //parser file
3048 var = ".BUILTIN." + var;
3049 place[var] = QStringList(parser.file);
3050 } else if(var == QLatin1String("_DATE_")) { //current date/time
3051 var = ".BUILTIN." + var;
3052 place[var] = QStringList(QDateTime::currentDateTime().toString());
3053 } else if(var == QLatin1String("_PRO_FILE_")) {
3054 var = ".BUILTIN." + var;
3055 place[var] = QStringList(pfile);
3056 } else if(var == QLatin1String("_PRO_FILE_PWD_")) {
3057 var = ".BUILTIN." + var;
3058 place[var] = QStringList(pfile.isEmpty() ? qmake_getpwd() : QFileInfo(pfile).absolutePath());
3059 } else if(var == QLatin1String("_QMAKE_CACHE_")) {
3060 var = ".BUILTIN." + var;
3061 if(Option::mkfile::do_cache)
3062 place[var] = QStringList(Option::mkfile::cachefile);
3063 } else if(var == QLatin1String("TEMPLATE")) {
3064 if(!Option::user_template.isEmpty()) {
3065 var = ".BUILTIN.USER." + var;
3066 place[var] = QStringList(Option::user_template);
3068 QString orig_template, real_template;
3069 if(!place[var].isEmpty())
3070 orig_template = place[var].first();
3071 real_template = orig_template.isEmpty() ? "app" : orig_template;
3072 if(!Option::user_template_prefix.isEmpty() && !orig_template.startsWith(Option::user_template_prefix))
3073 real_template.prepend(Option::user_template_prefix);
3074 if(real_template != orig_template) {
3075 var = ".BUILTIN." + var;
3076 place[var] = QStringList(real_template);
3079 } else if(var.startsWith(QLatin1String("QMAKE_HOST."))) {
3080 QString ret, type = var.mid(11);
3081 #if defined(Q_OS_WIN32)
3084 } else if(type == "name") {
3085 DWORD name_length = 1024;
3087 if (GetComputerName(name, &name_length))
3088 ret = QString::fromWCharArray(name);
3089 } else if(type == "version" || type == "version_string") {
3090 QSysInfo::WinVersion ver = QSysInfo::WindowsVersion;
3091 if(type == "version")
3092 ret = QString::number(ver);
3093 else if(ver == QSysInfo::WV_Me)
3095 else if(ver == QSysInfo::WV_95)
3097 else if(ver == QSysInfo::WV_98)
3099 else if(ver == QSysInfo::WV_NT)
3101 else if(ver == QSysInfo::WV_2000)
3103 else if(ver == QSysInfo::WV_2000)
3105 else if(ver == QSysInfo::WV_XP)
3107 else if(ver == QSysInfo::WV_VISTA)
3111 } else if(type == "arch") {
3113 GetSystemInfo(&info);
3114 switch(info.wProcessorArchitecture) {
3115 #ifdef PROCESSOR_ARCHITECTURE_AMD64
3116 case PROCESSOR_ARCHITECTURE_AMD64:
3120 case PROCESSOR_ARCHITECTURE_INTEL:
3123 case PROCESSOR_ARCHITECTURE_IA64:
3124 #ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
3125 case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
3134 #elif defined(Q_OS_UNIX)
3135 struct utsname name;
3139 else if(type == "name")
3140 ret = name.nodename;
3141 else if(type == "version")
3143 else if(type == "version_string")
3145 else if(type == "arch")
3149 var = ".BUILTIN.HOST." + type;
3150 place[var] = QStringList(ret);
3151 } else if (var == QLatin1String("QMAKE_DIR_SEP")) {
3152 if (place[var].isEmpty())
3153 return values("DIR_SEPARATOR", place);
3154 } else if (var == QLatin1String("QMAKE_EXT_OBJ")) {
3155 if (place[var].isEmpty()) {
3156 var = ".BUILTIN." + var;
3157 place[var] = QStringList(Option::obj_ext);
3159 } else if (var == QLatin1String("QMAKE_QMAKE")) {
3160 if (place[var].isEmpty())
3161 place[var] = QStringList(Option::fixPathToTargetOS(
3162 !Option::qmake_abslocation.isEmpty()
3163 ? Option::qmake_abslocation
3164 : QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmake",
3167 #if defined(Q_OS_WIN32) && defined(Q_CC_MSVC)
3168 else if(var.startsWith(QLatin1String("QMAKE_TARGET."))) {
3169 QString ret, type = var.mid(13);
3170 if(type == "arch") {
3171 QString paths = qgetenv("PATH");
3172 QString vcBin64 = qgetenv("VCINSTALLDIR").append("\\bin\\amd64");
3173 QString vcBinX86_64 = qgetenv("VCINSTALLDIR").append("\\bin\\x86_amd64");
3174 if(paths.contains(vcBin64,Qt::CaseInsensitive) || paths.contains(vcBinX86_64,Qt::CaseInsensitive))
3179 place[var] = QStringList(ret);
3182 //qDebug("REPLACE [%s]->[%s]", qPrintable(var), qPrintable(place[var].join("::")));
3186 bool QMakeProject::isEmpty(const QString &v)
3188 QMap<QString, QStringList>::ConstIterator it = vars.constFind(varMap(v));
3189 return it == vars.constEnd() || it->isEmpty();