source: trunk/qmake/project.cpp@ 846

Last change on this file since 846 was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 122.7 KB
RevLine 
[2]1/****************************************************************************
2**
[846]3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
[561]4** All rights reserved.
5** Contact: Nokia Corporation (qt-info@nokia.com)
[2]6**
7** This file is part of the qmake application of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
[561]24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
[2]27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
[561]36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
[2]38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "project.h"
43#include "property.h"
44#include "option.h"
45#include "cachekeys.h"
[846]46#include "generators/metamakefile.h"
[2]47
48#include <qdatetime.h>
49#include <qfile.h>
50#include <qfileinfo.h>
51#include <qdir.h>
52#include <qregexp.h>
53#include <qtextstream.h>
54#include <qstack.h>
55#include <qhash.h>
56#include <qdebug.h>
57#ifdef Q_OS_UNIX
58#include <unistd.h>
59#include <sys/utsname.h>
60#elif defined(Q_OS_WIN32)
[561]61#include <windows.h>
[29]62#elif defined(Q_OS_OS2)
63#include <qt_os2.h>
[2]64#endif
65#include <stdio.h>
66#include <stdlib.h>
67
[769]68// Included from tools/shared
[846]69#include <symbian/epocroot_p.h>
[769]70
[2]71#ifdef Q_OS_WIN32
72#define QT_POPEN _popen
73#define QT_PCLOSE _pclose
74#else
75#define QT_POPEN popen
76#define QT_PCLOSE pclose
77#endif
78
79QT_BEGIN_NAMESPACE
80
[846]81//expand functions
[2]82enum ExpandFunc { E_MEMBER=1, E_FIRST, E_LAST, E_CAT, E_FROMFILE, E_EVAL, E_LIST,
83 E_SPRINTF, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION,
84 E_FIND, E_SYSTEM, E_UNIQUE, E_QUOTE, E_ESCAPE_EXPAND,
[561]85 E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,
[651]86 E_SIZE, E_GENERATE_UID };
[2]87QMap<QString, ExpandFunc> qmake_expandFunctions()
88{
89 static QMap<QString, ExpandFunc> *qmake_expand_functions = 0;
90 if(!qmake_expand_functions) {
91 qmake_expand_functions = new QMap<QString, ExpandFunc>;
92 qmakeAddCacheClear(qmakeDeleteCacheClear_QMapStringInt, (void**)&qmake_expand_functions);
93 qmake_expand_functions->insert("member", E_MEMBER);
94 qmake_expand_functions->insert("first", E_FIRST);
95 qmake_expand_functions->insert("last", E_LAST);
96 qmake_expand_functions->insert("cat", E_CAT);
97 qmake_expand_functions->insert("fromfile", E_FROMFILE);
98 qmake_expand_functions->insert("eval", E_EVAL);
99 qmake_expand_functions->insert("list", E_LIST);
100 qmake_expand_functions->insert("sprintf", E_SPRINTF);
101 qmake_expand_functions->insert("join", E_JOIN);
102 qmake_expand_functions->insert("split", E_SPLIT);
103 qmake_expand_functions->insert("basename", E_BASENAME);
104 qmake_expand_functions->insert("dirname", E_DIRNAME);
105 qmake_expand_functions->insert("section", E_SECTION);
106 qmake_expand_functions->insert("find", E_FIND);
107 qmake_expand_functions->insert("system", E_SYSTEM);
108 qmake_expand_functions->insert("unique", E_UNIQUE);
109 qmake_expand_functions->insert("quote", E_QUOTE);
110 qmake_expand_functions->insert("escape_expand", E_ESCAPE_EXPAND);
111 qmake_expand_functions->insert("upper", E_UPPER);
112 qmake_expand_functions->insert("lower", E_LOWER);
113 qmake_expand_functions->insert("re_escape", E_RE_ESCAPE);
114 qmake_expand_functions->insert("files", E_FILES);
115 qmake_expand_functions->insert("prompt", E_PROMPT);
116 qmake_expand_functions->insert("replace", E_REPLACE);
[561]117 qmake_expand_functions->insert("size", E_SIZE);
[651]118 qmake_expand_functions->insert("generate_uid", E_GENERATE_UID);
[2]119 }
120 return *qmake_expand_functions;
121}
122//replace functions
123enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,
124 T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,
125 T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,
126 T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,
[846]127 T_MESSAGE, T_WARNING, T_IF, T_OPTION };
[2]128QMap<QString, TestFunc> qmake_testFunctions()
129{
130 static QMap<QString, TestFunc> *qmake_test_functions = 0;
131 if(!qmake_test_functions) {
132 qmake_test_functions = new QMap<QString, TestFunc>;
133 qmake_test_functions->insert("requires", T_REQUIRES);
134 qmake_test_functions->insert("greaterThan", T_GREATERTHAN);
135 qmake_test_functions->insert("lessThan", T_LESSTHAN);
136 qmake_test_functions->insert("equals", T_EQUALS);
137 qmake_test_functions->insert("isEqual", T_EQUALS);
138 qmake_test_functions->insert("exists", T_EXISTS);
139 qmake_test_functions->insert("export", T_EXPORT);
140 qmake_test_functions->insert("clear", T_CLEAR);
141 qmake_test_functions->insert("unset", T_UNSET);
142 qmake_test_functions->insert("eval", T_EVAL);
143 qmake_test_functions->insert("CONFIG", T_CONFIG);
144 qmake_test_functions->insert("if", T_IF);
145 qmake_test_functions->insert("isActiveConfig", T_CONFIG);
146 qmake_test_functions->insert("system", T_SYSTEM);
147 qmake_test_functions->insert("return", T_RETURN);
148 qmake_test_functions->insert("break", T_BREAK);
149 qmake_test_functions->insert("next", T_NEXT);
150 qmake_test_functions->insert("defined", T_DEFINED);
151 qmake_test_functions->insert("contains", T_CONTAINS);
152 qmake_test_functions->insert("infile", T_INFILE);
153 qmake_test_functions->insert("count", T_COUNT);
154 qmake_test_functions->insert("isEmpty", T_ISEMPTY);
155 qmake_test_functions->insert("include", T_INCLUDE);
156 qmake_test_functions->insert("load", T_LOAD);
157 qmake_test_functions->insert("debug", T_DEBUG);
158 qmake_test_functions->insert("error", T_ERROR);
159 qmake_test_functions->insert("message", T_MESSAGE);
160 qmake_test_functions->insert("warning", T_WARNING);
[846]161 qmake_test_functions->insert("option", T_OPTION);
[2]162 }
163 return *qmake_test_functions;
164}
165
166struct parser_info {
167 QString file;
168 int line_no;
169 bool from_file;
170} parser;
171
172static QString remove_quotes(const QString &arg)
173{
174 const ushort SINGLEQUOTE = '\'';
175 const ushort DOUBLEQUOTE = '"';
176
177 const QChar *arg_data = arg.data();
178 const ushort first = arg_data->unicode();
179 const int arg_len = arg.length();
180 if(first == SINGLEQUOTE || first == DOUBLEQUOTE) {
181 const ushort last = (arg_data+arg_len-1)->unicode();
182 if(last == first)
183 return arg.mid(1, arg_len-2);
184 }
185 return arg;
186}
187
188static QString varMap(const QString &x)
189{
190 QString ret(x);
[846]191 if(ret == "INTERFACES")
[2]192 ret = "FORMS";
193 else if(ret == "QMAKE_POST_BUILD")
194 ret = "QMAKE_POST_LINK";
195 else if(ret == "TARGETDEPS")
196 ret = "POST_TARGETDEPS";
197 else if(ret == "LIBPATH")
198 ret = "QMAKE_LIBDIR";
199 else if(ret == "QMAKE_EXT_MOC")
200 ret = "QMAKE_EXT_CPP_MOC";
201 else if(ret == "QMAKE_MOD_MOC")
202 ret = "QMAKE_H_MOD_MOC";
203 else if(ret == "QMAKE_LFLAGS_SHAPP")
204 ret = "QMAKE_LFLAGS_APP";
205 else if(ret == "PRECOMPH")
206 ret = "PRECOMPILED_HEADER";
207 else if(ret == "PRECOMPCPP")
208 ret = "PRECOMPILED_SOURCE";
209 else if(ret == "INCPATH")
210 ret = "INCLUDEPATH";
211 else if(ret == "QMAKE_EXTRA_WIN_COMPILERS" || ret == "QMAKE_EXTRA_UNIX_COMPILERS")
212 ret = "QMAKE_EXTRA_COMPILERS";
213 else if(ret == "QMAKE_EXTRA_WIN_TARGETS" || ret == "QMAKE_EXTRA_UNIX_TARGETS")
214 ret = "QMAKE_EXTRA_TARGETS";
215 else if(ret == "QMAKE_EXTRA_UNIX_INCLUDES")
216 ret = "QMAKE_EXTRA_INCLUDES";
217 else if(ret == "QMAKE_EXTRA_UNIX_VARIABLES")
218 ret = "QMAKE_EXTRA_VARIABLES";
219 else if(ret == "QMAKE_RPATH")
220 ret = "QMAKE_LFLAGS_RPATH";
221 else if(ret == "QMAKE_FRAMEWORKDIR")
222 ret = "QMAKE_FRAMEWORKPATH";
223 else if(ret == "QMAKE_FRAMEWORKDIR_FLAGS")
224 ret = "QMAKE_FRAMEWORKPATH_FLAGS";
[846]225 else
226 return ret;
227 warn_msg(WarnDeprecated, "%s:%d: Variable %s is deprecated; use %s instead.",
228 parser.file.toLatin1().constData(), parser.line_no,
229 x.toLatin1().constData(), ret.toLatin1().constData());
[2]230 return ret;
231}
232
233static QStringList split_arg_list(QString params)
234{
235 int quote = 0;
236 QStringList args;
237
238 const ushort LPAREN = '(';
239 const ushort RPAREN = ')';
240 const ushort SINGLEQUOTE = '\'';
241 const ushort DOUBLEQUOTE = '"';
242 const ushort COMMA = ',';
243 const ushort SPACE = ' ';
244 //const ushort TAB = '\t';
245
246 ushort unicode;
247 const QChar *params_data = params.data();
248 const int params_len = params.length();
249 int last = 0;
250 while(last < params_len && (params_data[last].unicode() == SPACE
251 /*|| params_data[last].unicode() == TAB*/))
252 ++last;
253 for(int x = last, parens = 0; x <= params_len; x++) {
254 unicode = params_data[x].unicode();
255 if(x == params_len) {
256 while(x && params_data[x-1].unicode() == SPACE)
257 --x;
258 QString mid(params_data+last, x-last);
259 if(quote) {
260 if(mid[0] == quote && mid[(int)mid.length()-1] == quote)
261 mid = mid.mid(1, mid.length()-2);
262 quote = 0;
263 }
264 args << mid;
265 break;
266 }
267 if(unicode == LPAREN) {
268 --parens;
269 } else if(unicode == RPAREN) {
270 ++parens;
271 } else if(quote && unicode == quote) {
272 quote = 0;
273 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
274 quote = unicode;
275 }
276 if(!parens && !quote && unicode == COMMA) {
277 QString mid = params.mid(last, x - last).trimmed();
278 args << mid;
279 last = x+1;
280 while(last < params_len && (params_data[last].unicode() == SPACE
281 /*|| params_data[last].unicode() == TAB*/))
282 ++last;
283 }
284 }
285 return args;
286}
287
[846]288static QStringList split_value_list(const QString &vals)
[2]289{
290 QString build;
291 QStringList ret;
292 QStack<char> quote;
293
294 const ushort LPAREN = '(';
295 const ushort RPAREN = ')';
296 const ushort SINGLEQUOTE = '\'';
297 const ushort DOUBLEQUOTE = '"';
298 const ushort BACKSLASH = '\\';
299
300 ushort unicode;
301 const QChar *vals_data = vals.data();
302 const int vals_len = vals.length();
303 for(int x = 0, parens = 0; x < vals_len; x++) {
304 unicode = vals_data[x].unicode();
305 if(x != (int)vals_len-1 && unicode == BACKSLASH &&
306 (vals_data[x+1].unicode() == SINGLEQUOTE || vals_data[x+1].unicode() == DOUBLEQUOTE)) {
307 build += vals_data[x++]; //get that 'escape'
308 } else if(!quote.isEmpty() && unicode == quote.top()) {
309 quote.pop();
310 } else if(unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE) {
311 quote.push(unicode);
312 } else if(unicode == RPAREN) {
313 --parens;
314 } else if(unicode == LPAREN) {
315 ++parens;
316 }
317
[846]318 if(!parens && quote.isEmpty() && (vals_data[x] == Option::field_sep)) {
[2]319 ret << build;
320 build.clear();
321 } else {
322 build += vals_data[x];
323 }
324 }
325 if(!build.isEmpty())
326 ret << build;
327 return ret;
328}
329
330//just a parsable entity
331struct ParsableBlock
332{
333 ParsableBlock() : ref_cnt(1) { }
334 virtual ~ParsableBlock() { }
335
336 struct Parse {
337 QString text;
338 parser_info pi;
339 Parse(const QString &t) : text(t){ pi = parser; }
340 };
341 QList<Parse> parselist;
342
343 inline int ref() { return ++ref_cnt; }
344 inline int deref() { return --ref_cnt; }
345
346protected:
347 int ref_cnt;
348 virtual bool continueBlock() = 0;
349 bool eval(QMakeProject *p, QMap<QString, QStringList> &place);
350};
351
352bool ParsableBlock::eval(QMakeProject *p, QMap<QString, QStringList> &place)
353{
354 //save state
355 parser_info pi = parser;
356 const int block_count = p->scope_blocks.count();
357
358 //execute
359 bool ret = true;
360 for(int i = 0; i < parselist.count(); i++) {
361 parser = parselist.at(i).pi;
362 if(!(ret = p->parse(parselist.at(i).text, place)) || !continueBlock())
363 break;
364 }
365
366 //restore state
367 parser = pi;
368 while(p->scope_blocks.count() > block_count)
369 p->scope_blocks.pop();
370 return ret;
371}
372
373//defined functions
374struct FunctionBlock : public ParsableBlock
375{
376 FunctionBlock() : calling_place(0), scope_level(1), cause_return(false) { }
377
378 QMap<QString, QStringList> vars;
379 QMap<QString, QStringList> *calling_place;
380 QStringList return_value;
381 int scope_level;
382 bool cause_return;
383
384 bool exec(const QList<QStringList> &args,
385 QMakeProject *p, QMap<QString, QStringList> &place, QStringList &functionReturn);
386 virtual bool continueBlock() { return !cause_return; }
387};
388
389bool FunctionBlock::exec(const QList<QStringList> &args,
390 QMakeProject *proj, QMap<QString, QStringList> &place,
391 QStringList &functionReturn)
392{
393 //save state
394#if 1
395 calling_place = &place;
396#else
397 calling_place = &proj->variables();
398#endif
399 return_value.clear();
400 cause_return = false;
401
402 //execute
403#if 0
404 vars = proj->variables(); // should be place so that local variables can be inherited
405#else
406 vars = place;
407#endif
408 vars["ARGS"].clear();
409 for(int i = 0; i < args.count(); i++) {
410 vars["ARGS"] += args[i];
411 vars[QString::number(i+1)] = args[i];
412 }
413 bool ret = ParsableBlock::eval(proj, vars);
414 functionReturn = return_value;
415
416 //restore state
417 calling_place = 0;
418 return_value.clear();
419 vars.clear();
420 return ret;
421}
422
423//loops
424struct IteratorBlock : public ParsableBlock
425{
426 IteratorBlock() : scope_level(1), loop_forever(false), cause_break(false), cause_next(false) { }
427
428 int scope_level;
429
430 struct Test {
431 QString func;
432 QStringList args;
433 bool invert;
434 parser_info pi;
435 Test(const QString &f, QStringList &a, bool i) : func(f), args(a), invert(i) { pi = parser; }
436 };
437 QList<Test> test;
438
439 QString variable;
440
441 bool loop_forever, cause_break, cause_next;
442 QStringList list;
443
444 bool exec(QMakeProject *p, QMap<QString, QStringList> &place);
445 virtual bool continueBlock() { return !cause_next && !cause_break; }
446};
447bool IteratorBlock::exec(QMakeProject *p, QMap<QString, QStringList> &place)
448{
449 bool ret = true;
450 QStringList::Iterator it;
451 if(!loop_forever)
452 it = list.begin();
453 int iterate_count = 0;
454 //save state
455 IteratorBlock *saved_iterator = p->iterator;
456 p->iterator = this;
457
458 //do the loop
459 while(loop_forever || it != list.end()) {
460 cause_next = cause_break = false;
461 if(!loop_forever && (*it).isEmpty()) { //ignore empty items
462 ++it;
463 continue;
464 }
465
466 //set up the loop variable
467 QStringList va;
468 if(!variable.isEmpty()) {
469 va = place[variable];
470 if(loop_forever)
471 place[variable] = QStringList(QString::number(iterate_count));
472 else
473 place[variable] = QStringList(*it);
474 }
475 //do the iterations
476 bool succeed = true;
477 for(QList<Test>::Iterator test_it = test.begin(); test_it != test.end(); ++test_it) {
478 parser = (*test_it).pi;
479 succeed = p->doProjectTest((*test_it).func, (*test_it).args, place);
480 if((*test_it).invert)
481 succeed = !succeed;
482 if(!succeed)
483 break;
484 }
485 if(succeed)
486 ret = ParsableBlock::eval(p, place);
487 //restore the variable in the map
488 if(!variable.isEmpty())
489 place[variable] = va;
490 //loop counters
491 if(!loop_forever)
492 ++it;
493 iterate_count++;
494 if(!ret || cause_break)
495 break;
496 }
497
498 //restore state
499 p->iterator = saved_iterator;
500 return ret;
501}
502
503QMakeProject::ScopeBlock::~ScopeBlock()
504{
505#if 0
506 if(iterate)
507 delete iterate;
508#endif
509}
510
511static void qmake_error_msg(const QString &msg)
512{
513 fprintf(stderr, "%s:%d: %s\n", parser.file.toLatin1().constData(), parser.line_no,
514 msg.toLatin1().constData());
515}
516
517/*
518 1) environment variable QMAKEFEATURES (as separated by colons)
519 2) property variable QMAKEFEATURES (as separated by colons)
520 3) <project_root> (where .qmake.cache lives) + FEATURES_DIR
521 4) environment variable QMAKEPATH (as separated by colons) + /mkspecs/FEATURES_DIR
522 5) your QMAKESPEC/features dir
523 6) your data_install/mkspecs/FEATURES_DIR
524 7) your QMAKESPEC/../FEATURES_DIR dir
525
526 FEATURES_DIR is defined as:
527
528 1) features/(unix|win32|macx)/
529 2) features/
530*/
531QStringList qmake_feature_paths(QMakeProperty *prop=0)
532{
533 QStringList concat;
534 {
535 const QString base_concat = QDir::separator() + QString("features");
536 switch(Option::target_mode) {
537 case Option::TARG_MACX_MODE: //also a unix
538 concat << base_concat + QDir::separator() + "mac";
539 concat << base_concat + QDir::separator() + "macx";
540 concat << base_concat + QDir::separator() + "unix";
541 break;
[846]542 default: // Can't happen, just make the compiler shut up
[2]543 case Option::TARG_UNIX_MODE:
[846]544 concat << base_concat + QDir::separator() + "unix";
545 break;
[2]546 case Option::TARG_WIN_MODE:
[846]547 concat << base_concat + QDir::separator() + "win32";
548 break;
549 case Option::TARG_SYMBIAN_MODE:
550 concat << base_concat + QDir::separator() + "symbian";
551 break;
[27]552 case Option::TARG_OS2_MODE:
553 concat << base_concat + QDir::separator() + "os2";
554 break;
[2]555 }
556 concat << base_concat;
557 }
558 const QString mkspecs_concat = QDir::separator() + QString("mkspecs");
559 QStringList feature_roots;
560 QByteArray mkspec_path = qgetenv("QMAKEFEATURES");
561 if(!mkspec_path.isNull())
562 feature_roots += splitPathList(QString::fromLocal8Bit(mkspec_path));
563 if(prop)
564 feature_roots += splitPathList(prop->value("QMAKEFEATURES"));
565 if(!Option::mkfile::cachefile.isEmpty()) {
566 QString path;
[846]567 int last_slash = Option::mkfile::cachefile.lastIndexOf(QDir::separator());
[2]568 if(last_slash != -1)
[846]569 path = Option::fixPathToLocalOS(Option::mkfile::cachefile.left(last_slash), false);
[2]570 for(QStringList::Iterator concat_it = concat.begin();
571 concat_it != concat.end(); ++concat_it)
572 feature_roots << (path + (*concat_it));
573 }
574 QByteArray qmakepath = qgetenv("QMAKEPATH");
575 if (!qmakepath.isNull()) {
576 const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));
577 for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it) {
578 for(QStringList::Iterator concat_it = concat.begin();
579 concat_it != concat.end(); ++concat_it)
580 feature_roots << ((*it) + mkspecs_concat + (*concat_it));
581 }
582 }
583 if(!Option::mkfile::qmakespec.isEmpty())
584 feature_roots << Option::mkfile::qmakespec + QDir::separator() + "features";
585 if(!Option::mkfile::qmakespec.isEmpty()) {
586 QFileInfo specfi(Option::mkfile::qmakespec);
587 QDir specdir(specfi.absoluteFilePath());
588 while(!specdir.isRoot()) {
589 if(!specdir.cdUp() || specdir.isRoot())
590 break;
591 if(QFile::exists(specdir.path() + QDir::separator() + "features")) {
592 for(QStringList::Iterator concat_it = concat.begin();
593 concat_it != concat.end(); ++concat_it)
594 feature_roots << (specdir.path() + (*concat_it));
595 break;
596 }
597 }
598 }
599 for(QStringList::Iterator concat_it = concat.begin();
600 concat_it != concat.end(); ++concat_it)
601 feature_roots << (QLibraryInfo::location(QLibraryInfo::PrefixPath) +
602 mkspecs_concat + (*concat_it));
603 for(QStringList::Iterator concat_it = concat.begin();
604 concat_it != concat.end(); ++concat_it)
605 feature_roots << (QLibraryInfo::location(QLibraryInfo::DataPath) +
606 mkspecs_concat + (*concat_it));
607 return feature_roots;
608}
609
610QStringList qmake_mkspec_paths()
611{
612 QStringList ret;
613 const QString concat = QDir::separator() + QString("mkspecs");
614 QByteArray qmakepath = qgetenv("QMAKEPATH");
615 if (!qmakepath.isEmpty()) {
616 const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));
617 for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it)
618 ret << ((*it) + concat);
619 }
620 ret << QLibraryInfo::location(QLibraryInfo::DataPath) + concat;
621
622 return ret;
623}
624
625QMakeProject::~QMakeProject()
626{
627 if(own_prop)
628 delete prop;
629 for(QMap<QString, FunctionBlock*>::iterator it = replaceFunctions.begin(); it != replaceFunctions.end(); ++it) {
630 if(!it.value()->deref())
631 delete it.value();
632 }
633 replaceFunctions.clear();
634 for(QMap<QString, FunctionBlock*>::iterator it = testFunctions.begin(); it != testFunctions.end(); ++it) {
635 if(!it.value()->deref())
636 delete it.value();
637 }
638 testFunctions.clear();
639}
640
641
642void
643QMakeProject::init(QMakeProperty *p, const QMap<QString, QStringList> *vars)
644{
645 if(vars)
646 base_vars = *vars;
647 if(!p) {
648 prop = new QMakeProperty;
649 own_prop = true;
650 } else {
651 prop = p;
652 own_prop = false;
653 }
[846]654 recursive = false;
[2]655 reset();
656}
657
658QMakeProject::QMakeProject(QMakeProject *p, const QMap<QString, QStringList> *vars)
659{
660 init(p->properties(), vars ? vars : &p->variables());
661 for(QMap<QString, FunctionBlock*>::iterator it = p->replaceFunctions.begin(); it != p->replaceFunctions.end(); ++it) {
662 it.value()->ref();
663 replaceFunctions.insert(it.key(), it.value());
664 }
665 for(QMap<QString, FunctionBlock*>::iterator it = p->testFunctions.begin(); it != p->testFunctions.end(); ++it) {
666 it.value()->ref();
667 testFunctions.insert(it.key(), it.value());
668 }
669}
670
671void
672QMakeProject::reset()
673{
674 // scope_blocks starts with one non-ignoring entity
675 scope_blocks.clear();
676 scope_blocks.push(ScopeBlock());
677 iterator = 0;
678 function = 0;
[846]679 backslashWarned = false;
[2]680}
681
682bool
683QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int numLines)
684{
[846]685 // To preserve the integrity of any UTF-8 characters in .pro file, temporarily replace the
686 // non-breaking space (0xA0) characters with another non-space character, so that
687 // QString::simplified() call will not replace it with space.
688 // Note: There won't be any two byte characters in .pro files, so 0x10A0 should be a safe
689 // replacement character.
690 static QChar nbsp(0xA0);
691 static QChar nbspFix(0x01A0);
692 QString s;
693 if (t.indexOf(nbsp) != -1) {
694 s = t;
695 s.replace(nbsp, nbspFix);
696 s = s.simplified();
697 s.replace(nbspFix, nbsp);
698 } else {
699 s = t.simplified();
700 }
701
[2]702 int hash_mark = s.indexOf("#");
703 if(hash_mark != -1) //good bye comments
704 s = s.left(hash_mark);
705 if(s.isEmpty()) // blank_line
706 return true;
707
708 if(scope_blocks.top().ignore) {
709 bool continue_parsing = false;
710 // adjust scope for each block which appears on a single line
711 for(int i = 0; i < s.length(); i++) {
712 if(s[i] == '{') {
713 scope_blocks.push(ScopeBlock(true));
714 } else if(s[i] == '}') {
715 if(scope_blocks.count() == 1) {
716 fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
717 return false;
718 }
719 ScopeBlock sb = scope_blocks.pop();
720 if(sb.iterate) {
721 sb.iterate->exec(this, place);
722 delete sb.iterate;
723 sb.iterate = 0;
724 }
725 if(!scope_blocks.top().ignore) {
726 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
727 parser.line_no, scope_blocks.count()+1);
728 s = s.mid(i+1).trimmed();
729 continue_parsing = !s.isEmpty();
730 break;
731 }
732 }
733 }
734 if(!continue_parsing) {
735 debug_msg(1, "Project Parser: %s:%d : Ignored due to block being false.",
736 parser.file.toLatin1().constData(), parser.line_no);
737 return true;
738 }
739 }
740
741 if(function) {
742 QString append;
743 int d_off = 0;
744 const QChar *d = s.unicode();
745 bool function_finished = false;
746 while(d_off < s.length()) {
747 if(*(d+d_off) == QLatin1Char('}')) {
748 function->scope_level--;
749 if(!function->scope_level) {
750 function_finished = true;
751 break;
752 }
753 } else if(*(d+d_off) == QLatin1Char('{')) {
754 function->scope_level++;
755 }
756 append += *(d+d_off);
757 ++d_off;
758 }
759 if(!append.isEmpty())
760 function->parselist.append(IteratorBlock::Parse(append));
761 if(function_finished) {
762 function = 0;
763 s = QString(d+d_off, s.length()-d_off);
764 } else {
765 return true;
766 }
767 } else if(IteratorBlock *it = scope_blocks.top().iterate) {
768 QString append;
769 int d_off = 0;
770 const QChar *d = s.unicode();
771 bool iterate_finished = false;
772 while(d_off < s.length()) {
773 if(*(d+d_off) == QLatin1Char('}')) {
774 it->scope_level--;
775 if(!it->scope_level) {
776 iterate_finished = true;
777 break;
778 }
779 } else if(*(d+d_off) == QLatin1Char('{')) {
780 it->scope_level++;
781 }
782 append += *(d+d_off);
783 ++d_off;
784 }
785 if(!append.isEmpty())
786 scope_blocks.top().iterate->parselist.append(IteratorBlock::Parse(append));
787 if(iterate_finished) {
788 scope_blocks.top().iterate = 0;
789 bool ret = it->exec(this, place);
790 delete it;
791 if(!ret)
792 return false;
793 s = s.mid(d_off);
794 } else {
795 return true;
796 }
797 }
798
799 QString scope, var, op;
800 QStringList val;
801#define SKIP_WS(d, o, l) while(o < l && (*(d+o) == QLatin1Char(' ') || *(d+o) == QLatin1Char('\t'))) ++o
802 const QChar *d = s.unicode();
803 int d_off = 0;
804 SKIP_WS(d, d_off, s.length());
805 IteratorBlock *iterator = 0;
806 bool scope_failed = false, else_line = false, or_op=false;
807 QChar quote = 0;
808 int parens = 0, scope_count=0, start_block = 0;
809 while(d_off < s.length()) {
810 if(!parens) {
811 if(*(d+d_off) == QLatin1Char('='))
812 break;
813 if(*(d+d_off) == QLatin1Char('+') || *(d+d_off) == QLatin1Char('-') ||
814 *(d+d_off) == QLatin1Char('*') || *(d+d_off) == QLatin1Char('~')) {
815 if(*(d+d_off+1) == QLatin1Char('=')) {
816 break;
817 } else if(*(d+d_off+1) == QLatin1Char(' ')) {
818 const QChar *k = d+d_off+1;
819 int k_off = 0;
820 SKIP_WS(k, k_off, s.length()-d_off);
821 if(*(k+k_off) == QLatin1Char('=')) {
822 QString msg;
823 qmake_error_msg(QString(d+d_off, 1) + "must be followed immediately by =");
824 return false;
825 }
826 }
827 }
828 }
829
830 if(!quote.isNull()) {
831 if(*(d+d_off) == quote)
832 quote = QChar();
833 } else if(*(d+d_off) == '(') {
834 ++parens;
835 } else if(*(d+d_off) == ')') {
836 --parens;
837 } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {
838 quote = *(d+d_off);
839 }
840
841 if(!parens && quote.isNull() &&
842 (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('{') ||
843 *(d+d_off) == QLatin1Char(')') || *(d+d_off) == QLatin1Char('|'))) {
844 scope_count++;
845 scope = var.trimmed();
846 if(*(d+d_off) == QLatin1Char(')'))
847 scope += *(d+d_off); // need this
848 var = "";
849
850 bool test = scope_failed;
851 if(scope.isEmpty()) {
852 test = true;
853 } else if(scope.toLower() == "else") { //else is a builtin scope here as it modifies state
854 if(scope_count != 1 || scope_blocks.top().else_status == ScopeBlock::TestNone) {
855 qmake_error_msg(("Unexpected " + scope + " ('" + s + "')").toLatin1());
856 return false;
857 }
858 else_line = true;
859 test = (scope_blocks.top().else_status == ScopeBlock::TestSeek);
860 debug_msg(1, "Project Parser: %s:%d : Else%s %s.", parser.file.toLatin1().constData(), parser.line_no,
861 scope == "else" ? "" : QString(" (" + scope + ")").toLatin1().constData(),
862 test ? "considered" : "excluded");
863 } else {
864 QString comp_scope = scope;
865 bool invert_test = (comp_scope.at(0) == QLatin1Char('!'));
866 if(invert_test)
867 comp_scope = comp_scope.mid(1);
868 int lparen = comp_scope.indexOf('(');
869 if(or_op == scope_failed) {
870 if(lparen != -1) { // if there is an lparen in the scope, it IS a function
871 int rparen = comp_scope.lastIndexOf(')');
872 if(rparen == -1) {
873 qmake_error_msg("Function missing right paren: " + comp_scope);
874 return false;
875 }
876 QString func = comp_scope.left(lparen);
877 QStringList args = split_arg_list(comp_scope.mid(lparen+1, rparen - lparen - 1));
878 if(function) {
879 fprintf(stderr, "%s:%d: No tests can come after a function definition!\n",
880 parser.file.toLatin1().constData(), parser.line_no);
881 return false;
882 } else if(func == "for") { //for is a builtin function here, as it modifies state
883 if(args.count() > 2 || args.count() < 1) {
884 fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",
885 parser.file.toLatin1().constData(), parser.line_no);
886 return false;
887 } else if(iterator) {
888 fprintf(stderr, "%s:%d unexpected nested for()\n",
889 parser.file.toLatin1().constData(), parser.line_no);
890 return false;
891 }
892
893 iterator = new IteratorBlock;
894 QString it_list;
895 if(args.count() == 1) {
896 doVariableReplace(args[0], place);
897 it_list = args[0];
898 if(args[0] != "ever") {
899 delete iterator;
900 iterator = 0;
901 fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",
902 parser.file.toLatin1().constData(), parser.line_no);
903 return false;
904 }
905 it_list = "forever";
906 } else if(args.count() == 2) {
907 iterator->variable = args[0];
908 doVariableReplace(args[1], place);
909 it_list = args[1];
910 }
911 QStringList list = place[it_list];
912 if(list.isEmpty()) {
913 if(it_list == "forever") {
914 iterator->loop_forever = true;
915 } else {
916 int dotdot = it_list.indexOf("..");
917 if(dotdot != -1) {
918 bool ok;
919 int start = it_list.left(dotdot).toInt(&ok);
920 if(ok) {
921 int end = it_list.mid(dotdot+2).toInt(&ok);
922 if(ok) {
923 if(start < end) {
924 for(int i = start; i <= end; i++)
925 list << QString::number(i);
926 } else {
927 for(int i = start; i >= end; i--)
928 list << QString::number(i);
929 }
930 }
931 }
932 }
933 }
934 }
935 iterator->list = list;
936 test = !invert_test;
937 } else if(iterator) {
938 iterator->test.append(IteratorBlock::Test(func, args, invert_test));
939 test = !invert_test;
940 } else if(func == "defineTest" || func == "defineReplace") {
941 if(!function_blocks.isEmpty()) {
942 fprintf(stderr,
943 "%s:%d: cannot define a function within another definition.\n",
944 parser.file.toLatin1().constData(), parser.line_no);
945 return false;
946 }
947 if(args.count() != 1) {
948 fprintf(stderr, "%s:%d: %s(function_name) requires one argument.\n",
949 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
950 return false;
951 }
952 QMap<QString, FunctionBlock*> *map = 0;
953 if(func == "defineTest")
954 map = &testFunctions;
955 else
956 map = &replaceFunctions;
957#if 0
958 if(!map || map->contains(args[0])) {
959 fprintf(stderr, "%s:%d: Function[%s] multiply defined.\n",
960 parser.file.toLatin1().constData(), parser.line_no, args[0].toLatin1().constData());
961 return false;
962 }
963#endif
964 function = new FunctionBlock;
965 map->insert(args[0], function);
966 test = true;
967 } else {
968 test = doProjectTest(func, args, place);
969 if(*(d+d_off) == QLatin1Char(')') && d_off == s.length()-1) {
970 if(invert_test)
971 test = !test;
972 scope_blocks.top().else_status =
973 (test ? ScopeBlock::TestFound : ScopeBlock::TestSeek);
974 return true; // assume we are done
975 }
976 }
977 } else {
978 QString cscope = comp_scope.trimmed();
979 doVariableReplace(cscope, place);
980 test = isActiveConfig(cscope.trimmed(), true, &place);
981 }
982 if(invert_test)
983 test = !test;
984 }
985 }
986 if(!test && !scope_failed)
987 debug_msg(1, "Project Parser: %s:%d : Test (%s) failed.", parser.file.toLatin1().constData(),
988 parser.line_no, scope.toLatin1().constData());
989 if(test == or_op)
990 scope_failed = !test;
991 or_op = (*(d+d_off) == QLatin1Char('|'));
992
993 if(*(d+d_off) == QLatin1Char('{')) { // scoping block
994 start_block++;
995 if(iterator) {
996 for(int off = 0, braces = 0; true; ++off) {
997 if(*(d+d_off+off) == QLatin1Char('{'))
998 ++braces;
999 else if(*(d+d_off+off) == QLatin1Char('}') && braces)
1000 --braces;
1001 if(!braces || d_off+off == s.length()) {
1002 iterator->parselist.append(s.mid(d_off, off-1));
1003 if(braces > 1)
1004 iterator->scope_level += braces-1;
1005 d_off += off-1;
1006 break;
1007 }
1008 }
1009 }
1010 }
1011 } else if(!parens && *(d+d_off) == QLatin1Char('}')) {
1012 if(start_block) {
1013 --start_block;
1014 } else if(!scope_blocks.count()) {
1015 warn_msg(WarnParser, "Possible braces mismatch %s:%d", parser.file.toLatin1().constData(), parser.line_no);
1016 } else {
1017 if(scope_blocks.count() == 1) {
1018 fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
1019 return false;
1020 }
1021 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
1022 parser.line_no, scope_blocks.count());
1023 ScopeBlock sb = scope_blocks.pop();
1024 if(sb.iterate)
1025 sb.iterate->exec(this, place);
1026 }
1027 } else {
1028 var += *(d+d_off);
1029 }
1030 ++d_off;
1031 }
1032 var = var.trimmed();
1033
1034 if(!else_line || (else_line && !scope_failed))
1035 scope_blocks.top().else_status = (!scope_failed ? ScopeBlock::TestFound : ScopeBlock::TestSeek);
1036 if(start_block) {
1037 ScopeBlock next_block(scope_failed);
1038 next_block.iterate = iterator;
1039 if(iterator)
1040 next_block.else_status = ScopeBlock::TestNone;
1041 else if(scope_failed)
1042 next_block.else_status = ScopeBlock::TestSeek;
1043 else
1044 next_block.else_status = ScopeBlock::TestFound;
1045 scope_blocks.push(next_block);
1046 debug_msg(1, "Project Parser: %s:%d : Entering block %d (%d). [%s]", parser.file.toLatin1().constData(),
1047 parser.line_no, scope_blocks.count(), scope_failed, s.toLatin1().constData());
1048 } else if(iterator) {
1049 iterator->parselist.append(var+s.mid(d_off));
1050 bool ret = iterator->exec(this, place);
1051 delete iterator;
1052 return ret;
1053 }
1054
1055 if((!scope_count && !var.isEmpty()) || (scope_count == 1 && else_line))
1056 scope_blocks.top().else_status = ScopeBlock::TestNone;
1057 if(d_off == s.length()) {
1058 if(!var.trimmed().isEmpty())
1059 qmake_error_msg(("Parse Error ('" + s + "')").toLatin1());
1060 return var.isEmpty(); // allow just a scope
1061 }
1062
1063 SKIP_WS(d, d_off, s.length());
1064 for(; d_off < s.length() && op.indexOf('=') == -1; op += *(d+(d_off++)))
1065 ;
1066 op.replace(QRegExp("\\s"), "");
1067
1068 SKIP_WS(d, d_off, s.length());
1069 QString vals = s.mid(d_off); // vals now contains the space separated list of values
1070 int rbraces = vals.count('}'), lbraces = vals.count('{');
[846]1071 if(scope_blocks.count() > 1 && rbraces - lbraces == 1 && vals.endsWith('}')) {
[2]1072 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),
1073 parser.line_no, scope_blocks.count());
1074 ScopeBlock sb = scope_blocks.pop();
1075 if(sb.iterate)
1076 sb.iterate->exec(this, place);
1077 vals.truncate(vals.length()-1);
1078 } else if(rbraces != lbraces) {
1079 warn_msg(WarnParser, "Possible braces mismatch {%s} %s:%d",
1080 vals.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1081 }
1082 if(scope_failed)
1083 return true; // oh well
1084#undef SKIP_WS
1085
1086 doVariableReplace(var, place);
[846]1087 var = varMap(var); //backwards compatibility
[2]1088 if(!var.isEmpty() && Option::mkfile::do_preprocess) {
1089 static QString last_file("*none*");
1090 if(parser.file != last_file) {
1091 fprintf(stdout, "#file %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);
1092 last_file = parser.file;
1093 }
1094 fprintf(stdout, "%s %s %s\n", var.toLatin1().constData(), op.toLatin1().constData(), vals.toLatin1().constData());
1095 }
1096
1097 if(vals.contains('=') && numLines > 1)
[846]1098 warn_msg(WarnParser, "Possible accidental line continuation: {%s} at %s:%d",
[2]1099 var.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1100
1101 QStringList &varlist = place[var]; // varlist is the list in the symbol table
1102
1103 if(Option::debug_level >= 1) {
1104 QString tmp_vals = vals;
1105 doVariableReplace(tmp_vals, place);
1106 debug_msg(1, "Project Parser: %s:%d :%s: :%s: (%s)", parser.file.toLatin1().constData(), parser.line_no,
1107 var.toLatin1().constData(), op.toLatin1().constData(), tmp_vals.toLatin1().constData());
1108 }
1109
1110 // now do the operation
1111 if(op == "~=") {
1112 doVariableReplace(vals, place);
1113 if(vals.length() < 4 || vals.at(0) != 's') {
1114 qmake_error_msg(("~= operator only can handle s/// function ('" +
1115 s + "')").toLatin1());
1116 return false;
1117 }
1118 QChar sep = vals.at(1);
1119 QStringList func = vals.split(sep);
1120 if(func.count() < 3 || func.count() > 4) {
1121 qmake_error_msg(("~= operator only can handle s/// function ('" +
1122 s + "')").toLatin1());
1123 return false;
1124 }
1125 bool global = false, case_sense = true, quote = false;
1126 if(func.count() == 4) {
1127 global = func[3].indexOf('g') != -1;
1128 case_sense = func[3].indexOf('i') == -1;
1129 quote = func[3].indexOf('q') != -1;
1130 }
1131 QString from = func[1], to = func[2];
1132 if(quote)
1133 from = QRegExp::escape(from);
1134 QRegExp regexp(from, case_sense ? Qt::CaseSensitive : Qt::CaseInsensitive);
1135 for(QStringList::Iterator varit = varlist.begin(); varit != varlist.end();) {
1136 if((*varit).contains(regexp)) {
1137 (*varit) = (*varit).replace(regexp, to);
1138 if ((*varit).isEmpty())
1139 varit = varlist.erase(varit);
1140 else
1141 ++varit;
1142 if(!global)
1143 break;
1144 } else
1145 ++varit;
1146 }
1147 } else {
1148 QStringList vallist;
1149 {
1150 //doVariableReplace(vals, place);
[846]1151 QStringList tmp = split_value_list(vals);
[2]1152 for(int i = 0; i < tmp.size(); ++i)
1153 vallist += doVariableReplaceExpand(tmp[i], place);
1154 }
1155
1156 if(op == "=") {
1157 if(!varlist.isEmpty()) {
1158 bool send_warning = false;
1159 if(var != "TEMPLATE" && var != "TARGET") {
1160 QSet<QString> incoming_vals = vallist.toSet();
1161 for(int i = 0; i < varlist.size(); ++i) {
1162 const QString var = varlist.at(i).trimmed();
1163 if(!var.isEmpty() && !incoming_vals.contains(var)) {
1164 send_warning = true;
1165 break;
1166 }
1167 }
1168 }
1169 if(send_warning)
1170 warn_msg(WarnParser, "Operator=(%s) clears variables previously set: %s:%d",
1171 var.toLatin1().constData(), parser.file.toLatin1().constData(), parser.line_no);
1172 }
1173 varlist.clear();
1174 }
1175 for(QStringList::ConstIterator valit = vallist.begin();
1176 valit != vallist.end(); ++valit) {
1177 if((*valit).isEmpty())
1178 continue;
1179 if((op == "*=" && !varlist.contains((*valit))) ||
1180 op == "=" || op == "+=")
1181 varlist.append((*valit));
1182 else if(op == "-=")
1183 varlist.removeAll((*valit));
1184 }
1185 if(var == "REQUIRES") // special case to get communicated to backends!
1186 doProjectCheckReqs(vallist, place);
1187 }
1188 return true;
1189}
1190
1191bool
1192QMakeProject::read(QTextStream &file, QMap<QString, QStringList> &place)
1193{
1194 int numLines = 0;
1195 bool ret = true;
1196 QString s;
1197 while(!file.atEnd()) {
1198 parser.line_no++;
1199 QString line = file.readLine().trimmed();
1200 int prelen = line.length();
1201
1202 int hash_mark = line.indexOf("#");
1203 if(hash_mark != -1) //good bye comments
1204 line = line.left(hash_mark).trimmed();
1205 if(!line.isEmpty() && line.right(1) == "\\") {
1206 if(!line.startsWith("#")) {
1207 line.truncate(line.length() - 1);
1208 s += line + Option::field_sep;
1209 ++numLines;
1210 }
1211 } else if(!line.isEmpty() || (line.isEmpty() && !prelen)) {
1212 if(s.isEmpty() && line.isEmpty())
1213 continue;
1214 if(!line.isEmpty()) {
1215 s += line;
1216 ++numLines;
1217 }
1218 if(!s.isEmpty()) {
1219 if(!(ret = parse(s, place, numLines))) {
1220 s = "";
1221 numLines = 0;
1222 break;
1223 }
1224 s = "";
1225 numLines = 0;
1226 }
1227 }
1228 }
1229 if (!s.isEmpty())
1230 ret = parse(s, place, numLines);
1231 return ret;
1232}
1233
1234bool
1235QMakeProject::read(const QString &file, QMap<QString, QStringList> &place)
1236{
1237 parser_info pi = parser;
1238 reset();
1239
1240 const QString oldpwd = qmake_getpwd();
[846]1241 QString filename = Option::fixPathToLocalOS(file, false);
[2]1242 bool ret = false, using_stdin = false;
1243 QFile qfile;
1244 if(!strcmp(filename.toLatin1(), "-")) {
1245 qfile.setFileName("");
1246 ret = qfile.open(stdin, QIODevice::ReadOnly);
1247 using_stdin = true;
1248 } else if(QFileInfo(file).isDir()) {
1249 return false;
1250 } else {
1251 qfile.setFileName(filename);
1252 ret = qfile.open(QIODevice::ReadOnly);
1253 qmake_setpwd(QFileInfo(filename).absolutePath());
1254 }
1255 if(ret) {
1256 parser_info pi = parser;
1257 parser.from_file = true;
1258 parser.file = filename;
1259 parser.line_no = 0;
1260 QTextStream t(&qfile);
1261 ret = read(t, place);
1262 if(!using_stdin)
1263 qfile.close();
1264 }
1265 if(scope_blocks.count() != 1) {
1266 qmake_error_msg("Unterminated conditional block at end of file");
1267 ret = false;
1268 }
1269 parser = pi;
1270 qmake_setpwd(oldpwd);
1271 return ret;
1272}
1273
1274bool
1275QMakeProject::read(const QString &project, uchar cmd)
1276{
1277 pfile = QFileInfo(project).absoluteFilePath();
1278 return read(cmd);
1279}
1280
1281bool
1282QMakeProject::read(uchar cmd)
1283{
1284 if(cfile.isEmpty()) {
1285 // hack to get the Option stuff in there
1286 base_vars["QMAKE_EXT_CPP"] = Option::cpp_ext;
1287 base_vars["QMAKE_EXT_C"] = Option::c_ext;
1288 base_vars["QMAKE_EXT_H"] = Option::h_ext;
1289 base_vars["QMAKE_SH"] = Option::shellPath;
1290 if(!Option::user_template_prefix.isEmpty())
1291 base_vars["TEMPLATE_PREFIX"] = QStringList(Option::user_template_prefix);
1292
1293 if(cmd & ReadCache && Option::mkfile::do_cache) { // parse the cache
1294 int cache_depth = -1;
1295 QString qmake_cache = Option::mkfile::cachefile;
1296 if(qmake_cache.isEmpty()) { //find it as it has not been specified
1297 QString dir = QDir::toNativeSeparators(Option::output_dir);
1298 while(!QFile::exists((qmake_cache = dir + QDir::separator() + ".qmake.cache"))) {
1299 dir = dir.left(dir.lastIndexOf(QDir::separator()));
1300 if(dir.isEmpty() || dir.indexOf(QDir::separator()) == -1) {
1301 qmake_cache = "";
1302 break;
1303 }
1304 if(cache_depth == -1)
1305 cache_depth = 1;
1306 else
1307 cache_depth++;
1308 }
1309 } else {
1310 QString abs_cache = QFileInfo(Option::mkfile::cachefile).absoluteDir().path();
1311 if(Option::output_dir.startsWith(abs_cache))
1312 cache_depth = Option::output_dir.mid(abs_cache.length()).count('/');
1313 }
1314 if(!qmake_cache.isEmpty()) {
1315 if(read(qmake_cache, cache)) {
1316 Option::mkfile::cachefile_depth = cache_depth;
1317 Option::mkfile::cachefile = qmake_cache;
1318 if(Option::mkfile::qmakespec.isEmpty() && !cache["QMAKESPEC"].isEmpty())
1319 Option::mkfile::qmakespec = cache["QMAKESPEC"].first();
1320 }
1321 }
1322 }
1323 if(cmd & ReadConf) { // parse mkspec
1324 QString qmakespec = fixEnvVariables(Option::mkfile::qmakespec);
1325 QStringList mkspec_roots = qmake_mkspec_paths();
1326 debug_msg(2, "Looking for mkspec %s in (%s)", qmakespec.toLatin1().constData(),
1327 mkspec_roots.join("::").toLatin1().constData());
1328 if(qmakespec.isEmpty()) {
1329 for(QStringList::ConstIterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
1330 QString mkspec = (*it) + QDir::separator() + "default";
1331 QFileInfo default_info(mkspec);
1332 if(default_info.exists() && default_info.isDir()) {
1333 qmakespec = mkspec;
1334 break;
1335 }
1336 }
1337 if(qmakespec.isEmpty()) {
1338 fprintf(stderr, "QMAKESPEC has not been set, so configuration cannot be deduced.\n");
1339 return false;
1340 }
1341 Option::mkfile::qmakespec = qmakespec;
1342 }
1343
1344 if(QDir::isRelativePath(qmakespec)) {
1345 if (QFile::exists(qmakespec+"/qmake.conf")) {
1346 Option::mkfile::qmakespec = QFileInfo(Option::mkfile::qmakespec).absoluteFilePath();
[363]1347 } else if (QFile::exists(Option::output_dir+"/"+qmakespec+"/qmake.conf")) {
1348 qmakespec = Option::mkfile::qmakespec = QFileInfo(Option::output_dir+"/"+qmakespec).absoluteFilePath();
[2]1349 } else {
[363]1350 bool found_mkspec = false;
1351 for(QStringList::ConstIterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
1352 QString mkspec = (*it) + QDir::separator() + qmakespec;
1353 if(QFile::exists(mkspec)) {
1354 found_mkspec = true;
1355 Option::mkfile::qmakespec = qmakespec = mkspec;
1356 break;
[2]1357 }
1358 }
[363]1359 if(!found_mkspec) {
1360 fprintf(stderr, "Could not find mkspecs for your QMAKESPEC(%s) after trying:\n\t%s\n",
1361 qmakespec.toLatin1().constData(), mkspec_roots.join("\n\t").toLatin1().constData());
1362 return false;
1363 }
[2]1364 }
1365 }
1366
1367 // parse qmake configuration
1368 while(qmakespec.endsWith(QString(QChar(QDir::separator()))))
1369 qmakespec.truncate(qmakespec.length()-1);
1370 QString spec = qmakespec + QDir::separator() + "qmake.conf";
1371 debug_msg(1, "QMAKESPEC conf: reading %s", spec.toLatin1().constData());
1372 if(!read(spec, base_vars)) {
1373 fprintf(stderr, "Failure to read QMAKESPEC conf file %s.\n", spec.toLatin1().constData());
1374 return false;
1375 }
[846]1376 validateModes();
[561]1377
[2]1378 if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty()) {
1379 debug_msg(1, "QMAKECACHE file: reading %s", Option::mkfile::cachefile.toLatin1().constData());
1380 read(Option::mkfile::cachefile, base_vars);
1381 }
1382 }
1383
1384 if(cmd & ReadFeatures) {
1385 debug_msg(1, "Processing default_pre: %s", vars["CONFIG"].join("::").toLatin1().constData());
1386 if(doProjectInclude("default_pre", IncludeFlagFeature, base_vars) == IncludeNoExist)
1387 doProjectInclude("default", IncludeFlagFeature, base_vars);
1388 }
1389 }
1390
1391 vars = base_vars; // start with the base
1392
1393 //get a default
1394 if(pfile != "-" && vars["TARGET"].isEmpty())
1395 vars["TARGET"].append(QFileInfo(pfile).baseName());
1396
1397 //before commandline
1398 if(cmd & ReadCmdLine) {
1399 cfile = pfile;
1400 parser.file = "(internal)";
1401 parser.from_file = false;
1402 parser.line_no = 1; //really arg count now.. duh
1403 reset();
1404 for(QStringList::ConstIterator it = Option::before_user_vars.begin();
1405 it != Option::before_user_vars.end(); ++it) {
1406 if(!parse((*it), vars)) {
1407 fprintf(stderr, "Argument failed to parse: %s\n", (*it).toLatin1().constData());
1408 return false;
1409 }
1410 parser.line_no++;
1411 }
1412 }
1413
1414 //commandline configs
1415 if(cmd & ReadConfigs && !Option::user_configs.isEmpty()) {
1416 parser.file = "(configs)";
1417 parser.from_file = false;
1418 parser.line_no = 1; //really arg count now.. duh
1419 parse("CONFIG += " + Option::user_configs.join(" "), vars);
1420 }
1421
1422 if(cmd & ReadProFile) { // parse project file
1423 debug_msg(1, "Project file: reading %s", pfile.toLatin1().constData());
[561]1424 if(pfile != "-" && !QFile::exists(pfile) && !pfile.endsWith(Option::pro_ext))
1425 pfile += Option::pro_ext;
[2]1426 if(!read(pfile, vars))
1427 return false;
1428 }
1429
1430 if(cmd & ReadCmdLine) {
1431 parser.file = "(internal)";
1432 parser.from_file = false;
1433 parser.line_no = 1; //really arg count now.. duh
1434 reset();
1435 for(QStringList::ConstIterator it = Option::after_user_vars.begin();
1436 it != Option::after_user_vars.end(); ++it) {
1437 if(!parse((*it), vars)) {
1438 fprintf(stderr, "Argument failed to parse: %s\n", (*it).toLatin1().constData());
1439 return false;
1440 }
1441 parser.line_no++;
1442 }
1443 }
1444
1445 //after configs (set in BUILDS)
1446 if(cmd & ReadConfigs && !Option::after_user_configs.isEmpty()) {
1447 parser.file = "(configs)";
1448 parser.from_file = false;
1449 parser.line_no = 1; //really arg count now.. duh
1450 parse("CONFIG += " + Option::after_user_configs.join(" "), vars);
1451 }
1452
1453 if(pfile != "-" && vars["TARGET"].isEmpty())
1454 vars["TARGET"].append(QFileInfo(pfile).baseName());
1455
1456 if(cmd & ReadConfigs && !Option::user_configs.isEmpty()) {
1457 parser.file = "(configs)";
1458 parser.from_file = false;
1459 parser.line_no = 1; //really arg count now.. duh
1460 parse("CONFIG += " + Option::user_configs.join(" "), base_vars);
1461 }
1462
1463 if(cmd & ReadFeatures) {
1464 debug_msg(1, "Processing default_post: %s", vars["CONFIG"].join("::").toLatin1().constData());
1465 doProjectInclude("default_post", IncludeFlagFeature, vars);
1466
1467 QHash<QString, bool> processed;
1468 const QStringList &configs = vars["CONFIG"];
1469 debug_msg(1, "Processing CONFIG features: %s", configs.join("::").toLatin1().constData());
1470 while(1) {
1471 bool finished = true;
1472 for(int i = configs.size()-1; i >= 0; --i) {
1473 const QString config = configs[i].toLower();
1474 if(!processed.contains(config)) {
1475 processed.insert(config, true);
1476 if(doProjectInclude(config, IncludeFlagFeature, vars) == IncludeSuccess) {
1477 finished = false;
1478 break;
1479 }
1480 }
1481 }
1482 if(finished)
1483 break;
1484 }
1485 }
1486 Option::postProcessProject(this); // let Option post-process
1487 return true;
1488}
1489
[846]1490void QMakeProject::validateModes()
1491{
1492 if (Option::host_mode == Option::HOST_UNKNOWN_MODE
1493 || Option::target_mode == Option::TARG_UNKNOWN_MODE) {
1494 Option::HOST_MODE host_mode;
1495 Option::TARG_MODE target_mode;
1496 const QStringList &gen = base_vars.value("MAKEFILE_GENERATOR");
1497 if (gen.isEmpty()) {
1498 fprintf(stderr, "%s:%d: Using OS scope before setting MAKEFILE_GENERATOR\n",
1499 parser.file.toLatin1().constData(), parser.line_no);
1500 } else if (MetaMakefileGenerator::modesForGenerator(gen.first(),
1501 &host_mode, &target_mode)) {
1502 if (Option::host_mode == Option::HOST_UNKNOWN_MODE) {
1503 Option::host_mode = host_mode;
1504 Option::applyHostMode();
1505 }
1506
1507 if (Option::target_mode == Option::TARG_UNKNOWN_MODE) {
1508 const QStringList &tgt = base_vars.value("TARGET_PLATFORM");
1509 if (!tgt.isEmpty()) {
1510 const QString &os = tgt.first();
1511 if (os == "unix")
1512 Option::target_mode = Option::TARG_UNIX_MODE;
1513 else if (os == "macx")
1514 Option::target_mode = Option::TARG_MACX_MODE;
1515 else if (os == "symbian")
1516 Option::target_mode = Option::TARG_SYMBIAN_MODE;
1517 else if (os == "win32")
1518 Option::target_mode = Option::TARG_WIN_MODE;
1519 else
1520 fprintf(stderr, "Unknown target platform specified: %s\n",
1521 os.toLatin1().constData());
1522 } else {
1523 Option::target_mode = target_mode;
1524 }
1525 }
1526 }
1527 }
1528}
1529
[2]1530bool
1531QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QStringList> *place)
1532{
1533 if(x.isEmpty())
1534 return true;
1535
1536 //magic types for easy flipping
1537 if(x == "true")
1538 return true;
1539 else if(x == "false")
1540 return false;
1541
[846]1542 if (x == "unix") {
1543 validateModes();
1544 return Option::target_mode == Option::TARG_UNIX_MODE
1545 || Option::target_mode == Option::TARG_MACX_MODE
1546 || Option::target_mode == Option::TARG_SYMBIAN_MODE;
1547 } else if (x == "macx" || x == "mac") {
1548 validateModes();
1549 return Option::target_mode == Option::TARG_MACX_MODE;
1550 } else if (x == "symbian") {
1551 validateModes();
1552 return Option::target_mode == Option::TARG_SYMBIAN_MODE;
1553 } else if (x == "win32") {
1554 validateModes();
1555 return Option::target_mode == Option::TARG_WIN_MODE;
1556 }
1557
1558 //mkspecs
[561]1559 static QString spec;
1560 if(spec.isEmpty())
1561 spec = QFileInfo(Option::mkfile::qmakespec).fileName();
[27]1562 else if(Option::target_mode == Option::TARG_OS2_MODE && x == "os2")
1563 return true;
[2]1564 QRegExp re(x, Qt::CaseSensitive, QRegExp::Wildcard);
1565 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1566 return true;
1567#ifdef Q_OS_UNIX
1568 else if(spec == "default") {
1569 static char *buffer = NULL;
1570 if(!buffer) {
1571 buffer = (char *)malloc(1024);
1572 qmakeAddCacheClear(qmakeFreeCacheClear, (void**)&buffer);
1573 }
1574 int l = readlink(Option::mkfile::qmakespec.toLatin1(), buffer, 1024);
1575 if(l != -1) {
1576 buffer[l] = '\0';
1577 QString r = buffer;
1578 if(r.lastIndexOf('/') != -1)
1579 r = r.mid(r.lastIndexOf('/') + 1);
1580 if((regex && re.exactMatch(r)) || (!regex && r == x))
1581 return true;
1582 }
1583 }
[27]1584#elif defined(Q_OS_WIN) || defined(Q_OS_OS2)
[2]1585 else if(spec == "default") {
1586 // We can't resolve symlinks as they do on Unix, so configure.exe puts the source of the
1587 // qmake.conf at the end of the default/qmake.conf in the QMAKESPEC_ORG variable.
1588 const QStringList &spec_org = (place ? (*place)["QMAKESPEC_ORIGINAL"]
1589 : vars["QMAKESPEC_ORIGINAL"]);
1590 if (!spec_org.isEmpty()) {
[28]1591 spec = QFileInfo(spec_org.at(0)).fileName();
[2]1592 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1593 return true;
1594 }
1595 }
1596#endif
1597
1598 //simple matching
1599 const QStringList &configs = (place ? (*place)["CONFIG"] : vars["CONFIG"]);
1600 for(QStringList::ConstIterator it = configs.begin(); it != configs.end(); ++it) {
1601 if(((regex && re.exactMatch((*it))) || (!regex && (*it) == x)) && re.exactMatch((*it)))
1602 return true;
1603 }
1604 return false;
1605}
1606
1607bool
1608QMakeProject::doProjectTest(QString str, QMap<QString, QStringList> &place)
1609{
1610 QString chk = remove_quotes(str);
1611 if(chk.isEmpty())
1612 return true;
1613 bool invert_test = (chk.left(1) == "!");
1614 if(invert_test)
1615 chk = chk.mid(1);
1616
1617 bool test=false;
1618 int lparen = chk.indexOf('(');
1619 if(lparen != -1) { // if there is an lparen in the chk, it IS a function
1620 int rparen = chk.indexOf(')', lparen);
1621 if(rparen == -1) {
1622 qmake_error_msg("Function missing right paren: " + chk);
1623 } else {
1624 QString func = chk.left(lparen);
1625 test = doProjectTest(func, chk.mid(lparen+1, rparen - lparen - 1), place);
1626 }
1627 } else {
1628 test = isActiveConfig(chk, true, &place);
1629 }
1630 if(invert_test)
1631 return !test;
1632 return test;
1633}
1634
1635bool
1636QMakeProject::doProjectTest(QString func, const QString &params,
1637 QMap<QString, QStringList> &place)
1638{
1639 return doProjectTest(func, split_arg_list(params), place);
1640}
1641
1642QMakeProject::IncludeStatus
1643QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringList> &place)
1644{
1645 enum { UnknownFormat, ProFormat, JSFormat } format = UnknownFormat;
1646 if(flags & IncludeFlagFeature) {
1647 if(!file.endsWith(Option::prf_ext))
1648 file += Option::prf_ext;
1649 if(file.indexOf(Option::dir_sep) == -1 || !QFile::exists(file)) {
1650 static QStringList *feature_roots = 0;
1651 if(!feature_roots) {
[846]1652 validateModes();
[2]1653 feature_roots = new QStringList(qmake_feature_paths(prop));
1654 qmakeAddCacheClear(qmakeDeleteCacheClear_QStringList, (void**)&feature_roots);
1655 }
1656 debug_msg(2, "Looking for feature '%s' in (%s)", file.toLatin1().constData(),
1657 feature_roots->join("::").toLatin1().constData());
1658 int start_root = 0;
1659 if(parser.from_file) {
1660 QFileInfo currFile(parser.file), prfFile(file);
1661 if(currFile.fileName() == prfFile.fileName()) {
1662 currFile = QFileInfo(currFile.canonicalFilePath());
1663 for(int root = 0; root < feature_roots->size(); ++root) {
1664 prfFile = QFileInfo(feature_roots->at(root) +
1665 QDir::separator() + file).canonicalFilePath();
1666 if(prfFile == currFile) {
1667 start_root = root+1;
1668 break;
1669 }
1670 }
1671 }
1672 }
1673 for(int root = start_root; root < feature_roots->size(); ++root) {
1674 QString prf(feature_roots->at(root) + QDir::separator() + file);
1675 if(QFile::exists(prf + Option::js_ext)) {
1676 format = JSFormat;
1677 file = prf + Option::js_ext;
1678 break;
1679 } else if(QFile::exists(prf)) {
1680 format = ProFormat;
1681 file = prf;
1682 break;
1683 }
1684 }
1685 if(format == UnknownFormat)
1686 return IncludeNoExist;
1687 if(place["QMAKE_INTERNAL_INCLUDED_FEATURES"].indexOf(file) != -1)
1688 return IncludeFeatureAlreadyLoaded;
1689 place["QMAKE_INTERNAL_INCLUDED_FEATURES"].append(file);
1690 }
1691 }
1692 if(QDir::isRelativePath(file)) {
1693 QStringList include_roots;
1694 if(Option::output_dir != qmake_getpwd())
1695 include_roots << qmake_getpwd();
1696 include_roots << Option::output_dir;
[363]1697 for(int root = 0; root < include_roots.size(); ++root) {
1698 QString testName = QDir::toNativeSeparators(include_roots[root]);
1699 if (!testName.endsWith(QString(QDir::separator())))
1700 testName += QDir::separator();
1701 testName += file;
[2]1702 if(QFile::exists(testName)) {
1703 file = testName;
1704 break;
1705 }
1706 }
1707 }
1708 if(format == UnknownFormat) {
1709 if(QFile::exists(file)) {
1710 if(file.endsWith(Option::js_ext))
1711 format = JSFormat;
1712 else
1713 format = ProFormat;
1714 } else {
1715 return IncludeNoExist;
1716 }
1717 }
1718 if(Option::mkfile::do_preprocess) //nice to see this first..
1719 fprintf(stderr, "#switching file %s(%s) - %s:%d\n", (flags & IncludeFlagFeature) ? "load" : "include",
1720 file.toLatin1().constData(),
1721 parser.file.toLatin1().constData(), parser.line_no);
1722 debug_msg(1, "Project Parser: %s'ing file %s.", (flags & IncludeFlagFeature) ? "load" : "include",
1723 file.toLatin1().constData());
1724
1725 QString orig_file = file;
1726 int di = file.lastIndexOf(QDir::separator());
1727 QString oldpwd = qmake_getpwd();
1728 if(di != -1) {
1729 if(!qmake_setpwd(file.left(file.lastIndexOf(QDir::separator())))) {
1730 fprintf(stderr, "Cannot find directory: %s\n", file.left(di).toLatin1().constData());
1731 return IncludeFailure;
1732 }
1733 }
1734 bool parsed = false;
1735 parser_info pi = parser;
1736 if(format == JSFormat) {
1737 warn_msg(WarnParser, "%s:%d: QtScript support disabled for %s.",
1738 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1739 } else {
1740 QStack<ScopeBlock> sc = scope_blocks;
1741 IteratorBlock *it = iterator;
1742 FunctionBlock *fu = function;
1743 if(flags & (IncludeFlagNewProject|IncludeFlagNewParser)) {
1744 // The "project's variables" are used in other places (eg. export()) so it's not
1745 // possible to use "place" everywhere. Instead just set variables and grab them later
1746 QMakeProject proj(this, &place);
1747 if(flags & IncludeFlagNewParser) {
1748#if 1
1749 if(proj.doProjectInclude("default_pre", IncludeFlagFeature, proj.variables()) == IncludeNoExist)
1750 proj.doProjectInclude("default", IncludeFlagFeature, proj.variables());
1751#endif
[846]1752 parsed = proj.read(file, proj.variables()); // parse just that file (fromfile, infile)
[2]1753 } else {
[846]1754 parsed = proj.read(file); // parse all aux files (load/include into)
[2]1755 }
1756 place = proj.variables();
1757 } else {
1758 parsed = read(file, place);
1759 }
1760 iterator = it;
1761 function = fu;
1762 scope_blocks = sc;
1763 }
1764 if(parsed) {
1765 if(place["QMAKE_INTERNAL_INCLUDED_FILES"].indexOf(orig_file) == -1)
1766 place["QMAKE_INTERNAL_INCLUDED_FILES"].append(orig_file);
1767 } else {
1768 warn_msg(WarnParser, "%s:%d: Failure to include file %s.",
1769 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1770 }
1771 parser = pi;
1772 qmake_setpwd(oldpwd);
1773 if(!parsed)
1774 return IncludeParseFailure;
1775 return IncludeSuccess;
1776}
1777
1778QStringList
1779QMakeProject::doProjectExpand(QString func, const QString &params,
1780 QMap<QString, QStringList> &place)
1781{
1782 return doProjectExpand(func, split_arg_list(params), place);
1783}
1784
1785QStringList
1786QMakeProject::doProjectExpand(QString func, QStringList args,
1787 QMap<QString, QStringList> &place)
1788{
1789 QList<QStringList> args_list;
1790 for(int i = 0; i < args.size(); ++i) {
1791 QStringList arg = split_value_list(args[i]), tmp;
1792 for(int i = 0; i < arg.size(); ++i)
1793 tmp += doVariableReplaceExpand(arg[i], place);;
1794 args_list += tmp;
1795 }
1796 return doProjectExpand(func, args_list, place);
1797}
1798
[651]1799// defined in symbian generator
1800extern QString generate_test_uid(const QString& target);
1801
[2]1802QStringList
1803QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
1804 QMap<QString, QStringList> &place)
1805{
1806 func = func.trimmed();
1807 if(replaceFunctions.contains(func)) {
1808 FunctionBlock *defined = replaceFunctions[func];
1809 function_blocks.push(defined);
1810 QStringList ret;
1811 defined->exec(args_list, this, place, ret);
[405]1812 FunctionBlock *popped = function_blocks.pop();
1813 Q_ASSERT(popped == defined);
1814 Q_UNUSED(popped);
[2]1815 return ret;
1816 }
1817
1818 QStringList args; //why don't the builtin functions just use args_list? --Sam
1819 for(int i = 0; i < args_list.size(); ++i)
1820 args += args_list[i].join(QString(Option::field_sep));
1821
[846]1822 ExpandFunc func_t = qmake_expandFunctions().value(func);
1823 if (!func_t && (func_t = qmake_expandFunctions().value(func.toLower())))
1824 warn_msg(WarnDeprecated, "%s:%d: Using uppercased builtin functions is deprecated.",
1825 parser.file.toLatin1().constData(), parser.line_no);
[2]1826 debug_msg(1, "Running project expand: %s(%s) [%d]",
1827 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
1828
1829 QStringList ret;
1830 switch(func_t) {
1831 case E_MEMBER: {
1832 if(args.count() < 1 || args.count() > 3) {
1833 fprintf(stderr, "%s:%d: member(var, start, end) requires three arguments.\n",
1834 parser.file.toLatin1().constData(), parser.line_no);
1835 } else {
1836 bool ok = true;
1837 const QStringList &var = values(args.first(), place);
1838 int start = 0, end = 0;
1839 if(args.count() >= 2) {
1840 QString start_str = args[1];
1841 start = start_str.toInt(&ok);
1842 if(!ok) {
1843 if(args.count() == 2) {
1844 int dotdot = start_str.indexOf("..");
1845 if(dotdot != -1) {
1846 start = start_str.left(dotdot).toInt(&ok);
1847 if(ok)
1848 end = start_str.mid(dotdot+2).toInt(&ok);
1849 }
1850 }
1851 if(!ok)
1852 fprintf(stderr, "%s:%d: member() argument 2 (start) '%s' invalid.\n",
1853 parser.file.toLatin1().constData(), parser.line_no,
1854 start_str.toLatin1().constData());
1855 } else {
1856 end = start;
1857 if(args.count() == 3)
1858 end = args[2].toInt(&ok);
1859 if(!ok)
1860 fprintf(stderr, "%s:%d: member() argument 3 (end) '%s' invalid.\n",
1861 parser.file.toLatin1().constData(), parser.line_no,
1862 args[2].toLatin1().constData());
1863 }
1864 }
1865 if(ok) {
1866 if(start < 0)
1867 start += var.count();
1868 if(end < 0)
1869 end += var.count();
1870 if(start < 0 || start >= var.count() || end < 0 || end >= var.count()) {
1871 //nothing
1872 } else if(start < end) {
1873 for(int i = start; i <= end && (int)var.count() >= i; i++)
1874 ret += var[i];
1875 } else {
1876 for(int i = start; i >= end && (int)var.count() >= i && i >= 0; i--)
1877 ret += var[i];
1878 }
1879 }
1880 }
1881 break; }
1882 case E_FIRST:
1883 case E_LAST: {
1884 if(args.count() != 1) {
1885 fprintf(stderr, "%s:%d: %s(var) requires one argument.\n",
1886 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
1887 } else {
1888 const QStringList &var = values(args.first(), place);
1889 if(!var.isEmpty()) {
1890 if(func_t == E_FIRST)
1891 ret = QStringList(var[0]);
1892 else
1893 ret = QStringList(var[var.size()-1]);
1894 }
1895 }
1896 break; }
1897 case E_CAT: {
1898 if(args.count() < 1 || args.count() > 2) {
1899 fprintf(stderr, "%s:%d: cat(file) requires one argument.\n",
1900 parser.file.toLatin1().constData(), parser.line_no);
1901 } else {
1902 QString file = args[0];
1903 file = Option::fixPathToLocalOS(file);
1904
1905 bool singleLine = true;
1906 if(args.count() > 1)
1907 singleLine = (args[1].toLower() == "true");
1908
1909 QFile qfile(file);
1910 if(qfile.open(QIODevice::ReadOnly)) {
1911 QTextStream stream(&qfile);
1912 while(!stream.atEnd()) {
1913 ret += split_value_list(stream.readLine().trimmed());
1914 if(!singleLine)
1915 ret += "\n";
1916 }
1917 qfile.close();
1918 }
1919 }
1920 break; }
1921 case E_FROMFILE: {
1922 if(args.count() != 2) {
1923 fprintf(stderr, "%s:%d: fromfile(file, variable) requires two arguments.\n",
1924 parser.file.toLatin1().constData(), parser.line_no);
1925 } else {
1926 QString file = args[0], seek_var = args[1];
1927 file = Option::fixPathToLocalOS(file);
1928
1929 QMap<QString, QStringList> tmp;
1930 if(doProjectInclude(file, IncludeFlagNewParser, tmp) == IncludeSuccess) {
1931 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
1932 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
1933 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
1934 for(int i = 0; i < in.size(); ++i) {
1935 if(out.indexOf(in[i]) == -1)
1936 out += in[i];
1937 }
1938 }
1939 ret = tmp[seek_var];
1940 }
1941 }
1942 break; }
1943 case E_EVAL: {
1944 if(args.count() < 1 || args.count() > 2) {
1945 fprintf(stderr, "%s:%d: eval(variable) requires one argument.\n",
1946 parser.file.toLatin1().constData(), parser.line_no);
1947
1948 } else {
1949 const QMap<QString, QStringList> *source = &place;
1950 if(args.count() == 2) {
1951 if(args.at(1) == "Global") {
1952 source = &vars;
1953 } else if(args.at(1) == "Local") {
1954 source = &place;
1955 } else {
1956 fprintf(stderr, "%s:%d: unexpected source to eval.\n", parser.file.toLatin1().constData(),
1957 parser.line_no);
1958 }
1959 }
1960 ret += source->value(args.at(0));
1961 }
1962 break; }
1963 case E_LIST: {
1964 static int x = 0;
1965 QString tmp;
1966 tmp.sprintf(".QMAKE_INTERNAL_TMP_VAR_%d", x++);
1967 ret = QStringList(tmp);
1968 QStringList &lst = (*((QMap<QString, QStringList>*)&place))[tmp];
1969 lst.clear();
1970 for(QStringList::ConstIterator arg_it = args.begin();
1971 arg_it != args.end(); ++arg_it)
1972 lst += split_value_list((*arg_it));
1973 break; }
1974 case E_SPRINTF: {
1975 if(args.count() < 1) {
1976 fprintf(stderr, "%s:%d: sprintf(format, ...) requires one argument.\n",
1977 parser.file.toLatin1().constData(), parser.line_no);
1978 } else {
1979 QString tmp = args.at(0);
1980 for(int i = 1; i < args.count(); ++i)
1981 tmp = tmp.arg(args.at(i));
1982 ret = split_value_list(tmp);
1983 }
1984 break; }
1985 case E_JOIN: {
1986 if(args.count() < 1 || args.count() > 4) {
1987 fprintf(stderr, "%s:%d: join(var, glue, before, after) requires four"
1988 "arguments.\n", parser.file.toLatin1().constData(), parser.line_no);
1989 } else {
1990 QString glue, before, after;
1991 if(args.count() >= 2)
1992 glue = args[1];
1993 if(args.count() >= 3)
1994 before = args[2];
1995 if(args.count() == 4)
1996 after = args[3];
1997 const QStringList &var = values(args.first(), place);
1998 if(!var.isEmpty())
1999 ret = split_value_list(before + var.join(glue) + after);
2000 }
2001 break; }
2002 case E_SPLIT: {
2003 if(args.count() < 1 || args.count() > 2) {
2004 fprintf(stderr, "%s:%d split(var, sep) requires one or two arguments\n",
2005 parser.file.toLatin1().constData(), parser.line_no);
2006 } else {
2007 QString sep = QString(Option::field_sep);
2008 if(args.count() >= 2)
2009 sep = args[1];
2010 QStringList var = values(args.first(), place);
2011 for(QStringList::ConstIterator vit = var.begin(); vit != var.end(); ++vit) {
2012 QStringList lst = (*vit).split(sep);
2013 for(QStringList::ConstIterator spltit = lst.begin(); spltit != lst.end(); ++spltit)
2014 ret += (*spltit);
2015 }
2016 }
2017 break; }
2018 case E_BASENAME:
2019 case E_DIRNAME:
2020 case E_SECTION: {
2021 bool regexp = false;
2022 QString sep, var;
2023 int beg=0, end=-1;
2024 if(func_t == E_SECTION) {
2025 if(args.count() != 3 && args.count() != 4) {
2026 fprintf(stderr, "%s:%d section(var, sep, begin, end) requires three argument\n",
2027 parser.file.toLatin1().constData(), parser.line_no);
2028 } else {
2029 var = args[0];
2030 sep = args[1];
2031 beg = args[2].toInt();
2032 if(args.count() == 4)
2033 end = args[3].toInt();
2034 }
2035 } else {
2036 if(args.count() != 1) {
2037 fprintf(stderr, "%s:%d %s(var) requires one argument.\n",
2038 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
2039 } else {
2040 var = args[0];
2041 regexp = true;
2042 sep = "[" + QRegExp::escape(Option::dir_sep) + "/]";
2043 if(func_t == E_DIRNAME)
2044 end = -2;
2045 else
2046 beg = -1;
2047 }
2048 }
2049 if(!var.isNull()) {
2050 const QStringList &l = values(var, place);
2051 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2052 QString separator = sep;
2053 if(regexp)
2054 ret += (*it).section(QRegExp(separator), beg, end);
2055 else
2056 ret += (*it).section(separator, beg, end);
2057 }
2058 }
2059 break; }
2060 case E_FIND: {
2061 if(args.count() != 2) {
2062 fprintf(stderr, "%s:%d find(var, str) requires two arguments\n",
2063 parser.file.toLatin1().constData(), parser.line_no);
2064 } else {
2065 QRegExp regx(args[1]);
2066 const QStringList &var = values(args.first(), place);
2067 for(QStringList::ConstIterator vit = var.begin();
2068 vit != var.end(); ++vit) {
2069 if(regx.indexIn(*vit) != -1)
2070 ret += (*vit);
2071 }
2072 }
2073 break; }
2074 case E_SYSTEM: {
2075 if(args.count() < 1 || args.count() > 2) {
2076 fprintf(stderr, "%s:%d system(execut) requires one argument.\n",
2077 parser.file.toLatin1().constData(), parser.line_no);
2078 } else {
2079 char buff[256];
2080 bool singleLine = true;
2081 if(args.count() > 1)
2082 singleLine = (args[1].toLower() == "true");
2083 QString output;
[561]2084 FILE *proc = QT_POPEN(args[0].toLatin1(), "r");
[2]2085 while(proc && !feof(proc)) {
2086 int read_in = int(fread(buff, 1, 255, proc));
2087 if(!read_in)
2088 break;
2089 for(int i = 0; i < read_in; i++) {
2090 if((singleLine && buff[i] == '\n') || buff[i] == '\t')
2091 buff[i] = ' ';
2092 }
2093 buff[read_in] = '\0';
2094 output += buff;
2095 }
2096 ret += split_value_list(output);
2097 if(proc)
2098 QT_PCLOSE(proc);
2099 }
2100 break; }
2101 case E_UNIQUE: {
2102 if(args.count() != 1) {
2103 fprintf(stderr, "%s:%d unique(var) requires one argument.\n",
2104 parser.file.toLatin1().constData(), parser.line_no);
2105 } else {
2106 const QStringList &var = values(args.first(), place);
2107 for(int i = 0; i < var.count(); i++) {
2108 if(!ret.contains(var[i]))
2109 ret.append(var[i]);
2110 }
2111 }
2112 break; }
2113 case E_QUOTE:
2114 ret = args;
2115 break;
2116 case E_ESCAPE_EXPAND: {
2117 for(int i = 0; i < args.size(); ++i) {
2118 QChar *i_data = args[i].data();
2119 int i_len = args[i].length();
2120 for(int x = 0; x < i_len; ++x) {
2121 if(*(i_data+x) == '\\' && x < i_len-1) {
2122 if(*(i_data+x+1) == '\\') {
2123 ++x;
2124 } else {
2125 struct {
2126 char in, out;
2127 } mapped_quotes[] = {
2128 { 'n', '\n' },
2129 { 't', '\t' },
2130 { 'r', '\r' },
2131 { 0, 0 }
2132 };
2133 for(int i = 0; mapped_quotes[i].in; ++i) {
2134 if(*(i_data+x+1) == mapped_quotes[i].in) {
2135 *(i_data+x) = mapped_quotes[i].out;
2136 if(x < i_len-2)
2137 memmove(i_data+x+1, i_data+x+2, (i_len-x-2)*sizeof(QChar));
2138 --i_len;
2139 break;
2140 }
2141 }
2142 }
2143 }
2144 }
2145 ret.append(QString(i_data, i_len));
2146 }
2147 break; }
2148 case E_RE_ESCAPE: {
2149 for(int i = 0; i < args.size(); ++i)
2150 ret += QRegExp::escape(args[i]);
2151 break; }
2152 case E_UPPER:
2153 case E_LOWER: {
2154 for(int i = 0; i < args.size(); ++i) {
2155 if(func_t == E_UPPER)
2156 ret += args[i].toUpper();
2157 else
2158 ret += args[i].toLower();
2159 }
2160 break; }
2161 case E_FILES: {
2162 if(args.count() != 1 && args.count() != 2) {
2163 fprintf(stderr, "%s:%d files(pattern) requires one argument.\n",
2164 parser.file.toLatin1().constData(), parser.line_no);
2165 } else {
2166 bool recursive = false;
2167 if(args.count() == 2)
2168 recursive = (args[1].toLower() == "true" || args[1].toInt());
2169 QStringList dirs;
2170 QString r = Option::fixPathToLocalOS(args[0]);
2171 int slash = r.lastIndexOf(QDir::separator());
2172 if(slash != -1) {
2173 dirs.append(r.left(slash));
2174 r = r.mid(slash+1);
2175 } else {
2176 dirs.append("");
2177 }
2178
2179 const QRegExp regex(r, Qt::CaseSensitive, QRegExp::Wildcard);
2180 for(int d = 0; d < dirs.count(); d++) {
2181 QString dir = dirs[d];
[846]2182 if(!dir.isEmpty() && !dir.endsWith(QDir::separator()))
[2]2183 dir += "/";
2184
2185 QDir qdir(dir);
2186 for(int i = 0; i < (int)qdir.count(); ++i) {
2187 if(qdir[i] == "." || qdir[i] == "..")
2188 continue;
2189 QString fname = dir + qdir[i];
2190 if(QFileInfo(fname).isDir()) {
2191 if(recursive)
2192 dirs.append(fname);
2193 }
2194 if(regex.exactMatch(qdir[i]))
2195 ret += fname;
2196 }
2197 }
2198 }
2199 break; }
2200 case E_PROMPT: {
2201 if(args.count() != 1) {
2202 fprintf(stderr, "%s:%d prompt(question) requires one argument.\n",
2203 parser.file.toLatin1().constData(), parser.line_no);
[846]2204 } else if(pfile == "-") {
[2]2205 fprintf(stderr, "%s:%d prompt(question) cannot be used when '-o -' is used.\n",
2206 parser.file.toLatin1().constData(), parser.line_no);
2207 } else {
2208 QString msg = fixEnvVariables(args.first());
2209 if(!msg.endsWith("?"))
2210 msg += "?";
2211 fprintf(stderr, "Project %s: %s ", func.toUpper().toLatin1().constData(),
2212 msg.toLatin1().constData());
2213
2214 QFile qfile;
2215 if(qfile.open(stdin, QIODevice::ReadOnly)) {
2216 QTextStream t(&qfile);
2217 ret = split_value_list(t.readLine());
2218 }
2219 }
2220 break; }
2221 case E_REPLACE: {
2222 if(args.count() != 3 ) {
2223 fprintf(stderr, "%s:%d replace(var, before, after) requires three arguments\n",
2224 parser.file.toLatin1().constData(), parser.line_no);
2225 } else {
2226 const QRegExp before( args[1] );
2227 const QString after( args[2] );
2228 QStringList var = values(args.first(), place);
2229 for(QStringList::Iterator it = var.begin(); it != var.end(); ++it)
2230 ret += it->replace(before, after);
2231 }
2232 break; }
[561]2233 case E_SIZE: {
2234 if(args.count() != 1) {
2235 fprintf(stderr, "%s:%d: size(var) requires one argument.\n",
2236 parser.file.toLatin1().constData(), parser.line_no);
2237 } else {
[846]2238 int size = values(args[0], place).size();
[561]2239 ret += QString::number(size);
2240 }
2241 break; }
[651]2242 case E_GENERATE_UID:
2243 if (args.count() != 1) {
2244 fprintf(stderr, "%s:%d: generate_uid(var) requires one argument.\n",
2245 parser.file.toLatin1().constData(), parser.line_no);
2246 } else {
2247 ret += generate_test_uid(args.first());
2248 }
2249 break;
[2]2250 default: {
2251 fprintf(stderr, "%s:%d: Unknown replace function: %s\n",
2252 parser.file.toLatin1().constData(), parser.line_no,
2253 func.toLatin1().constData());
2254 break; }
2255 }
2256 return ret;
2257}
2258
2259bool
2260QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStringList> &place)
2261{
2262 QList<QStringList> args_list;
2263 for(int i = 0; i < args.size(); ++i) {
2264 QStringList arg = split_value_list(args[i]), tmp;
2265 for(int i = 0; i < arg.size(); ++i)
2266 tmp += doVariableReplaceExpand(arg[i], place);
2267 args_list += tmp;
2268 }
2269 return doProjectTest(func, args_list, place);
2270}
2271
2272bool
2273QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QString, QStringList> &place)
2274{
2275 func = func.trimmed();
2276
2277 if(testFunctions.contains(func)) {
2278 FunctionBlock *defined = testFunctions[func];
2279 QStringList ret;
2280 function_blocks.push(defined);
2281 defined->exec(args_list, this, place, ret);
[405]2282 FunctionBlock *popped = function_blocks.pop();
2283 Q_ASSERT(popped == defined);
2284 Q_UNUSED(popped);
[2]2285
2286 if(ret.isEmpty()) {
2287 return true;
2288 } else {
2289 if(ret.first() == "true") {
2290 return true;
2291 } else if(ret.first() == "false") {
2292 return false;
2293 } else {
2294 bool ok;
2295 int val = ret.first().toInt(&ok);
2296 if(ok)
2297 return val;
2298 fprintf(stderr, "%s:%d Unexpected return value from test %s [%s].\n",
2299 parser.file.toLatin1().constData(),
2300 parser.line_no, func.toLatin1().constData(),
2301 ret.join("::").toLatin1().constData());
2302 }
2303 return false;
2304 }
2305 return false;
2306 }
2307
2308 QStringList args; //why don't the builtin functions just use args_list? --Sam
2309 for(int i = 0; i < args_list.size(); ++i)
2310 args += args_list[i].join(QString(Option::field_sep));
2311
2312 TestFunc func_t = qmake_testFunctions().value(func);
2313 debug_msg(1, "Running project test: %s(%s) [%d]",
2314 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
2315
2316 switch(func_t) {
2317 case T_REQUIRES:
2318 return doProjectCheckReqs(args, place);
2319 case T_LESSTHAN:
2320 case T_GREATERTHAN: {
2321 if(args.count() != 2) {
2322 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2323 parser.line_no, func.toLatin1().constData());
2324 return false;
2325 }
2326 QString rhs(args[1]), lhs(values(args[0], place).join(QString(Option::field_sep)));
2327 bool ok;
2328 int rhs_int = rhs.toInt(&ok);
2329 if(ok) { // do integer compare
2330 int lhs_int = lhs.toInt(&ok);
2331 if(ok) {
[561]2332 if(func_t == T_GREATERTHAN)
[2]2333 return lhs_int > rhs_int;
2334 return lhs_int < rhs_int;
2335 }
2336 }
2337 if(func_t == T_GREATERTHAN)
2338 return lhs > rhs;
2339 return lhs < rhs; }
2340 case T_IF: {
2341 if(args.count() != 1) {
2342 fprintf(stderr, "%s:%d: if(condition) requires one argument.\n", parser.file.toLatin1().constData(),
2343 parser.line_no);
2344 return false;
2345 }
2346 const QString cond = args.first();
2347 const QChar *d = cond.unicode();
2348 QChar quote = 0;
2349 bool ret = true, or_op = false;
2350 QString test;
2351 for(int d_off = 0, parens = 0, d_len = cond.size(); d_off < d_len; ++d_off) {
2352 if(!quote.isNull()) {
2353 if(*(d+d_off) == quote)
2354 quote = QChar();
2355 } else if(*(d+d_off) == '(') {
2356 ++parens;
2357 } else if(*(d+d_off) == ')') {
2358 --parens;
2359 } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {
2360 quote = *(d+d_off);
2361 }
2362 if(!parens && quote.isNull() && (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('|') || d_off == d_len-1)) {
2363 if(d_off == d_len-1)
2364 test += *(d+d_off);
2365 if(!test.isEmpty()) {
[846]2366 if (or_op != ret)
2367 ret = doProjectTest(test, place);
2368 test.clear();
[2]2369 }
2370 if(*(d+d_off) == QLatin1Char(':')) {
2371 or_op = false;
2372 } else if(*(d+d_off) == QLatin1Char('|')) {
2373 or_op = true;
2374 }
2375 } else {
2376 test += *(d+d_off);
2377 }
2378 }
2379 return ret; }
2380 case T_EQUALS:
2381 if(args.count() != 2) {
2382 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2383 parser.line_no, func.toLatin1().constData());
2384 return false;
2385 }
2386 return values(args[0], place).join(QString(Option::field_sep)) == args[1];
2387 case T_EXISTS: {
2388 if(args.count() != 1) {
2389 fprintf(stderr, "%s:%d: exists(file) requires one argument.\n", parser.file.toLatin1().constData(),
2390 parser.line_no);
2391 return false;
2392 }
2393 QString file = args.first();
2394 file = Option::fixPathToLocalOS(file);
2395
2396 if(QFile::exists(file))
2397 return true;
2398 //regular expression I guess
2399 QString dirstr = qmake_getpwd();
[846]2400 int slsh = file.lastIndexOf(QDir::separator());
[2]2401 if(slsh != -1) {
2402 dirstr = file.left(slsh+1);
2403 file = file.right(file.length() - slsh - 1);
2404 }
2405 return QDir(dirstr).entryList(QStringList(file)).count(); }
2406 case T_EXPORT:
2407 if(args.count() != 1) {
2408 fprintf(stderr, "%s:%d: export(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2409 parser.line_no);
2410 return false;
2411 }
2412 for(int i = 0; i < function_blocks.size(); ++i) {
2413 FunctionBlock *f = function_blocks.at(i);
2414 f->vars[args[0]] = values(args[0], place);
2415 if(!i && f->calling_place)
2416 (*f->calling_place)[args[0]] = values(args[0], place);
2417 }
2418 return true;
2419 case T_CLEAR:
2420 if(args.count() != 1) {
2421 fprintf(stderr, "%s:%d: clear(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2422 parser.line_no);
2423 return false;
2424 }
2425 if(!place.contains(args[0]))
2426 return false;
2427 place[args[0]].clear();
2428 return true;
2429 case T_UNSET:
2430 if(args.count() != 1) {
2431 fprintf(stderr, "%s:%d: unset(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2432 parser.line_no);
2433 return false;
2434 }
2435 if(!place.contains(args[0]))
2436 return false;
2437 place.remove(args[0]);
2438 return true;
2439 case T_EVAL: {
2440 if(args.count() < 1 && 0) {
2441 fprintf(stderr, "%s:%d: eval(project) requires one argument.\n", parser.file.toLatin1().constData(),
2442 parser.line_no);
2443 return false;
2444 }
2445 QString project = args.join(" ");
2446 parser_info pi = parser;
2447 parser.from_file = false;
2448 parser.file = "(eval)";
2449 parser.line_no = 0;
2450 QTextStream t(&project, QIODevice::ReadOnly);
2451 bool ret = read(t, place);
2452 parser = pi;
2453 return ret; }
2454 case T_CONFIG: {
2455 if(args.count() < 1 || args.count() > 2) {
2456 fprintf(stderr, "%s:%d: CONFIG(config) requires one argument.\n", parser.file.toLatin1().constData(),
2457 parser.line_no);
2458 return false;
2459 }
2460 if(args.count() == 1)
2461 return isActiveConfig(args[0]);
2462 const QStringList mutuals = args[1].split('|');
2463 const QStringList &configs = values("CONFIG", place);
2464 for(int i = configs.size()-1; i >= 0; i--) {
2465 for(int mut = 0; mut < mutuals.count(); mut++) {
2466 if(configs[i] == mutuals[mut].trimmed())
2467 return (configs[i] == args[0]);
2468 }
2469 }
2470 return false; }
[846]2471 case T_SYSTEM:
[2]2472 if(args.count() < 1 || args.count() > 2) {
2473 fprintf(stderr, "%s:%d: system(exec) requires one argument.\n", parser.file.toLatin1().constData(),
2474 parser.line_no);
2475 return false;
2476 }
2477 if(args.count() == 2) {
2478 const QString sarg = args[1];
[846]2479 if (sarg.toLower() == "true" || sarg.toInt())
2480 warn_msg(WarnParser, "%s:%d: system()'s second argument is now hard-wired to false.\n",
2481 parser.file.toLatin1().constData(), parser.line_no);
[2]2482 }
[846]2483 return system(args[0].toLatin1().constData()) == 0;
[2]2484 case T_RETURN:
2485 if(function_blocks.isEmpty()) {
2486 fprintf(stderr, "%s:%d unexpected return()\n",
2487 parser.file.toLatin1().constData(), parser.line_no);
2488 } else {
2489 FunctionBlock *f = function_blocks.top();
2490 f->cause_return = true;
2491 if(args_list.count() >= 1)
2492 f->return_value += args_list[0];
2493 }
2494 return true;
2495 case T_BREAK:
2496 if(iterator)
2497 iterator->cause_break = true;
2498 else
2499 fprintf(stderr, "%s:%d unexpected break()\n",
2500 parser.file.toLatin1().constData(), parser.line_no);
2501 return true;
2502 case T_NEXT:
2503 if(iterator)
2504 iterator->cause_next = true;
2505 else
2506 fprintf(stderr, "%s:%d unexpected next()\n",
2507 parser.file.toLatin1().constData(), parser.line_no);
2508 return true;
2509 case T_DEFINED:
2510 if(args.count() < 1 || args.count() > 2) {
2511 fprintf(stderr, "%s:%d: defined(function) requires one argument.\n",
2512 parser.file.toLatin1().constData(), parser.line_no);
2513 } else {
2514 if(args.count() > 1) {
2515 if(args[1] == "test")
2516 return testFunctions.contains(args[0]);
2517 else if(args[1] == "replace")
2518 return replaceFunctions.contains(args[0]);
2519 fprintf(stderr, "%s:%d: defined(function, type): unexpected type [%s].\n",
2520 parser.file.toLatin1().constData(), parser.line_no,
2521 args[1].toLatin1().constData());
2522 } else {
2523 if(replaceFunctions.contains(args[0]) || testFunctions.contains(args[0]))
2524 return true;
2525 }
2526 }
2527 return false;
2528 case T_CONTAINS: {
2529 if(args.count() < 2 || args.count() > 3) {
2530 fprintf(stderr, "%s:%d: contains(var, val) requires at lesat 2 arguments.\n",
2531 parser.file.toLatin1().constData(), parser.line_no);
2532 return false;
2533 }
2534 QRegExp regx(args[1]);
2535 const QStringList &l = values(args[0], place);
2536 if(args.count() == 2) {
2537 for(int i = 0; i < l.size(); ++i) {
2538 const QString val = l[i];
2539 if(regx.exactMatch(val) || val == args[1])
2540 return true;
2541 }
2542 } else {
2543 const QStringList mutuals = args[2].split('|');
2544 for(int i = l.size()-1; i >= 0; i--) {
2545 const QString val = l[i];
2546 for(int mut = 0; mut < mutuals.count(); mut++) {
2547 if(val == mutuals[mut].trimmed())
2548 return (regx.exactMatch(val) || val == args[1]);
2549 }
2550 }
2551 }
2552 return false; }
2553 case T_INFILE: {
2554 if(args.count() < 2 || args.count() > 3) {
2555 fprintf(stderr, "%s:%d: infile(file, var, val) requires at least 2 arguments.\n",
2556 parser.file.toLatin1().constData(), parser.line_no);
2557 return false;
2558 }
2559
2560 bool ret = false;
2561 QMap<QString, QStringList> tmp;
2562 if(doProjectInclude(Option::fixPathToLocalOS(args[0]), IncludeFlagNewParser, tmp) == IncludeSuccess) {
2563 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
2564 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
2565 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
2566 for(int i = 0; i < in.size(); ++i) {
2567 if(out.indexOf(in[i]) == -1)
2568 out += in[i];
2569 }
2570 }
2571 if(args.count() == 2) {
2572 ret = tmp.contains(args[1]);
2573 } else {
2574 QRegExp regx(args[2]);
2575 const QStringList &l = tmp[args[1]];
2576 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2577 if(regx.exactMatch((*it)) || (*it) == args[2]) {
2578 ret = true;
2579 break;
2580 }
2581 }
2582 }
2583 }
2584 return ret; }
2585 case T_COUNT:
2586 if(args.count() != 2 && args.count() != 3) {
2587 fprintf(stderr, "%s:%d: count(var, count) requires two arguments.\n", parser.file.toLatin1().constData(),
2588 parser.line_no);
2589 return false;
2590 }
2591 if(args.count() == 3) {
2592 QString comp = args[2];
2593 if(comp == ">" || comp == "greaterThan")
2594 return values(args[0], place).count() > args[1].toInt();
2595 if(comp == ">=")
2596 return values(args[0], place).count() >= args[1].toInt();
2597 if(comp == "<" || comp == "lessThan")
2598 return values(args[0], place).count() < args[1].toInt();
2599 if(comp == "<=")
2600 return values(args[0], place).count() <= args[1].toInt();
2601 if(comp == "equals" || comp == "isEqual" || comp == "=" || comp == "==")
2602 return values(args[0], place).count() == args[1].toInt();
2603 fprintf(stderr, "%s:%d: unexpected modifier to count(%s)\n", parser.file.toLatin1().constData(),
2604 parser.line_no, comp.toLatin1().constData());
2605 return false;
2606 }
2607 return values(args[0], place).count() == args[1].toInt();
2608 case T_ISEMPTY:
2609 if(args.count() != 1) {
2610 fprintf(stderr, "%s:%d: isEmpty(var) requires one argument.\n", parser.file.toLatin1().constData(),
2611 parser.line_no);
2612 return false;
2613 }
2614 return values(args[0], place).isEmpty();
2615 case T_INCLUDE:
2616 case T_LOAD: {
2617 QString parseInto;
2618 const bool include_statement = (func_t == T_INCLUDE);
[561]2619 bool ignore_error = false;
2620 if(args.count() >= 2) {
[2]2621 if(func_t == T_INCLUDE) {
2622 parseInto = args[1];
[561]2623 if (args.count() == 3){
2624 QString sarg = args[2];
2625 if (sarg.toLower() == "true" || sarg.toInt())
2626 ignore_error = true;
2627 }
[2]2628 } else {
2629 QString sarg = args[1];
2630 ignore_error = (sarg.toLower() == "true" || sarg.toInt());
2631 }
2632 } else if(args.count() != 1) {
2633 QString func_desc = "load(feature)";
2634 if(include_statement)
2635 func_desc = "include(file)";
2636 fprintf(stderr, "%s:%d: %s requires one argument.\n", parser.file.toLatin1().constData(),
2637 parser.line_no, func_desc.toLatin1().constData());
2638 return false;
2639 }
2640 QString file = args.first();
2641 file = Option::fixPathToLocalOS(file);
2642 uchar flags = IncludeFlagNone;
2643 if(!include_statement)
2644 flags |= IncludeFlagFeature;
2645 IncludeStatus stat = IncludeFailure;
2646 if(!parseInto.isEmpty()) {
2647 QMap<QString, QStringList> symbols;
2648 stat = doProjectInclude(file, flags|IncludeFlagNewProject, symbols);
2649 if(stat == IncludeSuccess) {
2650 QMap<QString, QStringList> out_place;
2651 for(QMap<QString, QStringList>::ConstIterator it = place.begin(); it != place.end(); ++it) {
2652 const QString var = it.key();
2653 if(var != parseInto && !var.startsWith(parseInto + "."))
2654 out_place.insert(var, it.value());
2655 }
2656 for(QMap<QString, QStringList>::ConstIterator it = symbols.begin(); it != symbols.end(); ++it) {
2657 const QString var = it.key();
2658 if(!var.startsWith("."))
2659 out_place.insert(parseInto + "." + it.key(), it.value());
2660 }
2661 place = out_place;
2662 }
2663 } else {
2664 stat = doProjectInclude(file, flags, place);
2665 }
2666 if(stat == IncludeFeatureAlreadyLoaded) {
2667 warn_msg(WarnParser, "%s:%d: Duplicate of loaded feature %s",
2668 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
[561]2669 } else if(stat == IncludeNoExist && !ignore_error) {
2670 warn_msg(WarnAll, "%s:%d: Unable to find file for inclusion %s",
[2]2671 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
2672 return false;
2673 } else if(stat >= IncludeFailure) {
2674 if(!ignore_error) {
2675 printf("Project LOAD(): Feature %s cannot be found.\n", file.toLatin1().constData());
2676 if (!ignore_error)
2677#if defined(QT_BUILD_QMAKE_LIBRARY)
2678 return false;
2679#else
2680 exit(3);
2681#endif
2682 }
2683 return false;
2684 }
2685 return true; }
2686 case T_DEBUG: {
2687 if(args.count() != 2) {
2688 fprintf(stderr, "%s:%d: debug(level, message) requires one argument.\n", parser.file.toLatin1().constData(),
2689 parser.line_no);
2690 return false;
2691 }
2692 QString msg = fixEnvVariables(args[1]);
2693 debug_msg(args[0].toInt(), "Project DEBUG: %s", msg.toLatin1().constData());
2694 return true; }
2695 case T_ERROR:
2696 case T_MESSAGE:
2697 case T_WARNING: {
2698 if(args.count() != 1) {
2699 fprintf(stderr, "%s:%d: %s(message) requires one argument.\n", parser.file.toLatin1().constData(),
2700 parser.line_no, func.toLatin1().constData());
2701 return false;
2702 }
2703 QString msg = fixEnvVariables(args.first());
2704 fprintf(stderr, "Project %s: %s\n", func.toUpper().toLatin1().constData(), msg.toLatin1().constData());
2705 if(func == "error")
2706#if defined(QT_BUILD_QMAKE_LIBRARY)
2707 return false;
2708#else
2709 exit(2);
2710#endif
2711 return true; }
[846]2712 case T_OPTION:
2713 if (args.count() != 1) {
2714 fprintf(stderr, "%s:%d: option() requires one argument.\n",
2715 parser.file.toLatin1().constData(), parser.line_no);
2716 return false;
2717 }
2718 if (args.first() == "recursive") {
2719 recursive = true;
2720 } else {
2721 fprintf(stderr, "%s:%d: unrecognized option() argument '%s'.\n",
2722 parser.file.toLatin1().constData(), parser.line_no,
2723 args.first().toLatin1().constData());
2724 return false;
2725 }
2726 return true;
[2]2727 default:
2728 fprintf(stderr, "%s:%d: Unknown test function: %s\n", parser.file.toLatin1().constData(), parser.line_no,
2729 func.toLatin1().constData());
2730 }
2731 return false;
2732}
2733
2734bool
2735QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringList> &place)
2736{
2737 bool ret = false;
2738 for(QStringList::ConstIterator it = deps.begin(); it != deps.end(); ++it) {
2739 bool test = doProjectTest((*it), place);
2740 if(!test) {
2741 debug_msg(1, "Project Parser: %s:%d Failed test: REQUIRES = %s",
2742 parser.file.toLatin1().constData(), parser.line_no,
2743 (*it).toLatin1().constData());
2744 place["QMAKE_FAILED_REQUIREMENTS"].append((*it));
2745 ret = false;
2746 }
2747 }
2748 return ret;
2749}
2750
2751bool
2752QMakeProject::test(const QString &v)
2753{
2754 QMap<QString, QStringList> tmp = vars;
2755 return doProjectTest(v, tmp);
2756}
2757
2758bool
2759QMakeProject::test(const QString &func, const QList<QStringList> &args)
2760{
2761 QMap<QString, QStringList> tmp = vars;
2762 return doProjectTest(func, args, tmp);
2763}
2764
2765QStringList
2766QMakeProject::expand(const QString &str)
2767{
2768 bool ok;
2769 QMap<QString, QStringList> tmp = vars;
2770 const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
2771 if(ok)
2772 return ret;
2773 return QStringList();
2774}
2775
2776QStringList
2777QMakeProject::expand(const QString &func, const QList<QStringList> &args)
2778{
2779 QMap<QString, QStringList> tmp = vars;
2780 return doProjectExpand(func, args, tmp);
2781}
2782
2783bool
2784QMakeProject::doVariableReplace(QString &str, QMap<QString, QStringList> &place)
2785{
2786 bool ret;
2787 str = doVariableReplaceExpand(str, place, &ret).join(QString(Option::field_sep));
2788 return ret;
2789}
2790
2791QStringList
2792QMakeProject::doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok)
2793{
2794 QStringList ret;
2795 if(ok)
2796 *ok = true;
2797 if(str.isEmpty())
2798 return ret;
2799
2800 const ushort LSQUARE = '[';
2801 const ushort RSQUARE = ']';
2802 const ushort LCURLY = '{';
2803 const ushort RCURLY = '}';
2804 const ushort LPAREN = '(';
2805 const ushort RPAREN = ')';
2806 const ushort DOLLAR = '$';
2807 const ushort SLASH = '\\';
2808 const ushort UNDERSCORE = '_';
2809 const ushort DOT = '.';
2810 const ushort SPACE = ' ';
2811 const ushort TAB = '\t';
2812 const ushort SINGLEQUOTE = '\'';
2813 const ushort DOUBLEQUOTE = '"';
2814
2815 ushort unicode, quote = 0;
2816 const QChar *str_data = str.data();
2817 const int str_len = str.length();
2818
2819 ushort term;
2820 QString var, args;
2821
2822 int replaced = 0;
2823 QString current;
2824 for(int i = 0; i < str_len; ++i) {
2825 unicode = str_data[i].unicode();
2826 const int start_var = i;
2827 if(unicode == DOLLAR && str_len > i+2) {
2828 unicode = str_data[++i].unicode();
2829 if(unicode == DOLLAR) {
2830 term = 0;
2831 var.clear();
2832 args.clear();
2833 enum { VAR, ENVIRON, FUNCTION, PROPERTY } var_type = VAR;
2834 unicode = str_data[++i].unicode();
2835 if(unicode == LSQUARE) {
2836 unicode = str_data[++i].unicode();
2837 term = RSQUARE;
2838 var_type = PROPERTY;
2839 } else if(unicode == LCURLY) {
2840 unicode = str_data[++i].unicode();
2841 var_type = VAR;
2842 term = RCURLY;
2843 } else if(unicode == LPAREN) {
2844 unicode = str_data[++i].unicode();
2845 var_type = ENVIRON;
2846 term = RPAREN;
2847 }
2848 while(1) {
2849 if(!(unicode & (0xFF<<8)) &&
2850 unicode != DOT && unicode != UNDERSCORE &&
2851 //unicode != SINGLEQUOTE && unicode != DOUBLEQUOTE &&
2852 (unicode < 'a' || unicode > 'z') && (unicode < 'A' || unicode > 'Z') &&
2853 (unicode < '0' || unicode > '9'))
2854 break;
2855 var.append(QChar(unicode));
2856 if(++i == str_len)
2857 break;
2858 unicode = str_data[i].unicode();
2859 // at this point, i points to either the 'term' or 'next' character (which is in unicode)
2860 }
2861 if(var_type == VAR && unicode == LPAREN) {
2862 var_type = FUNCTION;
2863 int depth = 0;
2864 while(1) {
2865 if(++i == str_len)
2866 break;
2867 unicode = str_data[i].unicode();
2868 if(unicode == LPAREN) {
2869 depth++;
2870 } else if(unicode == RPAREN) {
2871 if(!depth)
2872 break;
2873 --depth;
2874 }
2875 args.append(QChar(unicode));
2876 }
2877 if(++i < str_len)
2878 unicode = str_data[i].unicode();
2879 else
2880 unicode = 0;
2881 // at this point i is pointing to the 'next' character (which is in unicode)
2882 // this might actually be a term character since you can do $${func()}
2883 }
2884 if(term) {
2885 if(unicode != term) {
2886 qmake_error_msg("Missing " + QString(term) + " terminator [found " + (unicode?QString(unicode):QString("end-of-line")) + "]");
2887 if(ok)
2888 *ok = false;
2889 return QStringList();
2890 }
2891 } else {
2892 // move the 'cursor' back to the last char of the thing we were looking at
2893 --i;
2894 }
2895 // since i never points to the 'next' character, there is no reason for this to be set
2896 unicode = 0;
2897
2898 QStringList replacement;
2899 if(var_type == ENVIRON) {
2900 replacement = split_value_list(QString::fromLocal8Bit(qgetenv(var.toLatin1().constData())));
2901 } else if(var_type == PROPERTY) {
2902 if(prop)
2903 replacement = split_value_list(prop->value(var));
2904 } else if(var_type == FUNCTION) {
2905 replacement = doProjectExpand(var, args, place);
2906 } else if(var_type == VAR) {
2907 replacement = values(var, place);
2908 }
2909 if(!(replaced++) && start_var)
2910 current = str.left(start_var);
2911 if(!replacement.isEmpty()) {
2912 if(quote) {
2913 current += replacement.join(QString(Option::field_sep));
2914 } else {
2915 current += replacement.takeFirst();
2916 if(!replacement.isEmpty()) {
2917 if(!current.isEmpty())
2918 ret.append(current);
2919 current = replacement.takeLast();
2920 if(!replacement.isEmpty())
2921 ret += replacement;
2922 }
2923 }
2924 }
2925 debug_msg(2, "Project Parser [var replace]: %s -> %s",
2926 str.toLatin1().constData(), var.toLatin1().constData(),
2927 replacement.join("::").toLatin1().constData());
2928 } else {
2929 if(replaced)
2930 current.append("$");
2931 }
2932 }
2933 if(quote && unicode == quote) {
2934 unicode = 0;
2935 quote = 0;
2936 } else if(unicode == SLASH) {
2937 bool escape = false;
2938 const char *symbols = "[]{}()$\\'\"";
2939 for(const char *s = symbols; *s; ++s) {
2940 if(str_data[i+1].unicode() == (ushort)*s) {
2941 i++;
2942 escape = true;
2943 if(!(replaced++))
2944 current = str.left(start_var);
2945 current.append(str.at(i));
2946 break;
2947 }
2948 }
[846]2949 if(!escape && !backslashWarned) {
2950 backslashWarned = true;
2951 warn_msg(WarnDeprecated, "%s:%d: Unescaped backslashes are deprecated.",
2952 parser.file.toLatin1().constData(), parser.line_no);
2953 }
[2]2954 if(escape || !replaced)
2955 unicode =0;
2956 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
2957 quote = unicode;
2958 unicode = 0;
2959 if(!(replaced++) && i)
2960 current = str.left(i);
2961 } else if(!quote && (unicode == SPACE || unicode == TAB)) {
2962 unicode = 0;
2963 if(!current.isEmpty()) {
2964 ret.append(current);
2965 current.clear();
2966 }
2967 }
2968 if(replaced && unicode)
2969 current.append(QChar(unicode));
2970 }
2971 if(!replaced)
2972 ret = QStringList(str);
2973 else if(!current.isEmpty())
2974 ret.append(current);
2975 //qDebug() << "REPLACE" << str << ret;
2976 return ret;
2977}
2978
2979QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList> &place)
2980{
2981 QString var = varMap(_var);
2982 if(var == QLatin1String("LITERAL_WHITESPACE")) { //a real space in a token)
2983 var = ".BUILTIN." + var;
2984 place[var] = QStringList(QLatin1String("\t"));
2985 } else if(var == QLatin1String("LITERAL_DOLLAR")) { //a real $
2986 var = ".BUILTIN." + var;
2987 place[var] = QStringList(QLatin1String("$"));
2988 } else if(var == QLatin1String("LITERAL_HASH")) { //a real #
2989 var = ".BUILTIN." + var;
2990 place[var] = QStringList("#");
2991 } else if(var == QLatin1String("OUT_PWD")) { //the out going dir
2992 var = ".BUILTIN." + var;
2993 place[var] = QStringList(Option::output_dir);
2994 } else if(var == QLatin1String("PWD") || //current working dir (of _FILE_)
2995 var == QLatin1String("IN_PWD")) {
2996 var = ".BUILTIN." + var;
2997 place[var] = QStringList(qmake_getpwd());
2998 } else if(var == QLatin1String("DIR_SEPARATOR")) {
2999 var = ".BUILTIN." + var;
3000 place[var] = QStringList(Option::dir_sep);
3001 } else if(var == QLatin1String("DIRLIST_SEPARATOR")) {
3002 var = ".BUILTIN." + var;
3003 place[var] = QStringList(Option::dirlist_sep);
3004 } else if(var == QLatin1String("_LINE_")) { //parser line number
3005 var = ".BUILTIN." + var;
3006 place[var] = QStringList(QString::number(parser.line_no));
3007 } else if(var == QLatin1String("_FILE_")) { //parser file
3008 var = ".BUILTIN." + var;
3009 place[var] = QStringList(parser.file);
3010 } else if(var == QLatin1String("_DATE_")) { //current date/time
3011 var = ".BUILTIN." + var;
3012 place[var] = QStringList(QDateTime::currentDateTime().toString());
3013 } else if(var == QLatin1String("_PRO_FILE_")) {
3014 var = ".BUILTIN." + var;
3015 place[var] = QStringList(pfile);
3016 } else if(var == QLatin1String("_PRO_FILE_PWD_")) {
3017 var = ".BUILTIN." + var;
[769]3018 place[var] = QStringList(pfile.isEmpty() ? qmake_getpwd() : QFileInfo(pfile).absolutePath());
[2]3019 } else if(var == QLatin1String("_QMAKE_CACHE_")) {
3020 var = ".BUILTIN." + var;
3021 if(Option::mkfile::do_cache)
3022 place[var] = QStringList(Option::mkfile::cachefile);
3023 } else if(var == QLatin1String("TEMPLATE")) {
3024 if(!Option::user_template.isEmpty()) {
3025 var = ".BUILTIN.USER." + var;
3026 place[var] = QStringList(Option::user_template);
3027 } else if(!place[var].isEmpty()) {
3028 QString orig_template = place["TEMPLATE"].first(), real_template;
3029 if(!Option::user_template_prefix.isEmpty() && !orig_template.startsWith(Option::user_template_prefix))
3030 real_template = Option::user_template_prefix + orig_template;
3031 if(!real_template.isEmpty()) {
3032 var = ".BUILTIN." + var;
3033 place[var] = QStringList(real_template);
3034 }
3035 } else {
3036 var = ".BUILTIN." + var;
3037 place[var] = QStringList("app");
3038 }
3039 } else if(var.startsWith(QLatin1String("QMAKE_HOST."))) {
3040 QString ret, type = var.mid(11);
3041#if defined(Q_OS_WIN32)
3042 if(type == "os") {
3043 ret = "Windows";
3044 } else if(type == "name") {
3045 DWORD name_length = 1024;
[561]3046 wchar_t name[1024];
3047 if (GetComputerName(name, &name_length))
3048 ret = QString::fromWCharArray(name);
[2]3049 } else if(type == "version" || type == "version_string") {
3050 QSysInfo::WinVersion ver = QSysInfo::WindowsVersion;
3051 if(type == "version")
3052 ret = QString::number(ver);
3053 else if(ver == QSysInfo::WV_Me)
3054 ret = "WinMe";
3055 else if(ver == QSysInfo::WV_95)
3056 ret = "Win95";
3057 else if(ver == QSysInfo::WV_98)
3058 ret = "Win98";
3059 else if(ver == QSysInfo::WV_NT)
3060 ret = "WinNT";
3061 else if(ver == QSysInfo::WV_2000)
3062 ret = "Win2000";
3063 else if(ver == QSysInfo::WV_2000)
3064 ret = "Win2003";
3065 else if(ver == QSysInfo::WV_XP)
3066 ret = "WinXP";
3067 else if(ver == QSysInfo::WV_VISTA)
3068 ret = "WinVista";
3069 else
3070 ret = "Unknown";
3071 } else if(type == "arch") {
3072 SYSTEM_INFO info;
3073 GetSystemInfo(&info);
3074 switch(info.wProcessorArchitecture) {
3075#ifdef PROCESSOR_ARCHITECTURE_AMD64
3076 case PROCESSOR_ARCHITECTURE_AMD64:
3077 ret = "x86_64";
3078 break;
3079#endif
3080 case PROCESSOR_ARCHITECTURE_INTEL:
3081 ret = "x86";
3082 break;
3083 case PROCESSOR_ARCHITECTURE_IA64:
3084#ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
3085 case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
3086#endif
3087 ret = "IA64";
3088 break;
3089 default:
3090 ret = "Unknown";
3091 break;
3092 }
3093 }
[29]3094#elif defined(Q_OS_OS2)
3095 if(type == "os") {
3096 ret = "OS2";
3097 } else if(type == "name") {
3098 ret = QString::fromLocal8Bit(qgetenv("HOSTNAME"));
3099 } else if(type == "version" || type == "version_string") {
3100 ULONG buf [3];
3101 DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_REVISION,
3102 &buf, sizeof(buf));
3103 if(type == "version")
[388]3104 ret = QString().sprintf("%lu.%lu.%lu", buf[0], buf[1], buf[2]);
[29]3105 else {
3106 /* Warp 3 is reported as 20.30 */
3107 /* Warp 4 is reported as 20.40 */
3108 /* Aurora and eCS are reported as 20.45 */
3109 if (buf[0] == 20 && buf[1] == 30)
3110 ret = "Warp3";
3111 else if (buf[0] == 20 && buf[1] == 40)
3112 ret = "Warp4";
3113 else if (buf[0] == 20 && buf[1] == 45) {
3114 if (QString::fromLocal8Bit(qgetenv("OS")) == "ecs")
3115 ret = "eComStation";
3116 else
3117 ret = "Aurora";
3118 }
3119 else
3120 ret = "Unknown";
3121 }
3122 } else if(type == "arch") {
3123 ret = "x86";
3124 }
[2]3125#elif defined(Q_OS_UNIX)
3126 struct utsname name;
3127 if(!uname(&name)) {
3128 if(type == "os")
3129 ret = name.sysname;
3130 else if(type == "name")
3131 ret = name.nodename;
3132 else if(type == "version")
3133 ret = name.release;
3134 else if(type == "version_string")
3135 ret = name.version;
3136 else if(type == "arch")
3137 ret = name.machine;
3138 }
3139#endif
3140 var = ".BUILTIN.HOST." + type;
3141 place[var] = QStringList(ret);
3142 } else if (var == QLatin1String("QMAKE_DIR_SEP")) {
3143 if (place[var].isEmpty())
3144 return values("DIR_SEPARATOR", place);
[846]3145 } else if (var == QLatin1String("QMAKE_EXT_OBJ")) {
3146 if (place[var].isEmpty()) {
3147 var = ".BUILTIN." + var;
3148 place[var] = QStringList(Option::obj_ext);
3149 }
3150 } else if (var == QLatin1String("QMAKE_QMAKE")) {
3151 if (place[var].isEmpty())
3152 place[var] = QStringList(Option::fixPathToTargetOS(
3153 !Option::qmake_abslocation.isEmpty()
3154 ? Option::qmake_abslocation
3155 : QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmake",
3156 false));
[561]3157 } else if (var == QLatin1String("EPOCROOT")) {
3158 if (place[var].isEmpty())
[846]3159 place[var] = QStringList(qt_epocRoot());
[2]3160 }
[846]3161#if defined(Q_OS_WIN32) && defined(Q_CC_MSVC)
3162 else if(var.startsWith(QLatin1String("QMAKE_TARGET."))) {
3163 QString ret, type = var.mid(13);
3164 if(type == "arch") {
3165 QString paths = qgetenv("PATH");
3166 QString vcBin64 = qgetenv("VCINSTALLDIR").append("\\bin\\amd64");
3167 QString vcBinX86_64 = qgetenv("VCINSTALLDIR").append("\\bin\\x86_amd64");
3168 if(paths.contains(vcBin64,Qt::CaseInsensitive) || paths.contains(vcBinX86_64,Qt::CaseInsensitive))
3169 ret = "x86_64";
3170 else
3171 ret = "x86";
3172 }
3173 place[var] = QStringList(ret);
3174 }
3175#endif
[2]3176 //qDebug("REPLACE [%s]->[%s]", qPrintable(var), qPrintable(place[var].join("::")));
3177 return place[var];
3178}
3179
[846]3180bool QMakeProject::isEmpty(const QString &v)
3181{
3182 QMap<QString, QStringList>::ConstIterator it = vars.constFind(varMap(v));
3183 return it == vars.constEnd() || it->isEmpty();
3184}
3185
[2]3186QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.