Context Navigation

source: trunk/qmake/project.cpp@ 28

Last change on this file since 28 was 28, checked in by Dmitry A. Kuminov, 16 years ago
qmake: Create mkspecs/default.
File size: 123.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: