1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the qmake application of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    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 // Included from tools/shared

    66 #include <symbian/epocroot.h>

    67 

    68 #ifdef Q_OS_WIN32

    69 #define QT_POPEN _popen

    70 #define QT_PCLOSE _pclose

    71 #else

    72 #define QT_POPEN popen

    73 #define QT_PCLOSE pclose

    74 #endif

    75 

    76 QT_BEGIN_NAMESPACE

    77 

    78 //expand fucntions

    79 enum ExpandFunc { E_MEMBER=1, E_FIRST, E_LAST, E_CAT, E_FROMFILE, E_EVAL, E_LIST,

    80                   E_SPRINTF, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION,

    81                   E_FIND, E_SYSTEM, E_UNIQUE, E_QUOTE, E_ESCAPE_EXPAND,

    82                   E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,

    83                   E_SIZE, E_GENERATE_UID };

    84 QMap<QString, ExpandFunc> qmake_expandFunctions()

    85 {

    86     static QMap<QString, ExpandFunc> *qmake_expand_functions = 0;

    87     if(!qmake_expand_functions) {

    88         qmake_expand_functions = new QMap<QString, ExpandFunc>;

    89         qmakeAddCacheClear(qmakeDeleteCacheClear_QMapStringInt, (void**)&qmake_expand_functions);

    90         qmake_expand_functions->insert("member", E_MEMBER);

    91         qmake_expand_functions->insert("first", E_FIRST);

    92         qmake_expand_functions->insert("last", E_LAST);

    93         qmake_expand_functions->insert("cat", E_CAT);

    94         qmake_expand_functions->insert("fromfile", E_FROMFILE);

    95         qmake_expand_functions->insert("eval", E_EVAL);

    96         qmake_expand_functions->insert("list", E_LIST);

    97         qmake_expand_functions->insert("sprintf", E_SPRINTF);

    98         qmake_expand_functions->insert("join", E_JOIN);

    99         qmake_expand_functions->insert("split", E_SPLIT);

   100         qmake_expand_functions->insert("basename", E_BASENAME);

   101         qmake_expand_functions->insert("dirname", E_DIRNAME);

   102         qmake_expand_functions->insert("section", E_SECTION);

   103         qmake_expand_functions->insert("find", E_FIND);

   104         qmake_expand_functions->insert("system", E_SYSTEM);

   105         qmake_expand_functions->insert("unique", E_UNIQUE);

   106         qmake_expand_functions->insert("quote", E_QUOTE);

   107         qmake_expand_functions->insert("escape_expand", E_ESCAPE_EXPAND);

   108         qmake_expand_functions->insert("upper", E_UPPER);

   109         qmake_expand_functions->insert("lower", E_LOWER);

   110         qmake_expand_functions->insert("re_escape", E_RE_ESCAPE);

   111         qmake_expand_functions->insert("files", E_FILES);

   112         qmake_expand_functions->insert("prompt", E_PROMPT);

   113         qmake_expand_functions->insert("replace", E_REPLACE);

   114         qmake_expand_functions->insert("size", E_SIZE);

   115         qmake_expand_functions->insert("generate_uid", E_GENERATE_UID);

   116     }

   117     return *qmake_expand_functions;

   118 }

   119 //replace functions

   120 enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,

   121                 T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,

   122                 T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,

   123                 T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,

   124                 T_MESSAGE, T_WARNING, T_IF };

   125 QMap<QString, TestFunc> qmake_testFunctions()

   126 {

   127     static QMap<QString, TestFunc> *qmake_test_functions = 0;

   128     if(!qmake_test_functions) {

   129         qmake_test_functions = new QMap<QString, TestFunc>;

   130         qmake_test_functions->insert("requires", T_REQUIRES);

   131         qmake_test_functions->insert("greaterThan", T_GREATERTHAN);

   132         qmake_test_functions->insert("lessThan", T_LESSTHAN);

   133         qmake_test_functions->insert("equals", T_EQUALS);

   134         qmake_test_functions->insert("isEqual", T_EQUALS);

   135         qmake_test_functions->insert("exists", T_EXISTS);

   136         qmake_test_functions->insert("export", T_EXPORT);

   137         qmake_test_functions->insert("clear", T_CLEAR);

   138         qmake_test_functions->insert("unset", T_UNSET);

   139         qmake_test_functions->insert("eval", T_EVAL);

   140         qmake_test_functions->insert("CONFIG", T_CONFIG);

   141         qmake_test_functions->insert("if", T_IF);

   142         qmake_test_functions->insert("isActiveConfig", T_CONFIG);

   143         qmake_test_functions->insert("system", T_SYSTEM);

   144         qmake_test_functions->insert("return", T_RETURN);

   145         qmake_test_functions->insert("break", T_BREAK);

   146         qmake_test_functions->insert("next", T_NEXT);

   147         qmake_test_functions->insert("defined", T_DEFINED);

   148         qmake_test_functions->insert("contains", T_CONTAINS);

   149         qmake_test_functions->insert("infile", T_INFILE);

   150         qmake_test_functions->insert("count", T_COUNT);

   151         qmake_test_functions->insert("isEmpty", T_ISEMPTY);

   152         qmake_test_functions->insert("include", T_INCLUDE);

   153         qmake_test_functions->insert("load", T_LOAD);

   154         qmake_test_functions->insert("debug", T_DEBUG);

   155         qmake_test_functions->insert("error", T_ERROR);

   156         qmake_test_functions->insert("message", T_MESSAGE);

   157         qmake_test_functions->insert("warning", T_WARNING);

   158     }

   159     return *qmake_test_functions;

   160 }

   161 

   162 struct parser_info {

   163     QString file;

   164     int line_no;

   165     bool from_file;

   166 } parser;

   167 

   168 static QString remove_quotes(const QString &arg)

   169 {

   170     const ushort SINGLEQUOTE = '\'';

   171     const ushort DOUBLEQUOTE = '"';

   172 

   173     const QChar *arg_data = arg.data();

   174     const ushort first = arg_data->unicode();

   175     const int arg_len = arg.length();

   176     if(first == SINGLEQUOTE || first == DOUBLEQUOTE) {

   177         const ushort last = (arg_data+arg_len-1)->unicode();

   178         if(last == first)

   179             return arg.mid(1, arg_len-2);

   180     }

   181     return arg;

   182 }

   183 

   184 static QString varMap(const QString &x)

   185 {

   186     QString ret(x);

   187     if(ret.startsWith("TMAKE")) //tmake no more!

   188         ret = "QMAKE" + ret.mid(5);

   189     else if(ret == "INTERFACES")

   190         ret = "FORMS";

   191     else if(ret == "QMAKE_POST_BUILD")

   192         ret = "QMAKE_POST_LINK";

   193     else if(ret == "TARGETDEPS")

   194         ret = "POST_TARGETDEPS";

   195     else if(ret == "LIBPATH")

   196         ret = "QMAKE_LIBDIR";

   197     else if(ret == "QMAKE_EXT_MOC")

   198         ret = "QMAKE_EXT_CPP_MOC";

   199     else if(ret == "QMAKE_MOD_MOC")

   200         ret = "QMAKE_H_MOD_MOC";

   201     else if(ret == "QMAKE_LFLAGS_SHAPP")

   202         ret = "QMAKE_LFLAGS_APP";

   203     else if(ret == "PRECOMPH")

   204         ret = "PRECOMPILED_HEADER";

   205     else if(ret == "PRECOMPCPP")

   206         ret = "PRECOMPILED_SOURCE";

   207     else if(ret == "INCPATH")

   208         ret = "INCLUDEPATH";

   209     else if(ret == "QMAKE_EXTRA_WIN_COMPILERS" || ret == "QMAKE_EXTRA_UNIX_COMPILERS")

   210         ret = "QMAKE_EXTRA_COMPILERS";

   211     else if(ret == "QMAKE_EXTRA_WIN_TARGETS" || ret == "QMAKE_EXTRA_UNIX_TARGETS")

   212         ret = "QMAKE_EXTRA_TARGETS";

   213     else if(ret == "QMAKE_EXTRA_UNIX_INCLUDES")

   214         ret = "QMAKE_EXTRA_INCLUDES";

   215     else if(ret == "QMAKE_EXTRA_UNIX_VARIABLES")

   216         ret = "QMAKE_EXTRA_VARIABLES";

   217     else if(ret == "QMAKE_RPATH")

   218         ret = "QMAKE_LFLAGS_RPATH";

   219     else if(ret == "QMAKE_FRAMEWORKDIR")

   220         ret = "QMAKE_FRAMEWORKPATH";

   221     else if(ret == "QMAKE_FRAMEWORKDIR_FLAGS")

   222         ret = "QMAKE_FRAMEWORKPATH_FLAGS";

   223     return ret;

   224 }

   225 

   226 static QStringList split_arg_list(QString params)

   227 {

   228     int quote = 0;

   229     QStringList args;

   230 

   231     const ushort LPAREN = '(';

   232     const ushort RPAREN = ')';

   233     const ushort SINGLEQUOTE = '\'';

   234     const ushort DOUBLEQUOTE = '"';

   235     const ushort COMMA = ',';

   236     const ushort SPACE = ' ';

   237     //const ushort TAB = '\t';

   238 

   239     ushort unicode;

   240     const QChar *params_data = params.data();

   241     const int params_len = params.length();

   242     int last = 0;

   243     while(last < params_len && (params_data[last].unicode() == SPACE

   244                                 /*|| params_data[last].unicode() == TAB*/))

   245         ++last;

   246     for(int x = last, parens = 0; x <= params_len; x++) {

   247         unicode = params_data[x].unicode();

   248         if(x == params_len) {

   249             while(x && params_data[x-1].unicode() == SPACE)

   250                 --x;

   251             QString mid(params_data+last, x-last);

   252             if(quote) {

   253                 if(mid[0] == quote && mid[(int)mid.length()-1] == quote)

   254                     mid = mid.mid(1, mid.length()-2);

   255                 quote = 0;

   256             }

   257             args << mid;

   258             break;

   259         }

   260         if(unicode == LPAREN) {

   261             --parens;

   262         } else if(unicode == RPAREN) {

   263             ++parens;

   264         } else if(quote && unicode == quote) {

   265             quote = 0;

   266         } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {

   267             quote = unicode;

   268         }

   269         if(!parens && !quote && unicode == COMMA) {

   270             QString mid = params.mid(last, x - last).trimmed();

   271             args << mid;

   272             last = x+1;

   273             while(last < params_len && (params_data[last].unicode() == SPACE

   274                                         /*|| params_data[last].unicode() == TAB*/))

   275                 ++last;

   276         }

   277     }

   278     return args;

   279 }

   280 

   281 static QStringList split_value_list(const QString &vals, bool do_semicolon=false)

   282 {

   283     QString build;

   284     QStringList ret;

   285     QStack<char> quote;

   286 

   287     const ushort LPAREN = '(';

   288     const ushort RPAREN = ')';

   289     const ushort SINGLEQUOTE = '\'';

   290     const ushort DOUBLEQUOTE = '"';

   291     const ushort BACKSLASH = '\\';

   292     const ushort SEMICOLON = ';';

   293 

   294     ushort unicode;

   295     const QChar *vals_data = vals.data();

   296     const int vals_len = vals.length();

   297     for(int x = 0, parens = 0; x < vals_len; x++) {

   298         unicode = vals_data[x].unicode();

   299         if(x != (int)vals_len-1 && unicode == BACKSLASH &&

   300             (vals_data[x+1].unicode() == SINGLEQUOTE || vals_data[x+1].unicode() == DOUBLEQUOTE)) {

   301             build += vals_data[x++]; //get that 'escape'

   302         } else if(!quote.isEmpty() && unicode == quote.top()) {

   303             quote.pop();

   304         } else if(unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE) {

   305             quote.push(unicode);

   306         } else if(unicode == RPAREN) {

   307             --parens;

   308         } else if(unicode == LPAREN) {

   309             ++parens;

   310         }

   311 

   312         if(!parens && quote.isEmpty() && ((do_semicolon && unicode == SEMICOLON) ||

   313                                            vals_data[x] == Option::field_sep)) {

   314             ret << build;

   315             build.clear();

   316         } else {

   317             build += vals_data[x];

   318         }

   319     }

   320     if(!build.isEmpty())

   321         ret << build;

   322     return ret;

   323 }

   324 

   325 //just a parsable entity

   326 struct ParsableBlock

   327 {

   328     ParsableBlock() : ref_cnt(1) { }

   329     virtual ~ParsableBlock() { }

   330 

   331     struct Parse {

   332         QString text;

   333         parser_info pi;

   334         Parse(const QString &t) : text(t){ pi = parser; }

   335     };

   336     QList<Parse> parselist;

   337 

   338     inline int ref() { return ++ref_cnt; }

   339     inline int deref() { return --ref_cnt; }

   340 

   341 protected:

   342     int ref_cnt;

   343     virtual bool continueBlock() = 0;

   344     bool eval(QMakeProject *p, QMap<QString, QStringList> &place);

   345 };

   346 

   347 bool ParsableBlock::eval(QMakeProject *p, QMap<QString, QStringList> &place)

   348 {

   349     //save state

   350     parser_info pi = parser;

   351     const int block_count = p->scope_blocks.count();

   352 

   353     //execute

   354     bool ret = true;

   355     for(int i = 0; i < parselist.count(); i++) {

   356         parser = parselist.at(i).pi;

   357         if(!(ret = p->parse(parselist.at(i).text, place)) || !continueBlock())

   358             break;

   359     }

   360 

   361     //restore state

   362     parser = pi;

   363     while(p->scope_blocks.count() > block_count)

   364         p->scope_blocks.pop();

   365     return ret;

   366 }

   367 

   368 //defined functions

   369 struct FunctionBlock : public ParsableBlock

   370 {

   371     FunctionBlock() : calling_place(0), scope_level(1), cause_return(false) { }

   372 

   373     QMap<QString, QStringList> vars;

   374     QMap<QString, QStringList> *calling_place;

   375     QStringList return_value;

   376     int scope_level;

   377     bool cause_return;

   378 

   379     bool exec(const QList<QStringList> &args,

   380               QMakeProject *p, QMap<QString, QStringList> &place, QStringList &functionReturn);

   381     virtual bool continueBlock() { return !cause_return; }

   382 };

   383 

   384 bool FunctionBlock::exec(const QList<QStringList> &args,

   385                          QMakeProject *proj, QMap<QString, QStringList> &place,

   386                          QStringList &functionReturn)

   387 {

   388     //save state

   389 #if 1

   390     calling_place = &place;

   391 #else

   392     calling_place = &proj->variables();

   393 #endif

   394     return_value.clear();

   395     cause_return = false;

   396 

   397     //execute

   398 #if 0

   399     vars = proj->variables(); // should be place so that local variables can be inherited

   400 #else

   401     vars = place;

   402 #endif

   403     vars["ARGS"].clear();

   404     for(int i = 0; i < args.count(); i++) {

   405         vars["ARGS"] += args[i];

   406         vars[QString::number(i+1)] = args[i];

   407     }

   408     bool ret = ParsableBlock::eval(proj, vars);

   409     functionReturn = return_value;

   410 

   411     //restore state

   412     calling_place = 0;

   413     return_value.clear();

   414     vars.clear();

   415     return ret;

   416 }

   417 

   418 //loops

   419 struct IteratorBlock : public ParsableBlock

   420 {

   421     IteratorBlock() : scope_level(1), loop_forever(false), cause_break(false), cause_next(false) { }

   422 

   423     int scope_level;

   424 

   425     struct Test {

   426         QString func;

   427         QStringList args;

   428         bool invert;

   429         parser_info pi;

   430         Test(const QString &f, QStringList &a, bool i) : func(f), args(a), invert(i) { pi = parser; }

   431     };

   432     QList<Test> test;

   433 

   434     QString variable;

   435 

   436     bool loop_forever, cause_break, cause_next;

   437     QStringList list;

   438 

   439     bool exec(QMakeProject *p, QMap<QString, QStringList> &place);

   440     virtual bool continueBlock() { return !cause_next && !cause_break; }

   441 };

   442 bool IteratorBlock::exec(QMakeProject *p, QMap<QString, QStringList> &place)

   443 {

   444     bool ret = true;

   445     QStringList::Iterator it;

   446     if(!loop_forever)

   447         it = list.begin();

   448     int iterate_count = 0;

   449     //save state

   450     IteratorBlock *saved_iterator = p->iterator;

   451     p->iterator = this;

   452 

   453     //do the loop

   454     while(loop_forever || it != list.end()) {

   455         cause_next = cause_break = false;

   456         if(!loop_forever && (*it).isEmpty()) { //ignore empty items

   457             ++it;

   458             continue;

   459         }

   460 

   461         //set up the loop variable

   462         QStringList va;

   463         if(!variable.isEmpty()) {

   464             va = place[variable];

   465             if(loop_forever)

   466                 place[variable] = QStringList(QString::number(iterate_count));

   467             else

   468                 place[variable] = QStringList(*it);

   469         }

   470         //do the iterations

   471         bool succeed = true;

   472         for(QList<Test>::Iterator test_it = test.begin(); test_it != test.end(); ++test_it) {

   473             parser = (*test_it).pi;

   474             succeed = p->doProjectTest((*test_it).func, (*test_it).args, place);

   475             if((*test_it).invert)

   476                 succeed = !succeed;

   477             if(!succeed)

   478                 break;

   479         }

   480         if(succeed)

   481             ret = ParsableBlock::eval(p, place);

   482         //restore the variable in the map

   483         if(!variable.isEmpty())

   484             place[variable] = va;

   485         //loop counters

   486         if(!loop_forever)

   487             ++it;

   488         iterate_count++;

   489         if(!ret || cause_break)

   490             break;

   491     }

   492 

   493     //restore state

   494     p->iterator = saved_iterator;

   495     return ret;

   496 }

   497 

   498 QMakeProject::ScopeBlock::~ScopeBlock()

   499 {

   500 #if 0

   501     if(iterate)

   502         delete iterate;

   503 #endif

   504 }

   505 

   506 static void qmake_error_msg(const QString &msg)

   507 {

   508     fprintf(stderr, "%s:%d: %s\n", parser.file.toLatin1().constData(), parser.line_no,

   509             msg.toLatin1().constData());

   510 }

   511 

   512 enum isForSymbian_enum {

   513     isForSymbian_NOT_SET = -1,

   514     isForSymbian_FALSE = 0,

   515     isForSymbian_ABLD = 1,

   516     isForSymbian_SBSV2 = 2,

   517 };

   518 

   519 static isForSymbian_enum isForSymbian_value = isForSymbian_NOT_SET;

   520 

   521 // Checking for symbian build is primarily determined from the qmake spec,

   522 // but if that is not specified, detect if symbian is the default spec

   523 // by checking the MAKEFILE_GENERATOR variable value.

   524 static void init_symbian(const QMap<QString, QStringList>& vars)

   525 {

   526     if (isForSymbian_value != isForSymbian_NOT_SET)

   527         return;

   528 

   529     QString spec = QFileInfo(Option::mkfile::qmakespec).fileName();

   530     if (spec.startsWith("symbian-abld", Qt::CaseInsensitive)) {

   531         isForSymbian_value = isForSymbian_ABLD;

   532     } else if (spec.startsWith("symbian-sbsv2", Qt::CaseInsensitive)) {

   533         isForSymbian_value = isForSymbian_SBSV2;

   534     } else {

   535         QStringList generatorList = vars["MAKEFILE_GENERATOR"];

   536 

   537         if (!generatorList.isEmpty()) {

   538             QString generator = generatorList.first();

   539             if (generator.startsWith("SYMBIAN_ABLD"))

   540                 isForSymbian_value = isForSymbian_ABLD;

   541             else if (generator.startsWith("SYMBIAN_SBSV2"))

   542                 isForSymbian_value = isForSymbian_SBSV2;

   543             else

   544                 isForSymbian_value = isForSymbian_FALSE;

   545         } else {

   546             isForSymbian_value = isForSymbian_FALSE;

   547         }

   548     }

   549 

   550     // Force recursive on Symbian, as non-recursive is not really a viable option there

   551     if (isForSymbian_value != isForSymbian_FALSE)

   552         Option::recursive = true;

   553 }

   554 

   555 bool isForSymbian()

   556 {

   557     // If isForSymbian_value has not been initialized explicitly yet,

   558     // call initializer with dummy map to check qmake spec.

   559     if (isForSymbian_value == isForSymbian_NOT_SET)

   560         init_symbian(QMap<QString, QStringList>());

   561 

   562     return (isForSymbian_value != isForSymbian_FALSE);

   563 }

   564 

   565 bool isForSymbianSbsv2()

   566 {

   567     // If isForSymbian_value has not been initialized explicitly yet,

   568     // call initializer with dummy map to check qmake spec.

   569     if (isForSymbian_value == isForSymbian_NOT_SET)

   570         init_symbian(QMap<QString, QStringList>());

   571 

   572     return (isForSymbian_value == isForSymbian_SBSV2);

   573 }

   574 

   575 /*

   576    1) environment variable QMAKEFEATURES (as separated by colons)

   577    2) property variable QMAKEFEATURES (as separated by colons)

   578    3) <project_root> (where .qmake.cache lives) + FEATURES_DIR

   579    4) environment variable QMAKEPATH (as separated by colons) + /mkspecs/FEATURES_DIR

   580    5) your QMAKESPEC/features dir

   581    6) your data_install/mkspecs/FEATURES_DIR

   582    7) your QMAKESPEC/../FEATURES_DIR dir

   583 

   584    FEATURES_DIR is defined as:

   585 

   586    1) features/(unix|win32|macx)/

   587    2) features/

   588 */

   589 QStringList qmake_feature_paths(QMakeProperty *prop=0)

   590 {

   591     QStringList concat;

   592     {

   593         const QString base_concat = QDir::separator() + QString("features");

   594         switch(Option::target_mode) {

   595         case Option::TARG_MACX_MODE:                     //also a unix

   596             concat << base_concat + QDir::separator() + "mac";

   597             concat << base_concat + QDir::separator() + "macx";

   598             concat << base_concat + QDir::separator() + "unix";

   599             break;

   600         case Option::TARG_UNIX_MODE:

   601             {

   602                 if (isForSymbian())

   603                     concat << base_concat + QDir::separator() + "symbian";

   604                 else

   605                     concat << base_concat + QDir::separator() + "unix";

   606                 break;

   607             }

   608         case Option::TARG_WIN_MODE:

   609             {

   610                 if (isForSymbian())

   611                     concat << base_concat + QDir::separator() + "symbian";

   612                 else

   613                     concat << base_concat + QDir::separator() + "win32";

   614                 break;

   615             }

   616         case Option::TARG_MAC9_MODE:

   617             concat << base_concat + QDir::separator() + "mac";

   618             concat << base_concat + QDir::separator() + "mac9";

   619             break;

   620         }

   621         concat << base_concat;

   622     }

   623     const QString mkspecs_concat = QDir::separator() + QString("mkspecs");

   624     QStringList feature_roots;

   625     QByteArray mkspec_path = qgetenv("QMAKEFEATURES");

   626     if(!mkspec_path.isNull())

   627         feature_roots += splitPathList(QString::fromLocal8Bit(mkspec_path));

   628     if(prop)

   629         feature_roots += splitPathList(prop->value("QMAKEFEATURES"));

   630     if(!Option::mkfile::cachefile.isEmpty()) {

   631         QString path;

   632         int last_slash = Option::mkfile::cachefile.lastIndexOf(Option::dir_sep);

   633         if(last_slash != -1)

   634             path = Option::fixPathToLocalOS(Option::mkfile::cachefile.left(last_slash));

   635         for(QStringList::Iterator concat_it = concat.begin();

   636             concat_it != concat.end(); ++concat_it)

   637             feature_roots << (path + (*concat_it));

   638     }

   639     QByteArray qmakepath = qgetenv("QMAKEPATH");

   640     if (!qmakepath.isNull()) {

   641         const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));

   642         for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it) {

   643             for(QStringList::Iterator concat_it = concat.begin();

   644                 concat_it != concat.end(); ++concat_it)

   645                     feature_roots << ((*it) + mkspecs_concat + (*concat_it));

   646         }

   647     }

   648     if(!Option::mkfile::qmakespec.isEmpty())

   649         feature_roots << Option::mkfile::qmakespec + QDir::separator() + "features";

   650     if(!Option::mkfile::qmakespec.isEmpty()) {

   651         QFileInfo specfi(Option::mkfile::qmakespec);

   652         QDir specdir(specfi.absoluteFilePath());

   653         while(!specdir.isRoot()) {

   654             if(!specdir.cdUp() || specdir.isRoot())

   655                 break;

   656             if(QFile::exists(specdir.path() + QDir::separator() + "features")) {

   657                 for(QStringList::Iterator concat_it = concat.begin();

   658                     concat_it != concat.end(); ++concat_it)

   659                     feature_roots << (specdir.path() + (*concat_it));

   660                 break;

   661             }

   662         }

   663     }

   664     for(QStringList::Iterator concat_it = concat.begin();

   665         concat_it != concat.end(); ++concat_it)

   666         feature_roots << (QLibraryInfo::location(QLibraryInfo::PrefixPath) +

   667                           mkspecs_concat + (*concat_it));

   668     for(QStringList::Iterator concat_it = concat.begin();

   669         concat_it != concat.end(); ++concat_it)

   670         feature_roots << (QLibraryInfo::location(QLibraryInfo::DataPath) +

   671                           mkspecs_concat + (*concat_it));

   672     return feature_roots;

   673 }

   674 

   675 QStringList qmake_mkspec_paths()

   676 {

   677     QStringList ret;

   678     const QString concat = QDir::separator() + QString("mkspecs");

   679     QByteArray qmakepath = qgetenv("QMAKEPATH");

   680     if (!qmakepath.isEmpty()) {

   681         const QStringList lst = splitPathList(QString::fromLocal8Bit(qmakepath));

   682         for(QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it)

   683             ret << ((*it) + concat);

   684     }

   685     ret << QLibraryInfo::location(QLibraryInfo::DataPath) + concat;

   686 

   687     return ret;

   688 }

   689 

   690 class QMakeProjectEnv

   691 {

   692     QStringList envs;

   693 public:

   694     QMakeProjectEnv() { }

   695     QMakeProjectEnv(QMakeProject *p) { execute(p->variables()); }

   696     QMakeProjectEnv(const QMap<QString, QStringList> &values) { execute(values); }

   697 

   698     void execute(QMakeProject *p) { execute(p->variables()); }

   699     void execute(const QMap<QString, QStringList> &values) {

   700 #ifdef Q_OS_UNIX

   701         for(QMap<QString, QStringList>::ConstIterator it = values.begin(); it != values.end(); ++it) {

   702             const QString var = it.key(), val = it.value().join(" ");

   703             if(!var.startsWith(".")) {

   704                 const QString env_var = Option::sysenv_mod + var;

   705                 if(!putenv(strdup(QString(env_var + "=" + val).toAscii().data())))

   706                     envs.append(env_var);

   707             }

   708         }

   709 #else

   710         Q_UNUSED(values);

   711 #endif

   712     }

   713     ~QMakeProjectEnv() {

   714 #ifdef Q_OS_UNIX

   715         for(QStringList::ConstIterator it = envs.begin();it != envs.end(); ++it) {

   716             putenv(strdup(QString(*it + "=").toAscii().data()));

   717         }

   718 #endif

   719     }

   720 };

   721 

   722 QMakeProject::~QMakeProject()

   723 {

   724     if(own_prop)

   725         delete prop;

   726     for(QMap<QString, FunctionBlock*>::iterator it = replaceFunctions.begin(); it != replaceFunctions.end(); ++it) {

   727         if(!it.value()->deref())

   728             delete it.value();

   729     }

   730     replaceFunctions.clear();

   731     for(QMap<QString, FunctionBlock*>::iterator it = testFunctions.begin(); it != testFunctions.end(); ++it) {

   732         if(!it.value()->deref())

   733             delete it.value();

   734     }

   735     testFunctions.clear();

   736 }

   737 

   738 

   739 void

   740 QMakeProject::init(QMakeProperty *p, const QMap<QString, QStringList> *vars)

   741 {

   742     if(vars)

   743         base_vars = *vars;

   744     if(!p) {

   745         prop = new QMakeProperty;

   746         own_prop = true;

   747     } else {

   748         prop = p;

   749         own_prop = false;

   750     }

   751     reset();

   752 }

   753 

   754 QMakeProject::QMakeProject(QMakeProject *p, const QMap<QString, QStringList> *vars)

   755 {

   756     init(p->properties(), vars ? vars : &p->variables());

   757     for(QMap<QString, FunctionBlock*>::iterator it = p->replaceFunctions.begin(); it != p->replaceFunctions.end(); ++it) {

   758         it.value()->ref();

   759         replaceFunctions.insert(it.key(), it.value());

   760     }

   761     for(QMap<QString, FunctionBlock*>::iterator it = p->testFunctions.begin(); it != p->testFunctions.end(); ++it) {

   762         it.value()->ref();

   763         testFunctions.insert(it.key(), it.value());

   764     }

   765 }

   766 

   767 void

   768 QMakeProject::reset()

   769 {

   770     // scope_blocks starts with one non-ignoring entity

   771     scope_blocks.clear();

   772     scope_blocks.push(ScopeBlock());

   773     iterator = 0;

   774     function = 0;

   775 }

   776 

   777 bool

   778 QMakeProject::parse(const QString &t, QMap<QString, QStringList> &place, int numLines)

   779 {

   780     QString s = t.simplified();

   781     int hash_mark = s.indexOf("#");

   782     if(hash_mark != -1) //good bye comments

   783         s = s.left(hash_mark);

   784     if(s.isEmpty()) // blank_line

   785         return true;

   786 

   787     if(scope_blocks.top().ignore) {

   788         bool continue_parsing = false;

   789         // adjust scope for each block which appears on a single line

   790         for(int i = 0; i < s.length(); i++) {

   791             if(s[i] == '{') {

   792                 scope_blocks.push(ScopeBlock(true));

   793             } else if(s[i] == '}') {

   794                 if(scope_blocks.count() == 1) {

   795                     fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);

   796                     return false;

   797                 }

   798                 ScopeBlock sb = scope_blocks.pop();

   799                 if(sb.iterate) {

   800                     sb.iterate->exec(this, place);

   801                     delete sb.iterate;

   802                     sb.iterate = 0;

   803                 }

   804                 if(!scope_blocks.top().ignore) {

   805                     debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),

   806                               parser.line_no, scope_blocks.count()+1);

   807                     s = s.mid(i+1).trimmed();

   808                     continue_parsing = !s.isEmpty();

   809                     break;

   810                 }

   811             }

   812         }

   813         if(!continue_parsing) {

   814             debug_msg(1, "Project Parser: %s:%d : Ignored due to block being false.",

   815                       parser.file.toLatin1().constData(), parser.line_no);

   816             return true;

   817         }

   818     }

   819 

   820     if(function) {

   821         QString append;

   822         int d_off = 0;

   823         const QChar *d = s.unicode();

   824         bool function_finished = false;

   825         while(d_off < s.length()) {

   826             if(*(d+d_off) == QLatin1Char('}')) {

   827                 function->scope_level--;

   828                 if(!function->scope_level) {

   829                     function_finished = true;

   830                     break;

   831                 }

   832             } else if(*(d+d_off) == QLatin1Char('{')) {

   833                 function->scope_level++;

   834             }

   835             append += *(d+d_off);

   836             ++d_off;

   837         }

   838         if(!append.isEmpty())

   839             function->parselist.append(IteratorBlock::Parse(append));

   840         if(function_finished) {

   841             function = 0;

   842             s = QString(d+d_off, s.length()-d_off);

   843         } else {

   844             return true;

   845         }

   846     } else if(IteratorBlock *it = scope_blocks.top().iterate) {

   847         QString append;

   848         int d_off = 0;

   849         const QChar *d = s.unicode();

   850         bool iterate_finished = false;

   851         while(d_off < s.length()) {

   852             if(*(d+d_off) == QLatin1Char('}')) {

   853                 it->scope_level--;

   854                 if(!it->scope_level) {

   855                     iterate_finished = true;

   856                     break;

   857                 }

   858             } else if(*(d+d_off) == QLatin1Char('{')) {

   859                 it->scope_level++;

   860             }

   861             append += *(d+d_off);

   862             ++d_off;

   863         }

   864         if(!append.isEmpty())

   865             scope_blocks.top().iterate->parselist.append(IteratorBlock::Parse(append));

   866         if(iterate_finished) {

   867             scope_blocks.top().iterate = 0;

   868             bool ret = it->exec(this, place);

   869             delete it;

   870             if(!ret)

   871                 return false;

   872             s = s.mid(d_off);

   873         } else {

   874             return true;

   875         }

   876     }

   877 

   878     QString scope, var, op;

   879     QStringList val;

   880 #define SKIP_WS(d, o, l) while(o < l && (*(d+o) == QLatin1Char(' ') || *(d+o) == QLatin1Char('\t'))) ++o

   881     const QChar *d = s.unicode();

   882     int d_off = 0;

   883     SKIP_WS(d, d_off, s.length());

   884     IteratorBlock *iterator = 0;

   885     bool scope_failed = false, else_line = false, or_op=false;

   886     QChar quote = 0;

   887     int parens = 0, scope_count=0, start_block = 0;

   888     while(d_off < s.length()) {

   889         if(!parens) {

   890             if(*(d+d_off) == QLatin1Char('='))

   891                 break;

   892             if(*(d+d_off) == QLatin1Char('+') || *(d+d_off) == QLatin1Char('-') ||

   893                *(d+d_off) == QLatin1Char('*') || *(d+d_off) == QLatin1Char('~')) {

   894                 if(*(d+d_off+1) == QLatin1Char('=')) {

   895                     break;

   896                 } else if(*(d+d_off+1) == QLatin1Char(' ')) {

   897                     const QChar *k = d+d_off+1;

   898                     int k_off = 0;

   899                     SKIP_WS(k, k_off, s.length()-d_off);

   900                     if(*(k+k_off) == QLatin1Char('=')) {

   901                         QString msg;

   902                         qmake_error_msg(QString(d+d_off, 1) + "must be followed immediately by =");

   903                         return false;

   904                     }

   905                 }

   906             }

   907         }

   908 

   909         if(!quote.isNull()) {

   910             if(*(d+d_off) == quote)

   911                 quote = QChar();

   912         } else if(*(d+d_off) == '(') {

   913             ++parens;

   914         } else if(*(d+d_off) == ')') {

   915             --parens;

   916         } else if(*(d+d_off) == '"' /*|| *(d+d_off) == '\''*/) {

   917             quote = *(d+d_off);

   918         }

   919 

   920         if(!parens && quote.isNull() &&

   921            (*(d+d_off) == QLatin1Char(':') || *(d+d_off) == QLatin1Char('{') ||

   922             *(d+d_off) == QLatin1Char(')') || *(d+d_off) == QLatin1Char('|'))) {

   923             scope_count++;

   924             scope = var.trimmed();

   925             if(*(d+d_off) == QLatin1Char(')'))

   926                 scope += *(d+d_off); // need this

   927             var = "";

   928 

   929             bool test = scope_failed;

   930             if(scope.isEmpty()) {

   931                 test = true;

   932             } else if(scope.toLower() == "else") { //else is a builtin scope here as it modifies state

   933                 if(scope_count != 1 || scope_blocks.top().else_status == ScopeBlock::TestNone) {

   934                     qmake_error_msg(("Unexpected " + scope + " ('" + s + "')").toLatin1());

   935                     return false;

   936                 }

   937                 else_line = true;

   938                 test = (scope_blocks.top().else_status == ScopeBlock::TestSeek);

   939                 debug_msg(1, "Project Parser: %s:%d : Else%s %s.", parser.file.toLatin1().constData(), parser.line_no,

   940                           scope == "else" ? "" : QString(" (" + scope + ")").toLatin1().constData(),

   941                           test ? "considered" : "excluded");

   942             } else {

   943                 QString comp_scope = scope;

   944                 bool invert_test = (comp_scope.at(0) == QLatin1Char('!'));

   945                 if(invert_test)

   946                     comp_scope = comp_scope.mid(1);

   947                 int lparen = comp_scope.indexOf('(');

   948                 if(or_op == scope_failed) {

   949                     if(lparen != -1) { // if there is an lparen in the scope, it IS a function

   950                         int rparen = comp_scope.lastIndexOf(')');

   951                         if(rparen == -1) {

   952                             qmake_error_msg("Function missing right paren: " + comp_scope);

   953                             return false;

   954                         }

   955                         QString func = comp_scope.left(lparen);

   956                         QStringList args = split_arg_list(comp_scope.mid(lparen+1, rparen - lparen - 1));

   957                         if(function) {

   958                             fprintf(stderr, "%s:%d: No tests can come after a function definition!\n",

   959                                     parser.file.toLatin1().constData(), parser.line_no);

   960                             return false;

   961                         } else if(func == "for") { //for is a builtin function here, as it modifies state

   962                             if(args.count() > 2 || args.count() < 1) {

   963                                 fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",

   964                                         parser.file.toLatin1().constData(), parser.line_no);

   965                                 return false;

   966                             } else if(iterator) {

   967                                 fprintf(stderr, "%s:%d unexpected nested for()\n",

   968                                         parser.file.toLatin1().constData(), parser.line_no);

   969                                 return false;

   970                             }

   971 

   972                             iterator = new IteratorBlock;

   973                             QString it_list;

   974                             if(args.count() == 1) {

   975                                 doVariableReplace(args[0], place);

   976                                 it_list = args[0];

   977                                 if(args[0] != "ever") {

   978                                     delete iterator;

   979                                     iterator = 0;

   980                                     fprintf(stderr, "%s:%d: for(iterate, list) requires two arguments.\n",

   981                                             parser.file.toLatin1().constData(), parser.line_no);

   982                                     return false;

   983                                 }

   984                                 it_list = "forever";

   985                             } else if(args.count() == 2) {

   986                                 iterator->variable = args[0];

   987                                 doVariableReplace(args[1], place);

   988                                 it_list = args[1];

   989                             }

   990                             QStringList list = place[it_list];

   991                             if(list.isEmpty()) {

   992                                 if(it_list == "forever") {

   993                                     iterator->loop_forever = true;

   994                                 } else {

   995                                     int dotdot = it_list.indexOf("..");

   996                                     if(dotdot != -1) {

   997                                         bool ok;

   998                                         int start = it_list.left(dotdot).toInt(&ok);

   999                                         if(ok) {

  1000                                             int end = it_list.mid(dotdot+2).toInt(&ok);

  1001                                             if(ok) {

  1002                                                 if(start < end) {

  1003                                                     for(int i = start; i <= end; i++)

  1004                                                         list << QString::number(i);

  1005                                                 } else {

  1006                                                     for(int i = start; i >= end; i--)

  1007                                                         list << QString::number(i);

  1008                                                 }

  1009                                             }

  1010                                         }

  1011                                     }

  1012                                 }

  1013                             }

  1014                             iterator->list = list;

  1015                             test = !invert_test;

  1016                         } else if(iterator) {

  1017                             iterator->test.append(IteratorBlock::Test(func, args, invert_test));

  1018                             test = !invert_test;

  1019                         } else if(func == "defineTest" || func == "defineReplace") {

  1020                             if(!function_blocks.isEmpty()) {

  1021                                 fprintf(stderr,

  1022                                         "%s:%d: cannot define a function within another definition.\n",

  1023                                         parser.file.toLatin1().constData(), parser.line_no);

  1024                                 return false;

  1025                             }

  1026                             if(args.count() != 1) {

  1027                                 fprintf(stderr, "%s:%d: %s(function_name) requires one argument.\n",

  1028                                         parser.file.toLatin1().constData(), parser.line_no, func.toLatin1().constData());

  1029                                 return false;

  1030                             }

  1031                             QMap<QString, FunctionBlock*> *map = 0;

  1032                             if(func == "defineTest")

  1033                                 map = &testFunctions;

  1034                             else

  1035                                 map = &replaceFunctions;

  1036 #if 0

  1037                             if(!map || map->contains(args[0])) {

  1038                                 fprintf(stderr, "%s:%d: Function[%s] multiply defined.\n",

  1039                                         parser.file.toLatin1().constData(), parser.line_no, args[0].toLatin1().constData());

  1040                                 return false;

  1041                             }

  1042 #endif

  1043                             function = new FunctionBlock;

  1044                             map->insert(args[0], function);

  1045                             test = true;

  1046                         } else {

  1047                             test = doProjectTest(func, args, place);

  1048                             if(*(d+d_off) == QLatin1Char(')') && d_off == s.length()-1) {

  1049                                 if(invert_test)

  1050                                     test = !test;

  1051                                 scope_blocks.top().else_status =

  1052                                     (test ? ScopeBlock::TestFound : ScopeBlock::TestSeek);

  1053                                 return true;  // assume we are done

  1054                             }

  1055                         }

  1056                     } else {

  1057                         QString cscope = comp_scope.trimmed();

  1058                         doVariableReplace(cscope, place);

  1059                         test = isActiveConfig(cscope.trimmed(), true, &place);

  1060                     }

  1061                     if(invert_test)

  1062                         test = !test;

  1063                 }

  1064             }

  1065             if(!test && !scope_failed)

  1066                 debug_msg(1, "Project Parser: %s:%d : Test (%s) failed.", parser.file.toLatin1().constData(),

  1067                           parser.line_no, scope.toLatin1().constData());

  1068             if(test == or_op)

  1069                 scope_failed = !test;

  1070             or_op = (*(d+d_off) == QLatin1Char('|'));

  1071 

  1072             if(*(d+d_off) == QLatin1Char('{')) { // scoping block

  1073                 start_block++;

  1074                 if(iterator) {

  1075                     for(int off = 0, braces = 0; true; ++off) {

  1076                         if(*(d+d_off+off) == QLatin1Char('{'))

  1077                             ++braces;

  1078                         else if(*(d+d_off+off) == QLatin1Char('}') && braces)

  1079                             --braces;

  1080                         if(!braces || d_off+off == s.length()) {

  1081                             iterator->parselist.append(s.mid(d_off, off-1));

  1082                             if(braces > 1)

  1083                                 iterator->scope_level += braces-1;

  1084                             d_off += off-1;

  1085                             break;

  1086                         }

  1087                     }

  1088                 }

  1089             }

  1090         } else if(!parens && *(d+d_off) == QLatin1Char('}')) {

  1091             if(start_block) {

  1092                 --start_block;

  1093             } else if(!scope_blocks.count()) {

  1094                 warn_msg(WarnParser, "Possible braces mismatch %s:%d", parser.file.toLatin1().constData(), parser.line_no);

  1095             } else {

  1096                 if(scope_blocks.count() == 1) {

  1097                     fprintf(stderr, "Braces mismatch %s:%d\n", parser.file.toLatin1().constData(), parser.line_no);

  1098                     return false;

  1099                 }

  1100                 debug_msg(1, "Project Parser: %s:%d : Leaving block %d", parser.file.toLatin1().constData(),

  1101                           parser.line_no, scope_blocks.count());

  1102                 ScopeBlock sb = scope_blocks.pop();

  1103                 if(sb.iterate)

  1104                     sb.iterate->exec(this, place);

  1105             }

  1106         } else {

  1107             var += *(d+d_off);

  1108         }

  1109         ++d_off;

  1110     }

  1111     var = var.trimmed();

  1112 

  1113     if(!else_line || (else_line && !scope_failed))

  1114         scope_blocks.top().else_status = (!scope_failed ? ScopeBlock::TestFound : ScopeBlock::TestSeek);

  1115     if(start_block) {

  1116         ScopeBlock next_block(scope_failed);

  1117         next_block.iterate = iterator;

  1118         if(iterator)

  1119             next_block.else_status = ScopeBlock::TestNone;

  1120         else if(scope_failed)

  1121             next_block.else_status = ScopeBlock::TestSeek;

  1122         else

  1123             next_block.else_status = ScopeBlock::TestFound;

  1124         scope_blocks.push(next_block);

  1125         debug_msg(1, "Project Parser: %s:%d : Entering block %d (%d). [%s]", parser.file.toLatin1().constData(),

  1126                   parser.line_no, scope_blocks.count(), scope_failed, s.toLatin1().constData());

  1127     } else if(iterator) {

  1128         iterator->parselist.append(var+s.mid(d_off));

  1129         bool ret = iterator->exec(this, place);

  1130         delete iterator;

  1131         return ret;

  1132     }

  1133 

  1134     if((!scope_count && !var.isEmpty()) || (scope_count == 1 && else_line))

  1135         scope_blocks.top().else_status = ScopeBlock::TestNone;