source: trunk/qmake/project.cpp@ 966

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

qmake: Fixed the OS/2 build and the GNUMAKE generator.
File size: 122.9 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation (qt-info@nokia.com)
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**
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.
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**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "project.h"
43#include "property.h"
44#include "option.h"
45#include "cachekeys.h"
46#include "generators/metamakefile.h"
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)
61#include <windows.h>
62#elif defined(Q_OS_OS2)
63#include <qt_os2.h>
64#endif
65#include <stdio.h>
66#include <stdlib.h>
67
68// Included from tools/shared
69#include <symbian/epocroot_p.h>
70
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
81//expand functions
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,
85 E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,
86 E_SIZE, E_GENERATE_UID };
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);
117 qmake_expand_functions->insert("size", E_SIZE);
118 qmake_expand_functions->insert("generate_uid", E_GENERATE_UID);
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,
127 T_MESSAGE, T_WARNING, T_IF, T_OPTION };
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);
161 qmake_test_functions->insert("option", T_OPTION);
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);
191 if(ret == "INTERFACES")
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";
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());
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
288static QStringList split_value_list(const QString &vals)
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
318 if(!parens && quote.isEmpty() && (vals_data[x] == Option::field_sep)) {
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;
542 default: // Can't happen, just make the compiler shut up
543 case Option::TARG_UNIX_MODE:
544 concat << base_concat + QDir::separator() + "unix";
545 break;
546 case Option::TARG_WIN_MODE:
547 concat << base_concat + QDir::separator() + "win32";
548 break;
549 case Option::TARG_SYMBIAN_MODE:
550 concat << base_concat + QDir::separator() + "symbian";
551 break;
552 case Option::TARG_OS2_MODE:
553 concat << base_concat + QDir::separator() + "os2";
554 break;
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;
567 int last_slash = Option::mkfile::cachefile.lastIndexOf(QDir::separator());
568 if(last_slash != -1)
569 path = Option::fixPathToLocalOS(Option::mkfile::cachefile.left(last_slash), false);
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 }
654 recursive = false;
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;
679 backslashWarned = false;
680}
681
682bool
683QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int numLines)
684{
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
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('{');
1071 if(scope_blocks.count() > 1 && rbraces - lbraces == 1 && vals.endsWith('}')) {
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);
1087 var = varMap(var); //backwards compatibility
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)
1098 warn_msg(WarnParser, "Possible accidental line continuation: {%s} at %s:%d",
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);
1151 QStringList tmp = split_value_list(vals);
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();
1241 QString filename = Option::fixPathToLocalOS(file, false);
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();
1347 } else if (QFile::exists(Option::output_dir+"/"+qmakespec+"/qmake.conf")) {
1348 qmakespec = Option::mkfile::qmakespec = QFileInfo(Option::output_dir+"/"+qmakespec).absoluteFilePath();
1349 } else {
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;
1357 }
1358 }
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 }
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 }
1376 validateModes();
1377
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());
1424 if(pfile != "-" && !QFile::exists(pfile) && !pfile.endsWith(Option::pro_ext))
1425 pfile += Option::pro_ext;
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
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 if (os == "os2")
1520 Option::target_mode = Option::TARG_OS2_MODE;
1521 else
1522 fprintf(stderr, "Unknown target platform specified: %s\n",
1523 os.toLatin1().constData());
1524 } else {
1525 Option::target_mode = target_mode;
1526 }
1527 }
1528 }
1529 }
1530}
1531
1532bool
1533QMakeProject::isActiveConfig(const QString &x, bool regex, QMap<QString, QStringList> *place)
1534{
1535 if(x.isEmpty())
1536 return true;
1537
1538 //magic types for easy flipping
1539 if(x == "true")
1540 return true;
1541 else if(x == "false")
1542 return false;
1543
1544 if (x == "unix") {
1545 validateModes();
1546 return Option::target_mode == Option::TARG_UNIX_MODE
1547 || Option::target_mode == Option::TARG_MACX_MODE
1548 || Option::target_mode == Option::TARG_SYMBIAN_MODE;
1549 } else if (x == "macx" || x == "mac") {
1550 validateModes();
1551 return Option::target_mode == Option::TARG_MACX_MODE;
1552 } else if (x == "symbian") {
1553 validateModes();
1554 return Option::target_mode == Option::TARG_SYMBIAN_MODE;
1555 } else if (x == "win32") {
1556 validateModes();
1557 return Option::target_mode == Option::TARG_WIN_MODE;
1558 }
1559
1560 //mkspecs
1561 static QString spec;
1562 if(spec.isEmpty())
1563 spec = QFileInfo(Option::mkfile::qmakespec).fileName();
1564 else if(Option::target_mode == Option::TARG_OS2_MODE && x == "os2")
1565 return true;
1566 QRegExp re(x, Qt::CaseSensitive, QRegExp::Wildcard);
1567 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1568 return true;
1569#ifdef Q_OS_UNIX
1570 else if(spec == "default") {
1571 static char *buffer = NULL;
1572 if(!buffer) {
1573 buffer = (char *)malloc(1024);
1574 qmakeAddCacheClear(qmakeFreeCacheClear, (void**)&buffer);
1575 }
1576 int l = readlink(Option::mkfile::qmakespec.toLatin1(), buffer, 1024);
1577 if(l != -1) {
1578 buffer[l] = '\0';
1579 QString r = buffer;
1580 if(r.lastIndexOf('/') != -1)
1581 r = r.mid(r.lastIndexOf('/') + 1);
1582 if((regex && re.exactMatch(r)) || (!regex && r == x))
1583 return true;
1584 }
1585 }
1586#elif defined(Q_OS_WIN) || defined(Q_OS_OS2)
1587 else if(spec == "default") {
1588 // We can't resolve symlinks as they do on Unix, so configure.exe puts the source of the
1589 // qmake.conf at the end of the default/qmake.conf in the QMAKESPEC_ORG variable.
1590 const QStringList &spec_org = (place ? (*place)["QMAKESPEC_ORIGINAL"]
1591 : vars["QMAKESPEC_ORIGINAL"]);
1592 if (!spec_org.isEmpty()) {
1593 spec = QFileInfo(spec_org.at(0)).fileName();
1594 if((regex && re.exactMatch(spec)) || (!regex && spec == x))
1595 return true;
1596 }
1597 }
1598#endif
1599
1600 //simple matching
1601 const QStringList &configs = (place ? (*place)["CONFIG"] : vars["CONFIG"]);
1602 for(QStringList::ConstIterator it = configs.begin(); it != configs.end(); ++it) {
1603 if(((regex && re.exactMatch((*it))) || (!regex && (*it) == x)) && re.exactMatch((*it)))
1604 return true;
1605 }
1606 return false;
1607}
1608
1609bool
1610QMakeProject::doProjectTest(QString str, QMap<QString, QStringList> &place)
1611{
1612 QString chk = remove_quotes(str);
1613 if(chk.isEmpty())
1614 return true;
1615 bool invert_test = (chk.left(1) == "!");
1616 if(invert_test)
1617 chk = chk.mid(1);
1618
1619 bool test=false;
1620 int lparen = chk.indexOf('(');
1621 if(lparen != -1) { // if there is an lparen in the chk, it IS a function
1622 int rparen = chk.indexOf(')', lparen);
1623 if(rparen == -1) {
1624 qmake_error_msg("Function missing right paren: " + chk);
1625 } else {
1626 QString func = chk.left(lparen);
1627 test = doProjectTest(func, chk.mid(lparen+1, rparen - lparen - 1), place);
1628 }
1629 } else {
1630 test = isActiveConfig(chk, true, &place);
1631 }
1632 if(invert_test)
1633 return !test;
1634 return test;
1635}
1636
1637bool
1638QMakeProject::doProjectTest(QString func, const QString &params,
1639 QMap<QString, QStringList> &place)
1640{
1641 return doProjectTest(func, split_arg_list(params), place);
1642}
1643
1644QMakeProject::IncludeStatus
1645QMakeProject::doProjectInclude(QString file, uchar flags, QMap<QString, QStringList> &place)
1646{
1647 enum { UnknownFormat, ProFormat, JSFormat } format = UnknownFormat;
1648 if(flags & IncludeFlagFeature) {
1649 if(!file.endsWith(Option::prf_ext))
1650 file += Option::prf_ext;
1651 if(file.indexOf(Option::dir_sep) == -1 || !QFile::exists(file)) {
1652 static QStringList *feature_roots = 0;
1653 if(!feature_roots) {
1654 validateModes();
1655 feature_roots = new QStringList(qmake_feature_paths(prop));
1656 qmakeAddCacheClear(qmakeDeleteCacheClear_QStringList, (void**)&feature_roots);
1657 }
1658 debug_msg(2, "Looking for feature '%s' in (%s)", file.toLatin1().constData(),
1659 feature_roots->join("::").toLatin1().constData());
1660 int start_root = 0;
1661 if(parser.from_file) {
1662 QFileInfo currFile(parser.file), prfFile(file);
1663 if(currFile.fileName() == prfFile.fileName()) {
1664 currFile = QFileInfo(currFile.canonicalFilePath());
1665 for(int root = 0; root < feature_roots->size(); ++root) {
1666 prfFile = QFileInfo(feature_roots->at(root) +
1667 QDir::separator() + file).canonicalFilePath();
1668 if(prfFile == currFile) {
1669 start_root = root+1;
1670 break;
1671 }
1672 }
1673 }
1674 }
1675 for(int root = start_root; root < feature_roots->size(); ++root) {
1676 QString prf(feature_roots->at(root) + QDir::separator() + file);
1677 if(QFile::exists(prf + Option::js_ext)) {
1678 format = JSFormat;
1679 file = prf + Option::js_ext;
1680 break;
1681 } else if(QFile::exists(prf)) {
1682 format = ProFormat;
1683 file = prf;
1684 break;
1685 }
1686 }
1687 if(format == UnknownFormat)
1688 return IncludeNoExist;
1689 if(place["QMAKE_INTERNAL_INCLUDED_FEATURES"].indexOf(file) != -1)
1690 return IncludeFeatureAlreadyLoaded;
1691 place["QMAKE_INTERNAL_INCLUDED_FEATURES"].append(file);
1692 }
1693 }
1694 if(QDir::isRelativePath(file)) {
1695 QStringList include_roots;
1696 if(Option::output_dir != qmake_getpwd())
1697 include_roots << qmake_getpwd();
1698 include_roots << Option::output_dir;
1699 for(int root = 0; root < include_roots.size(); ++root) {
1700 QString testName = QDir::toNativeSeparators(include_roots[root]);
1701 if (!testName.endsWith(QString(QDir::separator())))
1702 testName += QDir::separator();
1703 testName += file;
1704 if(QFile::exists(testName)) {
1705 file = testName;
1706 break;
1707 }
1708 }
1709 }
1710 if(format == UnknownFormat) {
1711 if(QFile::exists(file)) {
1712 if(file.endsWith(Option::js_ext))
1713 format = JSFormat;
1714 else
1715 format = ProFormat;
1716 } else {
1717 return IncludeNoExist;
1718 }
1719 }
1720 if(Option::mkfile::do_preprocess) //nice to see this first..
1721 fprintf(stderr, "#switching file %s(%s) - %s:%d\n", (flags & IncludeFlagFeature) ? "load" : "include",
1722 file.toLatin1().constData(),
1723 parser.file.toLatin1().constData(), parser.line_no);
1724 debug_msg(1, "Project Parser: %s'ing file %s.", (flags & IncludeFlagFeature) ? "load" : "include",
1725 file.toLatin1().constData());
1726
1727 QString orig_file = file;
1728 int di = file.lastIndexOf(QDir::separator());
1729 QString oldpwd = qmake_getpwd();
1730 if(di != -1) {
1731 if(!qmake_setpwd(file.left(file.lastIndexOf(QDir::separator())))) {
1732 fprintf(stderr, "Cannot find directory: %s\n", file.left(di).toLatin1().constData());
1733 return IncludeFailure;
1734 }
1735 }
1736 bool parsed = false;
1737 parser_info pi = parser;
1738 if(format == JSFormat) {
1739 warn_msg(WarnParser, "%s:%d: QtScript support disabled for %s.",
1740 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1741 } else {
1742 QStack<ScopeBlock> sc = scope_blocks;
1743 IteratorBlock *it = iterator;
1744 FunctionBlock *fu = function;
1745 if(flags & (IncludeFlagNewProject|IncludeFlagNewParser)) {
1746 // The "project's variables" are used in other places (eg. export()) so it's not
1747 // possible to use "place" everywhere. Instead just set variables and grab them later
1748 QMakeProject proj(this, &place);
1749 if(flags & IncludeFlagNewParser) {
1750#if 1
1751 if(proj.doProjectInclude("default_pre", IncludeFlagFeature, proj.variables()) == IncludeNoExist)
1752 proj.doProjectInclude("default", IncludeFlagFeature, proj.variables());
1753#endif
1754 parsed = proj.read(file, proj.variables()); // parse just that file (fromfile, infile)
1755 } else {
1756 parsed = proj.read(file); // parse all aux files (load/include into)
1757 }
1758 place = proj.variables();
1759 } else {
1760 parsed = read(file, place);
1761 }
1762 iterator = it;
1763 function = fu;
1764 scope_blocks = sc;
1765 }
1766 if(parsed) {
1767 if(place["QMAKE_INTERNAL_INCLUDED_FILES"].indexOf(orig_file) == -1)
1768 place["QMAKE_INTERNAL_INCLUDED_FILES"].append(orig_file);
1769 } else {
1770 warn_msg(WarnParser, "%s:%d: Failure to include file %s.",
1771 pi.file.toLatin1().constData(), pi.line_no, orig_file.toLatin1().constData());
1772 }
1773 parser = pi;
1774 qmake_setpwd(oldpwd);
1775 if(!parsed)
1776 return IncludeParseFailure;
1777 return IncludeSuccess;
1778}
1779
1780QStringList
1781QMakeProject::doProjectExpand(QString func, const QString &params,
1782 QMap<QString, QStringList> &place)
1783{
1784 return doProjectExpand(func, split_arg_list(params), place);
1785}
1786
1787QStringList
1788QMakeProject::doProjectExpand(QString func, QStringList args,
1789 QMap<QString, QStringList> &place)
1790{
1791 QList<QStringList> args_list;
1792 for(int i = 0; i < args.size(); ++i) {
1793 QStringList arg = split_value_list(args[i]), tmp;
1794 for(int i = 0; i < arg.size(); ++i)
1795 tmp += doVariableReplaceExpand(arg[i], place);;
1796 args_list += tmp;
1797 }
1798 return doProjectExpand(func, args_list, place);
1799}
1800
1801// defined in symbian generator
1802extern QString generate_test_uid(const QString& target);
1803
1804QStringList
1805QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
1806 QMap<QString, QStringList> &place)
1807{
1808 func = func.trimmed();
1809 if(replaceFunctions.contains(func)) {
1810 FunctionBlock *defined = replaceFunctions[func];
1811 function_blocks.push(defined);
1812 QStringList ret;
1813 defined->exec(args_list, this, place, ret);
1814 FunctionBlock *popped = function_blocks.pop();
1815 Q_ASSERT(popped == defined);
1816 Q_UNUSED(popped);
1817 return ret;
1818 }
1819
1820 QStringList args; //why don't the builtin functions just use args_list? --Sam
1821 for(int i = 0; i < args_list.size(); ++i)
1822 args += args_list[i].join(QString(Option::field_sep));
1823
1824 ExpandFunc func_t = qmake_expandFunctions().value(func);
1825 if (!func_t && (func_t = qmake_expandFunctions().value(func.toLower())))
1826 warn_msg(WarnDeprecated, "%s:%d: Using uppercased builtin functions is deprecated.",
1827 parser.file.toLatin1().constData(), parser.line_no);
1828 debug_msg(1, "Running project expand: %s(%s) [%d]",
1829 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
1830
1831 QStringList ret;
1832 switch(func_t) {
1833 case E_MEMBER: {
1834 if(args.count() < 1 || args.count() > 3) {
1835 fprintf(stderr, "%s:%d: member(var, start, end) requires three arguments.\n",
1836 parser.file.toLatin1().constData(), parser.line_no);
1837 } else {
1838 bool ok = true;
1839 const QStringList &var = values(args.first(), place);
1840 int start = 0, end = 0;
1841 if(args.count() >= 2) {
1842 QString start_str = args[1];
1843 start = start_str.toInt(&ok);
1844 if(!ok) {
1845 if(args.count() == 2) {
1846 int dotdot = start_str.indexOf("..");
1847 if(dotdot != -1) {
1848 start = start_str.left(dotdot).toInt(&ok);
1849 if(ok)
1850 end = start_str.mid(dotdot+2).toInt(&ok);
1851 }
1852 }
1853 if(!ok)
1854 fprintf(stderr, "%s:%d: member() argument 2 (start) '%s' invalid.\n",
1855 parser.file.toLatin1().constData(), parser.line_no,
1856 start_str.toLatin1().constData());
1857 } else {
1858 end = start;
1859 if(args.count() == 3)
1860 end = args[2].toInt(&ok);
1861 if(!ok)
1862 fprintf(stderr, "%s:%d: member() argument 3 (end) '%s' invalid.\n",
1863 parser.file.toLatin1().constData(), parser.line_no,
1864 args[2].toLatin1().constData());
1865 }
1866 }
1867 if(ok) {
1868 if(start < 0)
1869 start += var.count();
1870 if(end < 0)
1871 end += var.count();
1872 if(start < 0 || start >= var.count() || end < 0 || end >= var.count()) {
1873 //nothing
1874 } else if(start < end) {
1875 for(int i = start; i <= end && (int)var.count() >= i; i++)
1876 ret += var[i];
1877 } else {
1878 for(int i = start; i >= end && (int)var.count() >= i && i >= 0; i--)
1879 ret += var[i];
1880 }
1881 }
1882 }
1883 break; }
1884 case E_FIRST:
1885 case E_LAST: {
1886 if(args.count() != 1) {
1887 fprintf(stderr, "%s:%d: %s(var) requires one argument.\n",
1888 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
1889 } else {
1890 const QStringList &var = values(args.first(), place);
1891 if(!var.isEmpty()) {
1892 if(func_t == E_FIRST)
1893 ret = QStringList(var[0]);
1894 else
1895 ret = QStringList(var[var.size()-1]);
1896 }
1897 }
1898 break; }
1899 case E_CAT: {
1900 if(args.count() < 1 || args.count() > 2) {
1901 fprintf(stderr, "%s:%d: cat(file) requires one argument.\n",
1902 parser.file.toLatin1().constData(), parser.line_no);
1903 } else {
1904 QString file = args[0];
1905 file = Option::fixPathToLocalOS(file);
1906
1907 bool singleLine = true;
1908 if(args.count() > 1)
1909 singleLine = (args[1].toLower() == "true");
1910
1911 QFile qfile(file);
1912 if(qfile.open(QIODevice::ReadOnly)) {
1913 QTextStream stream(&qfile);
1914 while(!stream.atEnd()) {
1915 ret += split_value_list(stream.readLine().trimmed());
1916 if(!singleLine)
1917 ret += "\n";
1918 }
1919 qfile.close();
1920 }
1921 }
1922 break; }
1923 case E_FROMFILE: {
1924 if(args.count() != 2) {
1925 fprintf(stderr, "%s:%d: fromfile(file, variable) requires two arguments.\n",
1926 parser.file.toLatin1().constData(), parser.line_no);
1927 } else {
1928 QString file = args[0], seek_var = args[1];
1929 file = Option::fixPathToLocalOS(file);
1930
1931 QMap<QString, QStringList> tmp;
1932 if(doProjectInclude(file, IncludeFlagNewParser, tmp) == IncludeSuccess) {
1933 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
1934 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
1935 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
1936 for(int i = 0; i < in.size(); ++i) {
1937 if(out.indexOf(in[i]) == -1)
1938 out += in[i];
1939 }
1940 }
1941 ret = tmp[seek_var];
1942 }
1943 }
1944 break; }
1945 case E_EVAL: {
1946 if(args.count() < 1 || args.count() > 2) {
1947 fprintf(stderr, "%s:%d: eval(variable) requires one argument.\n",
1948 parser.file.toLatin1().constData(), parser.line_no);
1949
1950 } else {
1951 const QMap<QString, QStringList> *source = &place;
1952 if(args.count() == 2) {
1953 if(args.at(1) == "Global") {
1954 source = &vars;
1955 } else if(args.at(1) == "Local") {
1956 source = &place;
1957 } else {
1958 fprintf(stderr, "%s:%d: unexpected source to eval.\n", parser.file.toLatin1().constData(),
1959 parser.line_no);
1960 }
1961 }
1962 ret += source->value(args.at(0));
1963 }
1964 break; }
1965 case E_LIST: {
1966 static int x = 0;
1967 QString tmp;
1968 tmp.sprintf(".QMAKE_INTERNAL_TMP_VAR_%d", x++);
1969 ret = QStringList(tmp);
1970 QStringList &lst = (*((QMap<QString, QStringList>*)&place))[tmp];
1971 lst.clear();
1972 for(QStringList::ConstIterator arg_it = args.begin();
1973 arg_it != args.end(); ++arg_it)
1974 lst += split_value_list((*arg_it));
1975 break; }
1976 case E_SPRINTF: {
1977 if(args.count() < 1) {
1978 fprintf(stderr, "%s:%d: sprintf(format, ...) requires one argument.\n",
1979 parser.file.toLatin1().constData(), parser.line_no);
1980 } else {
1981 QString tmp = args.at(0);
1982 for(int i = 1; i < args.count(); ++i)
1983 tmp = tmp.arg(args.at(i));
1984 ret = split_value_list(tmp);
1985 }
1986 break; }
1987 case E_JOIN: {
1988 if(args.count() < 1 || args.count() > 4) {
1989 fprintf(stderr, "%s:%d: join(var, glue, before, after) requires four"
1990 "arguments.\n", parser.file.toLatin1().constData(), parser.line_no);
1991 } else {
1992 QString glue, before, after;
1993 if(args.count() >= 2)
1994 glue = args[1];
1995 if(args.count() >= 3)
1996 before = args[2];
1997 if(args.count() == 4)
1998 after = args[3];
1999 const QStringList &var = values(args.first(), place);
2000 if(!var.isEmpty())
2001 ret = split_value_list(before + var.join(glue) + after);
2002 }
2003 break; }
2004 case E_SPLIT: {
2005 if(args.count() < 1 || args.count() > 2) {
2006 fprintf(stderr, "%s:%d split(var, sep) requires one or two arguments\n",
2007 parser.file.toLatin1().constData(), parser.line_no);
2008 } else {
2009 QString sep = QString(Option::field_sep);
2010 if(args.count() >= 2)
2011 sep = args[1];
2012 QStringList var = values(args.first(), place);
2013 for(QStringList::ConstIterator vit = var.begin(); vit != var.end(); ++vit) {
2014 QStringList lst = (*vit).split(sep);
2015 for(QStringList::ConstIterator spltit = lst.begin(); spltit != lst.end(); ++spltit)
2016 ret += (*spltit);
2017 }
2018 }
2019 break; }
2020 case E_BASENAME:
2021 case E_DIRNAME:
2022 case E_SECTION: {
2023 bool regexp = false;
2024 QString sep, var;
2025 int beg=0, end=-1;
2026 if(func_t == E_SECTION) {
2027 if(args.count() != 3 && args.count() != 4) {
2028 fprintf(stderr, "%s:%d section(var, sep, begin, end) requires three argument\n",
2029 parser.file.toLatin1().constData(), parser.line_no);
2030 } else {
2031 var = args[0];
2032 sep = args[1];
2033 beg = args[2].toInt();
2034 if(args.count() == 4)
2035 end = args[3].toInt();
2036 }
2037 } else {
2038 if(args.count() != 1) {
2039 fprintf(stderr, "%s:%d %s(var) requires one argument.\n",
2040 parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());
2041 } else {
2042 var = args[0];
2043 regexp = true;
2044 sep = "[" + QRegExp::escape(Option::dir_sep) + "/]";
2045 if(func_t == E_DIRNAME)
2046 end = -2;
2047 else
2048 beg = -1;
2049 }
2050 }
2051 if(!var.isNull()) {
2052 const QStringList &l = values(var, place);
2053 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2054 QString separator = sep;
2055 if(regexp)
2056 ret += (*it).section(QRegExp(separator), beg, end);
2057 else
2058 ret += (*it).section(separator, beg, end);
2059 }
2060 }
2061 break; }
2062 case E_FIND: {
2063 if(args.count() != 2) {
2064 fprintf(stderr, "%s:%d find(var, str) requires two arguments\n",
2065 parser.file.toLatin1().constData(), parser.line_no);
2066 } else {
2067 QRegExp regx(args[1]);
2068 const QStringList &var = values(args.first(), place);
2069 for(QStringList::ConstIterator vit = var.begin();
2070 vit != var.end(); ++vit) {
2071 if(regx.indexIn(*vit) != -1)
2072 ret += (*vit);
2073 }
2074 }
2075 break; }
2076 case E_SYSTEM: {
2077 if(args.count() < 1 || args.count() > 2) {
2078 fprintf(stderr, "%s:%d system(execut) requires one argument.\n",
2079 parser.file.toLatin1().constData(), parser.line_no);
2080 } else {
2081 char buff[256];
2082 bool singleLine = true;
2083 if(args.count() > 1)
2084 singleLine = (args[1].toLower() == "true");
2085 QString output;
2086 FILE *proc = QT_POPEN(args[0].toLatin1(), "r");
2087 while(proc && !feof(proc)) {
2088 int read_in = int(fread(buff, 1, 255, proc));
2089 if(!read_in)
2090 break;
2091 for(int i = 0; i < read_in; i++) {
2092 if((singleLine && buff[i] == '\n') || buff[i] == '\t')
2093 buff[i] = ' ';
2094 }
2095 buff[read_in] = '\0';
2096 output += buff;
2097 }
2098 ret += split_value_list(output);
2099 if(proc)
2100 QT_PCLOSE(proc);
2101 }
2102 break; }
2103 case E_UNIQUE: {
2104 if(args.count() != 1) {
2105 fprintf(stderr, "%s:%d unique(var) requires one argument.\n",
2106 parser.file.toLatin1().constData(), parser.line_no);
2107 } else {
2108 const QStringList &var = values(args.first(), place);
2109 for(int i = 0; i < var.count(); i++) {
2110 if(!ret.contains(var[i]))
2111 ret.append(var[i]);
2112 }
2113 }
2114 break; }
2115 case E_QUOTE:
2116 ret = args;
2117 break;
2118 case E_ESCAPE_EXPAND: {
2119 for(int i = 0; i < args.size(); ++i) {
2120 QChar *i_data = args[i].data();
2121 int i_len = args[i].length();
2122 for(int x = 0; x < i_len; ++x) {
2123 if(*(i_data+x) == '\\' && x < i_len-1) {
2124 if(*(i_data+x+1) == '\\') {
2125 ++x;
2126 } else {
2127 struct {
2128 char in, out;
2129 } mapped_quotes[] = {
2130 { 'n', '\n' },
2131 { 't', '\t' },
2132 { 'r', '\r' },
2133 { 0, 0 }
2134 };
2135 for(int i = 0; mapped_quotes[i].in; ++i) {
2136 if(*(i_data+x+1) == mapped_quotes[i].in) {
2137 *(i_data+x) = mapped_quotes[i].out;
2138 if(x < i_len-2)
2139 memmove(i_data+x+1, i_data+x+2, (i_len-x-2)*sizeof(QChar));
2140 --i_len;
2141 break;
2142 }
2143 }
2144 }
2145 }
2146 }
2147 ret.append(QString(i_data, i_len));
2148 }
2149 break; }
2150 case E_RE_ESCAPE: {
2151 for(int i = 0; i < args.size(); ++i)
2152 ret += QRegExp::escape(args[i]);
2153 break; }
2154 case E_UPPER:
2155 case E_LOWER: {
2156 for(int i = 0; i < args.size(); ++i) {
2157 if(func_t == E_UPPER)
2158 ret += args[i].toUpper();
2159 else
2160 ret += args[i].toLower();
2161 }
2162 break; }
2163 case E_FILES: {
2164 if(args.count() != 1 && args.count() != 2) {
2165 fprintf(stderr, "%s:%d files(pattern) requires one argument.\n",
2166 parser.file.toLatin1().constData(), parser.line_no);
2167 } else {
2168 bool recursive = false;
2169 if(args.count() == 2)
2170 recursive = (args[1].toLower() == "true" || args[1].toInt());
2171 QStringList dirs;
2172 QString r = Option::fixPathToLocalOS(args[0]);
2173 int slash = r.lastIndexOf(QDir::separator());
2174 if(slash != -1) {
2175 dirs.append(r.left(slash));
2176 r = r.mid(slash+1);
2177 } else {
2178 dirs.append("");
2179 }
2180
2181 const QRegExp regex(r, Qt::CaseSensitive, QRegExp::Wildcard);
2182 for(int d = 0; d < dirs.count(); d++) {
2183 QString dir = dirs[d];
2184 if(!dir.isEmpty() && !dir.endsWith(QDir::separator()))
2185 dir += "/";
2186
2187 QDir qdir(dir);
2188 for(int i = 0; i < (int)qdir.count(); ++i) {
2189 if(qdir[i] == "." || qdir[i] == "..")
2190 continue;
2191 QString fname = dir + qdir[i];
2192 if(QFileInfo(fname).isDir()) {
2193 if(recursive)
2194 dirs.append(fname);
2195 }
2196 if(regex.exactMatch(qdir[i]))
2197 ret += fname;
2198 }
2199 }
2200 }
2201 break; }
2202 case E_PROMPT: {
2203 if(args.count() != 1) {
2204 fprintf(stderr, "%s:%d prompt(question) requires one argument.\n",
2205 parser.file.toLatin1().constData(), parser.line_no);
2206 } else if(pfile == "-") {
2207 fprintf(stderr, "%s:%d prompt(question) cannot be used when '-o -' is used.\n",
2208 parser.file.toLatin1().constData(), parser.line_no);
2209 } else {
2210 QString msg = fixEnvVariables(args.first());
2211 if(!msg.endsWith("?"))
2212 msg += "?";
2213 fprintf(stderr, "Project %s: %s ", func.toUpper().toLatin1().constData(),
2214 msg.toLatin1().constData());
2215
2216 QFile qfile;
2217 if(qfile.open(stdin, QIODevice::ReadOnly)) {
2218 QTextStream t(&qfile);
2219 ret = split_value_list(t.readLine());
2220 }
2221 }
2222 break; }
2223 case E_REPLACE: {
2224 if(args.count() != 3 ) {
2225 fprintf(stderr, "%s:%d replace(var, before, after) requires three arguments\n",
2226 parser.file.toLatin1().constData(), parser.line_no);
2227 } else {
2228 const QRegExp before( args[1] );
2229 const QString after( args[2] );
2230 QStringList var = values(args.first(), place);
2231 for(QStringList::Iterator it = var.begin(); it != var.end(); ++it)
2232 ret += it->replace(before, after);
2233 }
2234 break; }
2235 case E_SIZE: {
2236 if(args.count() != 1) {
2237 fprintf(stderr, "%s:%d: size(var) requires one argument.\n",
2238 parser.file.toLatin1().constData(), parser.line_no);
2239 } else {
2240 int size = values(args[0], place).size();
2241 ret += QString::number(size);
2242 }
2243 break; }
2244 case E_GENERATE_UID:
2245 if (args.count() != 1) {
2246 fprintf(stderr, "%s:%d: generate_uid(var) requires one argument.\n",
2247 parser.file.toLatin1().constData(), parser.line_no);
2248 } else {
2249 ret += generate_test_uid(args.first());
2250 }
2251 break;
2252 default: {
2253 fprintf(stderr, "%s:%d: Unknown replace function: %s\n",
2254 parser.file.toLatin1().constData(), parser.line_no,
2255 func.toLatin1().constData());
2256 break; }
2257 }
2258 return ret;
2259}
2260
2261bool
2262QMakeProject::doProjectTest(QString func, QStringList args, QMap<QString, QStringList> &place)
2263{
2264 QList<QStringList> args_list;
2265 for(int i = 0; i < args.size(); ++i) {
2266 QStringList arg = split_value_list(args[i]), tmp;
2267 for(int i = 0; i < arg.size(); ++i)
2268 tmp += doVariableReplaceExpand(arg[i], place);
2269 args_list += tmp;
2270 }
2271 return doProjectTest(func, args_list, place);
2272}
2273
2274bool
2275QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QMap<QString, QStringList> &place)
2276{
2277 func = func.trimmed();
2278
2279 if(testFunctions.contains(func)) {
2280 FunctionBlock *defined = testFunctions[func];
2281 QStringList ret;
2282 function_blocks.push(defined);
2283 defined->exec(args_list, this, place, ret);
2284 FunctionBlock *popped = function_blocks.pop();
2285 Q_ASSERT(popped == defined);
2286 Q_UNUSED(popped);
2287
2288 if(ret.isEmpty()) {
2289 return true;
2290 } else {
2291 if(ret.first() == "true") {
2292 return true;
2293 } else if(ret.first() == "false") {
2294 return false;
2295 } else {
2296 bool ok;
2297 int val = ret.first().toInt(&ok);
2298 if(ok)
2299 return val;
2300 fprintf(stderr, "%s:%d Unexpected return value from test %s [%s].\n",
2301 parser.file.toLatin1().constData(),
2302 parser.line_no, func.toLatin1().constData(),
2303 ret.join("::").toLatin1().constData());
2304 }
2305 return false;
2306 }
2307 return false;
2308 }
2309
2310 QStringList args; //why don't the builtin functions just use args_list? --Sam
2311 for(int i = 0; i < args_list.size(); ++i)
2312 args += args_list[i].join(QString(Option::field_sep));
2313
2314 TestFunc func_t = qmake_testFunctions().value(func);
2315 debug_msg(1, "Running project test: %s(%s) [%d]",
2316 func.toLatin1().constData(), args.join("::").toLatin1().constData(), func_t);
2317
2318 switch(func_t) {
2319 case T_REQUIRES:
2320 return doProjectCheckReqs(args, place);
2321 case T_LESSTHAN:
2322 case T_GREATERTHAN: {
2323 if(args.count() != 2) {
2324 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2325 parser.line_no, func.toLatin1().constData());
2326 return false;
2327 }
2328 QString rhs(args[1]), lhs(values(args[0], place).join(QString(Option::field_sep)));
2329 bool ok;
2330 int rhs_int = rhs.toInt(&ok);
2331 if(ok) { // do integer compare
2332 int lhs_int = lhs.toInt(&ok);
2333 if(ok) {
2334 if(func_t == T_GREATERTHAN)
2335 return lhs_int > rhs_int;
2336 return lhs_int < rhs_int;
2337 }
2338 }
2339 if(func_t == T_GREATERTHAN)
2340 return lhs > rhs;
2341 return lhs < rhs; }
2342 case T_IF: {
2343 if(args.count() != 1) {
2344 fprintf(stderr, "%s:%d: if(condition) requires one argument.\n", parser.file.toLatin1().constData(),
2345 parser.line_no);
2346 return false;
2347 }
2348 const QString cond = args.first();
2349 const QChar *d = cond.unicode();
2350 QChar quote = 0;
2351 bool ret = true, or_op = false;
2352 QString test;
2353 for(int d_off = 0, parens = 0, d_len = cond.size(); d_off < d_len; ++d_off) {
2354 if(!quote.isNull()) {
2355 if(*(d+d_off) == quote)
2356 quote = QChar();
2357 } else if(*(d+d_off) == '(') {
2358 ++parens;
2359 } else if(*(d+d_off) == ')') {
2360 --parens;
2361 } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {
2362 quote = *(d+d_off);
2363 }
2364 if(!parens && quote.isNull() && (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('|') || d_off == d_len-1)) {
2365 if(d_off == d_len-1)
2366 test += *(d+d_off);
2367 if(!test.isEmpty()) {
2368 if (or_op != ret)
2369 ret = doProjectTest(test, place);
2370 test.clear();
2371 }
2372 if(*(d+d_off) == QLatin1Char(':')) {
2373 or_op = false;
2374 } else if(*(d+d_off) == QLatin1Char('|')) {
2375 or_op = true;
2376 }
2377 } else {
2378 test += *(d+d_off);
2379 }
2380 }
2381 return ret; }
2382 case T_EQUALS:
2383 if(args.count() != 2) {
2384 fprintf(stderr, "%s:%d: %s(variable, value) requires two arguments.\n", parser.file.toLatin1().constData(),
2385 parser.line_no, func.toLatin1().constData());
2386 return false;
2387 }
2388 return values(args[0], place).join(QString(Option::field_sep)) == args[1];
2389 case T_EXISTS: {
2390 if(args.count() != 1) {
2391 fprintf(stderr, "%s:%d: exists(file) requires one argument.\n", parser.file.toLatin1().constData(),
2392 parser.line_no);
2393 return false;
2394 }
2395 QString file = args.first();
2396 file = Option::fixPathToLocalOS(file);
2397
2398 if(QFile::exists(file))
2399 return true;
2400 //regular expression I guess
2401 QString dirstr = qmake_getpwd();
2402 int slsh = file.lastIndexOf(QDir::separator());
2403 if(slsh != -1) {
2404 dirstr = file.left(slsh+1);
2405 file = file.right(file.length() - slsh - 1);
2406 }
2407 return QDir(dirstr).entryList(QStringList(file)).count(); }
2408 case T_EXPORT:
2409 if(args.count() != 1) {
2410 fprintf(stderr, "%s:%d: export(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2411 parser.line_no);
2412 return false;
2413 }
2414 for(int i = 0; i < function_blocks.size(); ++i) {
2415 FunctionBlock *f = function_blocks.at(i);
2416 f->vars[args[0]] = values(args[0], place);
2417 if(!i && f->calling_place)
2418 (*f->calling_place)[args[0]] = values(args[0], place);
2419 }
2420 return true;
2421 case T_CLEAR:
2422 if(args.count() != 1) {
2423 fprintf(stderr, "%s:%d: clear(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2424 parser.line_no);
2425 return false;
2426 }
2427 if(!place.contains(args[0]))
2428 return false;
2429 place[args[0]].clear();
2430 return true;
2431 case T_UNSET:
2432 if(args.count() != 1) {
2433 fprintf(stderr, "%s:%d: unset(variable) requires one argument.\n", parser.file.toLatin1().constData(),
2434 parser.line_no);
2435 return false;
2436 }
2437 if(!place.contains(args[0]))
2438 return false;
2439 place.remove(args[0]);
2440 return true;
2441 case T_EVAL: {
2442 if(args.count() < 1 && 0) {
2443 fprintf(stderr, "%s:%d: eval(project) requires one argument.\n", parser.file.toLatin1().constData(),
2444 parser.line_no);
2445 return false;
2446 }
2447 QString project = args.join(" ");
2448 parser_info pi = parser;
2449 parser.from_file = false;
2450 parser.file = "(eval)";
2451 parser.line_no = 0;
2452 QTextStream t(&project, QIODevice::ReadOnly);
2453 bool ret = read(t, place);
2454 parser = pi;
2455 return ret; }
2456 case T_CONFIG: {
2457 if(args.count() < 1 || args.count() > 2) {
2458 fprintf(stderr, "%s:%d: CONFIG(config) requires one argument.\n", parser.file.toLatin1().constData(),
2459 parser.line_no);
2460 return false;
2461 }
2462 if(args.count() == 1)
2463 return isActiveConfig(args[0]);
2464 const QStringList mutuals = args[1].split('|');
2465 const QStringList &configs = values("CONFIG", place);
2466 for(int i = configs.size()-1; i >= 0; i--) {
2467 for(int mut = 0; mut < mutuals.count(); mut++) {
2468 if(configs[i] == mutuals[mut].trimmed())
2469 return (configs[i] == args[0]);
2470 }
2471 }
2472 return false; }
2473 case T_SYSTEM:
2474 if(args.count() < 1 || args.count() > 2) {
2475 fprintf(stderr, "%s:%d: system(exec) requires one argument.\n", parser.file.toLatin1().constData(),
2476 parser.line_no);
2477 return false;
2478 }
2479 if(args.count() == 2) {
2480 const QString sarg = args[1];
2481 if (sarg.toLower() == "true" || sarg.toInt())
2482 warn_msg(WarnParser, "%s:%d: system()'s second argument is now hard-wired to false.\n",
2483 parser.file.toLatin1().constData(), parser.line_no);
2484 }
2485 return system(args[0].toLatin1().constData()) == 0;
2486 case T_RETURN:
2487 if(function_blocks.isEmpty()) {
2488 fprintf(stderr, "%s:%d unexpected return()\n",
2489 parser.file.toLatin1().constData(), parser.line_no);
2490 } else {
2491 FunctionBlock *f = function_blocks.top();
2492 f->cause_return = true;
2493 if(args_list.count() >= 1)
2494 f->return_value += args_list[0];
2495 }
2496 return true;
2497 case T_BREAK:
2498 if(iterator)
2499 iterator->cause_break = true;
2500 else
2501 fprintf(stderr, "%s:%d unexpected break()\n",
2502 parser.file.toLatin1().constData(), parser.line_no);
2503 return true;
2504 case T_NEXT:
2505 if(iterator)
2506 iterator->cause_next = true;
2507 else
2508 fprintf(stderr, "%s:%d unexpected next()\n",
2509 parser.file.toLatin1().constData(), parser.line_no);
2510 return true;
2511 case T_DEFINED:
2512 if(args.count() < 1 || args.count() > 2) {
2513 fprintf(stderr, "%s:%d: defined(function) requires one argument.\n",
2514 parser.file.toLatin1().constData(), parser.line_no);
2515 } else {
2516 if(args.count() > 1) {
2517 if(args[1] == "test")
2518 return testFunctions.contains(args[0]);
2519 else if(args[1] == "replace")
2520 return replaceFunctions.contains(args[0]);
2521 fprintf(stderr, "%s:%d: defined(function, type): unexpected type [%s].\n",
2522 parser.file.toLatin1().constData(), parser.line_no,
2523 args[1].toLatin1().constData());
2524 } else {
2525 if(replaceFunctions.contains(args[0]) || testFunctions.contains(args[0]))
2526 return true;
2527 }
2528 }
2529 return false;
2530 case T_CONTAINS: {
2531 if(args.count() < 2 || args.count() > 3) {
2532 fprintf(stderr, "%s:%d: contains(var, val) requires at lesat 2 arguments.\n",
2533 parser.file.toLatin1().constData(), parser.line_no);
2534 return false;
2535 }
2536 QRegExp regx(args[1]);
2537 const QStringList &l = values(args[0], place);
2538 if(args.count() == 2) {
2539 for(int i = 0; i < l.size(); ++i) {
2540 const QString val = l[i];
2541 if(regx.exactMatch(val) || val == args[1])
2542 return true;
2543 }
2544 } else {
2545 const QStringList mutuals = args[2].split('|');
2546 for(int i = l.size()-1; i >= 0; i--) {
2547 const QString val = l[i];
2548 for(int mut = 0; mut < mutuals.count(); mut++) {
2549 if(val == mutuals[mut].trimmed())
2550 return (regx.exactMatch(val) || val == args[1]);
2551 }
2552 }
2553 }
2554 return false; }
2555 case T_INFILE: {
2556 if(args.count() < 2 || args.count() > 3) {
2557 fprintf(stderr, "%s:%d: infile(file, var, val) requires at least 2 arguments.\n",
2558 parser.file.toLatin1().constData(), parser.line_no);
2559 return false;
2560 }
2561
2562 bool ret = false;
2563 QMap<QString, QStringList> tmp;
2564 if(doProjectInclude(Option::fixPathToLocalOS(args[0]), IncludeFlagNewParser, tmp) == IncludeSuccess) {
2565 if(tmp.contains("QMAKE_INTERNAL_INCLUDED_FILES")) {
2566 QStringList &out = place["QMAKE_INTERNAL_INCLUDED_FILES"];
2567 const QStringList &in = tmp["QMAKE_INTERNAL_INCLUDED_FILES"];
2568 for(int i = 0; i < in.size(); ++i) {
2569 if(out.indexOf(in[i]) == -1)
2570 out += in[i];
2571 }
2572 }
2573 if(args.count() == 2) {
2574 ret = tmp.contains(args[1]);
2575 } else {
2576 QRegExp regx(args[2]);
2577 const QStringList &l = tmp[args[1]];
2578 for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
2579 if(regx.exactMatch((*it)) || (*it) == args[2]) {
2580 ret = true;
2581 break;
2582 }
2583 }
2584 }
2585 }
2586 return ret; }
2587 case T_COUNT:
2588 if(args.count() != 2 && args.count() != 3) {
2589 fprintf(stderr, "%s:%d: count(var, count) requires two arguments.\n", parser.file.toLatin1().constData(),
2590 parser.line_no);
2591 return false;
2592 }
2593 if(args.count() == 3) {
2594 QString comp = args[2];
2595 if(comp == ">" || comp == "greaterThan")
2596 return values(args[0], place).count() > args[1].toInt();
2597 if(comp == ">=")
2598 return values(args[0], place).count() >= args[1].toInt();
2599 if(comp == "<" || comp == "lessThan")
2600 return values(args[0], place).count() < args[1].toInt();
2601 if(comp == "<=")
2602 return values(args[0], place).count() <= args[1].toInt();
2603 if(comp == "equals" || comp == "isEqual" || comp == "=" || comp == "==")
2604 return values(args[0], place).count() == args[1].toInt();
2605 fprintf(stderr, "%s:%d: unexpected modifier to count(%s)\n", parser.file.toLatin1().constData(),
2606 parser.line_no, comp.toLatin1().constData());
2607 return false;
2608 }
2609 return values(args[0], place).count() == args[1].toInt();
2610 case T_ISEMPTY:
2611 if(args.count() != 1) {
2612 fprintf(stderr, "%s:%d: isEmpty(var) requires one argument.\n", parser.file.toLatin1().constData(),
2613 parser.line_no);
2614 return false;
2615 }
2616 return values(args[0], place).isEmpty();
2617 case T_INCLUDE:
2618 case T_LOAD: {
2619 QString parseInto;
2620 const bool include_statement = (func_t == T_INCLUDE);
2621 bool ignore_error = false;
2622 if(args.count() >= 2) {
2623 if(func_t == T_INCLUDE) {
2624 parseInto = args[1];
2625 if (args.count() == 3){
2626 QString sarg = args[2];
2627 if (sarg.toLower() == "true" || sarg.toInt())
2628 ignore_error = true;
2629 }
2630 } else {
2631 QString sarg = args[1];
2632 ignore_error = (sarg.toLower() == "true" || sarg.toInt());
2633 }
2634 } else if(args.count() != 1) {
2635 QString func_desc = "load(feature)";
2636 if(include_statement)
2637 func_desc = "include(file)";
2638 fprintf(stderr, "%s:%d: %s requires one argument.\n", parser.file.toLatin1().constData(),
2639 parser.line_no, func_desc.toLatin1().constData());
2640 return false;
2641 }
2642 QString file = args.first();
2643 file = Option::fixPathToLocalOS(file);
2644 uchar flags = IncludeFlagNone;
2645 if(!include_statement)
2646 flags |= IncludeFlagFeature;
2647 IncludeStatus stat = IncludeFailure;
2648 if(!parseInto.isEmpty()) {
2649 QMap<QString, QStringList> symbols;
2650 stat = doProjectInclude(file, flags|IncludeFlagNewProject, symbols);
2651 if(stat == IncludeSuccess) {
2652 QMap<QString, QStringList> out_place;
2653 for(QMap<QString, QStringList>::ConstIterator it = place.begin(); it != place.end(); ++it) {
2654 const QString var = it.key();
2655 if(var != parseInto && !var.startsWith(parseInto + "."))
2656 out_place.insert(var, it.value());
2657 }
2658 for(QMap<QString, QStringList>::ConstIterator it = symbols.begin(); it != symbols.end(); ++it) {
2659 const QString var = it.key();
2660 if(!var.startsWith("."))
2661 out_place.insert(parseInto + "." + it.key(), it.value());
2662 }
2663 place = out_place;
2664 }
2665 } else {
2666 stat = doProjectInclude(file, flags, place);
2667 }
2668 if(stat == IncludeFeatureAlreadyLoaded) {
2669 warn_msg(WarnParser, "%s:%d: Duplicate of loaded feature %s",
2670 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
2671 } else if(stat == IncludeNoExist && !ignore_error) {
2672 warn_msg(WarnAll, "%s:%d: Unable to find file for inclusion %s",
2673 parser.file.toLatin1().constData(), parser.line_no, file.toLatin1().constData());
2674 return false;
2675 } else if(stat >= IncludeFailure) {
2676 if(!ignore_error) {
2677 printf("Project LOAD(): Feature %s cannot be found.\n", file.toLatin1().constData());
2678 if (!ignore_error)
2679#if defined(QT_BUILD_QMAKE_LIBRARY)
2680 return false;
2681#else
2682 exit(3);
2683#endif
2684 }
2685 return false;
2686 }
2687 return true; }
2688 case T_DEBUG: {
2689 if(args.count() != 2) {
2690 fprintf(stderr, "%s:%d: debug(level, message) requires one argument.\n", parser.file.toLatin1().constData(),
2691 parser.line_no);
2692 return false;
2693 }
2694 QString msg = fixEnvVariables(args[1]);
2695 debug_msg(args[0].toInt(), "Project DEBUG: %s", msg.toLatin1().constData());
2696 return true; }
2697 case T_ERROR:
2698 case T_MESSAGE:
2699 case T_WARNING: {
2700 if(args.count() != 1) {
2701 fprintf(stderr, "%s:%d: %s(message) requires one argument.\n", parser.file.toLatin1().constData(),
2702 parser.line_no, func.toLatin1().constData());
2703 return false;
2704 }
2705 QString msg = fixEnvVariables(args.first());
2706 fprintf(stderr, "Project %s: %s\n", func.toUpper().toLatin1().constData(), msg.toLatin1().constData());
2707 if(func == "error")
2708#if defined(QT_BUILD_QMAKE_LIBRARY)
2709 return false;
2710#else
2711 exit(2);
2712#endif
2713 return true; }
2714 case T_OPTION:
2715 if (args.count() != 1) {
2716 fprintf(stderr, "%s:%d: option() requires one argument.\n",
2717 parser.file.toLatin1().constData(), parser.line_no);
2718 return false;
2719 }
2720 if (args.first() == "recursive") {
2721 recursive = true;
2722 } else {
2723 fprintf(stderr, "%s:%d: unrecognized option() argument '%s'.\n",
2724 parser.file.toLatin1().constData(), parser.line_no,
2725 args.first().toLatin1().constData());
2726 return false;
2727 }
2728 return true;
2729 default:
2730 fprintf(stderr, "%s:%d: Unknown test function: %s\n", parser.file.toLatin1().constData(), parser.line_no,
2731 func.toLatin1().constData());
2732 }
2733 return false;
2734}
2735
2736bool
2737QMakeProject::doProjectCheckReqs(const QStringList &deps, QMap<QString, QStringList> &place)
2738{
2739 bool ret = false;
2740 for(QStringList::ConstIterator it = deps.begin(); it != deps.end(); ++it) {
2741 bool test = doProjectTest((*it), place);
2742 if(!test) {
2743 debug_msg(1, "Project Parser: %s:%d Failed test: REQUIRES = %s",
2744 parser.file.toLatin1().constData(), parser.line_no,
2745 (*it).toLatin1().constData());
2746 place["QMAKE_FAILED_REQUIREMENTS"].append((*it));
2747 ret = false;
2748 }
2749 }
2750 return ret;
2751}
2752
2753bool
2754QMakeProject::test(const QString &v)
2755{
2756 QMap<QString, QStringList> tmp = vars;
2757 return doProjectTest(v, tmp);
2758}
2759
2760bool
2761QMakeProject::test(const QString &func, const QList<QStringList> &args)
2762{
2763 QMap<QString, QStringList> tmp = vars;
2764 return doProjectTest(func, args, tmp);
2765}
2766
2767QStringList
2768QMakeProject::expand(const QString &str)
2769{
2770 bool ok;
2771 QMap<QString, QStringList> tmp = vars;
2772 const QStringList ret = doVariableReplaceExpand(str, tmp, &ok);
2773 if(ok)
2774 return ret;
2775 return QStringList();
2776}
2777
2778QStringList
2779QMakeProject::expand(const QString &func, const QList<QStringList> &args)
2780{
2781 QMap<QString, QStringList> tmp = vars;
2782 return doProjectExpand(func, args, tmp);
2783}
2784
2785bool
2786QMakeProject::doVariableReplace(QString &str, QMap<QString, QStringList> &place)
2787{
2788 bool ret;
2789 str = doVariableReplaceExpand(str, place, &ret).join(QString(Option::field_sep));
2790 return ret;
2791}
2792
2793QStringList
2794QMakeProject::doVariableReplaceExpand(const QString &str, QMap<QString, QStringList> &place, bool *ok)
2795{
2796 QStringList ret;
2797 if(ok)
2798 *ok = true;
2799 if(str.isEmpty())
2800 return ret;
2801
2802 const ushort LSQUARE = '[';
2803 const ushort RSQUARE = ']';
2804 const ushort LCURLY = '{';
2805 const ushort RCURLY = '}';
2806 const ushort LPAREN = '(';
2807 const ushort RPAREN = ')';
2808 const ushort DOLLAR = '$';
2809 const ushort SLASH = '\\';
2810 const ushort UNDERSCORE = '_';
2811 const ushort DOT = '.';
2812 const ushort SPACE = ' ';
2813 const ushort TAB = '\t';
2814 const ushort SINGLEQUOTE = '\'';
2815 const ushort DOUBLEQUOTE = '"';
2816
2817 ushort unicode, quote = 0;
2818 const QChar *str_data = str.data();
2819 const int str_len = str.length();
2820
2821 ushort term;
2822 QString var, args;
2823
2824 int replaced = 0;
2825 QString current;
2826 for(int i = 0; i < str_len; ++i) {
2827 unicode = str_data[i].unicode();
2828 const int start_var = i;
2829 if(unicode == DOLLAR && str_len > i+2) {
2830 unicode = str_data[++i].unicode();
2831 if(unicode == DOLLAR) {
2832 term = 0;
2833 var.clear();
2834 args.clear();
2835 enum { VAR, ENVIRON, FUNCTION, PROPERTY } var_type = VAR;
2836 unicode = str_data[++i].unicode();
2837 if(unicode == LSQUARE) {
2838 unicode = str_data[++i].unicode();
2839 term = RSQUARE;
2840 var_type = PROPERTY;
2841 } else if(unicode == LCURLY) {
2842 unicode = str_data[++i].unicode();
2843 var_type = VAR;
2844 term = RCURLY;
2845 } else if(unicode == LPAREN) {
2846 unicode = str_data[++i].unicode();
2847 var_type = ENVIRON;
2848 term = RPAREN;
2849 }
2850 while(1) {
2851 if(!(unicode & (0xFF<<8)) &&
2852 unicode != DOT && unicode != UNDERSCORE &&
2853 //unicode != SINGLEQUOTE && unicode != DOUBLEQUOTE &&
2854 (unicode < 'a' || unicode > 'z') && (unicode < 'A' || unicode > 'Z') &&
2855 (unicode < '0' || unicode > '9'))
2856 break;
2857 var.append(QChar(unicode));
2858 if(++i == str_len)
2859 break;
2860 unicode = str_data[i].unicode();
2861 // at this point, i points to either the 'term' or 'next' character (which is in unicode)
2862 }
2863 if(var_type == VAR && unicode == LPAREN) {
2864 var_type = FUNCTION;
2865 int depth = 0;
2866 while(1) {
2867 if(++i == str_len)
2868 break;
2869 unicode = str_data[i].unicode();
2870 if(unicode == LPAREN) {
2871 depth++;
2872 } else if(unicode == RPAREN) {
2873 if(!depth)
2874 break;
2875 --depth;
2876 }
2877 args.append(QChar(unicode));
2878 }
2879 if(++i < str_len)
2880 unicode = str_data[i].unicode();
2881 else
2882 unicode = 0;
2883 // at this point i is pointing to the 'next' character (which is in unicode)
2884 // this might actually be a term character since you can do $${func()}
2885 }
2886 if(term) {
2887 if(unicode != term) {
2888 qmake_error_msg("Missing " + QString(term) + " terminator [found " + (unicode?QString(unicode):QString("end-of-line")) + "]");
2889 if(ok)
2890 *ok = false;
2891 return QStringList();
2892 }
2893 } else {
2894 // move the 'cursor' back to the last char of the thing we were looking at
2895 --i;
2896 }
2897 // since i never points to the 'next' character, there is no reason for this to be set
2898 unicode = 0;
2899
2900 QStringList replacement;
2901 if(var_type == ENVIRON) {
2902 replacement = split_value_list(QString::fromLocal8Bit(qgetenv(var.toLatin1().constData())));
2903 } else if(var_type == PROPERTY) {
2904 if(prop)
2905 replacement = split_value_list(prop->value(var));
2906 } else if(var_type == FUNCTION) {
2907 replacement = doProjectExpand(var, args, place);
2908 } else if(var_type == VAR) {
2909 replacement = values(var, place);
2910 }
2911 if(!(replaced++) && start_var)
2912 current = str.left(start_var);
2913 if(!replacement.isEmpty()) {
2914 if(quote) {
2915 current += replacement.join(QString(Option::field_sep));
2916 } else {
2917 current += replacement.takeFirst();
2918 if(!replacement.isEmpty()) {
2919 if(!current.isEmpty())
2920 ret.append(current);
2921 current = replacement.takeLast();
2922 if(!replacement.isEmpty())
2923 ret += replacement;
2924 }
2925 }
2926 }
2927 debug_msg(2, "Project Parser [var replace]: %s -> %s",
2928 str.toLatin1().constData(), var.toLatin1().constData(),
2929 replacement.join("::").toLatin1().constData());
2930 } else {
2931 if(replaced)
2932 current.append("$");
2933 }
2934 }
2935 if(quote && unicode == quote) {
2936 unicode = 0;
2937 quote = 0;
2938 } else if(unicode == SLASH) {
2939 bool escape = false;
2940 const char *symbols = "[]{}()$\\'\"";
2941 for(const char *s = symbols; *s; ++s) {
2942 if(str_data[i+1].unicode() == (ushort)*s) {
2943 i++;
2944 escape = true;
2945 if(!(replaced++))
2946 current = str.left(start_var);
2947 current.append(str.at(i));
2948 break;
2949 }
2950 }
2951 if(!escape && !backslashWarned) {
2952 backslashWarned = true;
2953 warn_msg(WarnDeprecated, "%s:%d: Unescaped backslashes are deprecated.",
2954 parser.file.toLatin1().constData(), parser.line_no);
2955 }
2956 if(escape || !replaced)
2957 unicode =0;
2958 } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {
2959 quote = unicode;
2960 unicode = 0;
2961 if(!(replaced++) && i)
2962 current = str.left(i);
2963 } else if(!quote && (unicode == SPACE || unicode == TAB)) {
2964 unicode = 0;
2965 if(!current.isEmpty()) {
2966 ret.append(current);
2967 current.clear();
2968 }
2969 }
2970 if(replaced && unicode)
2971 current.append(QChar(unicode));
2972 }
2973 if(!replaced)
2974 ret = QStringList(str);
2975 else if(!current.isEmpty())
2976 ret.append(current);
2977 //qDebug() << "REPLACE" << str << ret;
2978 return ret;
2979}
2980
2981QStringList &QMakeProject::values(const QString &_var, QMap<QString, QStringList> &place)
2982{
2983 QString var = varMap(_var);
2984 if(var == QLatin1String("LITERAL_WHITESPACE")) { //a real space in a token)
2985 var = ".BUILTIN." + var;
2986 place[var] = QStringList(QLatin1String("\t"));
2987 } else if(var == QLatin1String("LITERAL_DOLLAR")) { //a real $
2988 var = ".BUILTIN." + var;
2989 place[var] = QStringList(QLatin1String("$"));
2990 } else if(var == QLatin1String("LITERAL_HASH")) { //a real #
2991 var = ".BUILTIN." + var;
2992 place[var] = QStringList("#");
2993 } else if(var == QLatin1String("OUT_PWD")) { //the out going dir
2994 var = ".BUILTIN." + var;
2995 place[var] = QStringList(Option::output_dir);
2996 } else if(var == QLatin1String("PWD") || //current working dir (of _FILE_)
2997 var == QLatin1String("IN_PWD")) {
2998 var = ".BUILTIN." + var;
2999 place[var] = QStringList(qmake_getpwd());
3000 } else if(var == QLatin1String("DIR_SEPARATOR")) {
3001 var = ".BUILTIN." + var;
3002 place[var] = QStringList(Option::dir_sep);
3003 } else if(var == QLatin1String("DIRLIST_SEPARATOR")) {
3004 var = ".BUILTIN." + var;
3005 place[var] = QStringList(Option::dirlist_sep);
3006 } else if(var == QLatin1String("_LINE_")) { //parser line number
3007 var = ".BUILTIN." + var;
3008 place[var] = QStringList(QString::number(parser.line_no));
3009 } else if(var == QLatin1String("_FILE_")) { //parser file
3010 var = ".BUILTIN." + var;
3011 place[var] = QStringList(parser.file);
3012 } else if(var == QLatin1String("_DATE_")) { //current date/time
3013 var = ".BUILTIN." + var;
3014 place[var] = QStringList(QDateTime::currentDateTime().toString());
3015 } else if(var == QLatin1String("_PRO_FILE_")) {
3016 var = ".BUILTIN." + var;
3017 place[var] = QStringList(pfile);
3018 } else if(var == QLatin1String("_PRO_FILE_PWD_")) {
3019 var = ".BUILTIN." + var;
3020 place[var] = QStringList(pfile.isEmpty() ? qmake_getpwd() : QFileInfo(pfile).absolutePath());
3021 } else if(var == QLatin1String("_QMAKE_CACHE_")) {
3022 var = ".BUILTIN." + var;
3023 if(Option::mkfile::do_cache)
3024 place[var] = QStringList(Option::mkfile::cachefile);
3025 } else if(var == QLatin1String("TEMPLATE")) {
3026 if(!Option::user_template.isEmpty()) {
3027 var = ".BUILTIN.USER." + var;
3028 place[var] = QStringList(Option::user_template);
3029 } else if(!place[var].isEmpty()) {
3030 QString orig_template = place["TEMPLATE"].first(), real_template;
3031 if(!Option::user_template_prefix.isEmpty() && !orig_template.startsWith(Option::user_template_prefix))
3032 real_template = Option::user_template_prefix + orig_template;
3033 if(!real_template.isEmpty()) {
3034 var = ".BUILTIN." + var;
3035 place[var] = QStringList(real_template);
3036 }
3037 } else {
3038 var = ".BUILTIN." + var;
3039 place[var] = QStringList("app");
3040 }
3041 } else if(var.startsWith(QLatin1String("QMAKE_HOST."))) {
3042 QString ret, type = var.mid(11);
3043#if defined(Q_OS_WIN32)
3044 if(type == "os") {
3045 ret = "Windows";
3046 } else if(type == "name") {
3047 DWORD name_length = 1024;
3048 wchar_t name[1024];
3049 if (GetComputerName(name, &name_length))
3050 ret = QString::fromWCharArray(name);
3051 } else if(type == "version" || type == "version_string") {
3052 QSysInfo::WinVersion ver = QSysInfo::WindowsVersion;
3053 if(type == "version")
3054 ret = QString::number(ver);
3055 else if(ver == QSysInfo::WV_Me)
3056 ret = "WinMe";
3057 else if(ver == QSysInfo::WV_95)
3058 ret = "Win95";
3059 else if(ver == QSysInfo::WV_98)
3060 ret = "Win98";
3061 else if(ver == QSysInfo::WV_NT)
3062 ret = "WinNT";
3063 else if(ver == QSysInfo::WV_2000)
3064 ret = "Win2000";
3065 else if(ver == QSysInfo::WV_2000)
3066 ret = "Win2003";
3067 else if(ver == QSysInfo::WV_XP)
3068 ret = "WinXP";
3069 else if(ver == QSysInfo::WV_VISTA)
3070 ret = "WinVista";
3071 else
3072 ret = "Unknown";
3073 } else if(type == "arch") {
3074 SYSTEM_INFO info;
3075 GetSystemInfo(&info);
3076 switch(info.wProcessorArchitecture) {
3077#ifdef PROCESSOR_ARCHITECTURE_AMD64
3078 case PROCESSOR_ARCHITECTURE_AMD64:
3079 ret = "x86_64";
3080 break;
3081#endif
3082 case PROCESSOR_ARCHITECTURE_INTEL:
3083 ret = "x86";
3084 break;
3085 case PROCESSOR_ARCHITECTURE_IA64:
3086#ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
3087 case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
3088#endif
3089 ret = "IA64";
3090 break;
3091 default:
3092 ret = "Unknown";
3093 break;
3094 }
3095 }
3096#elif defined(Q_OS_OS2)
3097 if(type == "os") {
3098 ret = "OS2";
3099 } else if(type == "name") {
3100 ret = QString::fromLocal8Bit(qgetenv("HOSTNAME"));
3101 } else if(type == "version" || type == "version_string") {
3102 ULONG buf [3];
3103 DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_REVISION,
3104 &buf, sizeof(buf));
3105 if(type == "version")
3106 ret = QString().sprintf("%lu.%lu.%lu", buf[0], buf[1], buf[2]);
3107 else {
3108 /* Warp 3 is reported as 20.30 */
3109 /* Warp 4 is reported as 20.40 */
3110 /* Aurora and eCS are reported as 20.45 */
3111 if (buf[0] == 20 && buf[1] == 30)
3112 ret = "Warp3";
3113 else if (buf[0] == 20 && buf[1] == 40)
3114 ret = "Warp4";
3115 else if (buf[0] == 20 && buf[1] == 45) {
3116 if (QString::fromLocal8Bit(qgetenv("OS")) == "ecs")
3117 ret = "eComStation";
3118 else
3119 ret = "Aurora";
3120 }
3121 else
3122 ret = "Unknown";
3123 }
3124 } else if(type == "arch") {
3125 ret = "x86";
3126 }
3127#elif defined(Q_OS_UNIX)
3128 struct utsname name;
3129 if(!uname(&name)) {
3130 if(type == "os")
3131 ret = name.sysname;
3132 else if(type == "name")
3133 ret = name.nodename;
3134 else if(type == "version")
3135 ret = name.release;
3136 else if(type == "version_string")
3137 ret = name.version;
3138 else if(type == "arch")
3139 ret = name.machine;
3140 }
3141#endif
3142 var = ".BUILTIN.HOST." + type;
3143 place[var] = QStringList(ret);
3144 } else if (var == QLatin1String("QMAKE_DIR_SEP")) {
3145 if (place[var].isEmpty())
3146 return values("DIR_SEPARATOR", place);
3147 } else if (var == QLatin1String("QMAKE_EXT_OBJ")) {
3148 if (place[var].isEmpty()) {
3149 var = ".BUILTIN." + var;
3150 place[var] = QStringList(Option::obj_ext);
3151 }
3152 } else if (var == QLatin1String("QMAKE_QMAKE")) {
3153 if (place[var].isEmpty())
3154 place[var] = QStringList(Option::fixPathToTargetOS(
3155 !Option::qmake_abslocation.isEmpty()
3156 ? Option::qmake_abslocation
3157 : QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmake",
3158 false));
3159 } else if (var == QLatin1String("EPOCROOT")) {
3160 if (place[var].isEmpty())
3161 place[var] = QStringList(qt_epocRoot());
3162 }
3163#if defined(Q_OS_WIN32) && defined(Q_CC_MSVC)
3164 else if(var.startsWith(QLatin1String("QMAKE_TARGET."))) {
3165 QString ret, type = var.mid(13);
3166 if(type == "arch") {
3167 QString paths = qgetenv("PATH");
3168 QString vcBin64 = qgetenv("VCINSTALLDIR").append("\\bin\\amd64");
3169 QString vcBinX86_64 = qgetenv("VCINSTALLDIR").append("\\bin\\x86_amd64");
3170 if(paths.contains(vcBin64,Qt::CaseInsensitive) || paths.contains(vcBinX86_64,Qt::CaseInsensitive))
3171 ret = "x86_64";
3172 else
3173 ret = "x86";
3174 }
3175 place[var] = QStringList(ret);
3176 }
3177#endif
3178 //qDebug("REPLACE [%s]->[%s]", qPrintable(var), qPrintable(place[var].join("::")));
3179 return place[var];
3180}
3181
3182bool QMakeProject::isEmpty(const QString &v)
3183{
3184 QMap<QString, QStringList>::ConstIterator it = vars.constFind(varMap(v));
3185 return it == vars.constEnd() || it->isEmpty();
3186}
3187
3188QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.