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

     2 **

     3 ** Copyright (C) 2009 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 Qt Linguist 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 "profileevaluator.h"

    43 #include "proparserutils.h"

    44 #include "proitems.h"

    45 

    46 #include <QtCore/QByteArray>

    47 #include <QtCore/QDateTime>

    48 #include <QtCore/QDebug>

    49 #include <QtCore/QDir>

    50 #include <QtCore/QFile>

    51 #include <QtCore/QFileInfo>

    52 #include <QtCore/QList>

    53 #include <QtCore/QRegExp>

    54 #include <QtCore/QSet>

    55 #include <QtCore/QStack>

    56 #include <QtCore/QString>

    57 #include <QtCore/QStringList>

    58 #include <QtCore/QTextStream>

    59 

    60 #ifdef Q_OS_UNIX

    61 #include <unistd.h>

    62 #include <sys/utsname.h>

    63 #else

    64 #include <Windows.h>

    65 #endif

    66 #include <stdio.h>

    67 #include <stdlib.h>

    68 

    69 #ifdef Q_OS_WIN32

    70 #define QT_POPEN _popen

    71 #define QT_PCLOSE _pclose

    72 #else

    73 #define QT_POPEN popen

    74 #define QT_PCLOSE pclose

    75 #endif

    76 

    77 QT_BEGIN_NAMESPACE

    78 

    79 ///////////////////////////////////////////////////////////////////////

    80 //

    81 // Option

    82 //

    83 ///////////////////////////////////////////////////////////////////////

    84 

    85 QString

    86 Option::fixString(QString string, uchar flags)

    87 {

    88     // XXX Ripped out caching, so this will be slow. Should not matter for current uses.

    89 

    90     //fix the environment variables

    91     if (flags & Option::FixEnvVars) {

    92         int rep;

    93         QRegExp reg_variableName(QLatin1String("\\$\\(.*\\)"));

    94         reg_variableName.setMinimal(true);

    95         while ((rep = reg_variableName.indexIn(string)) != -1)

    96             string.replace(rep, reg_variableName.matchedLength(),

    97                            QString::fromLocal8Bit(qgetenv(string.mid(rep + 2, reg_variableName.matchedLength() - 3).toLatin1().constData()).constData()));

    98     }

    99 

   100     //canonicalize it (and treat as a path)

   101     if (flags & Option::FixPathCanonicalize) {

   102 #if 0

   103         string = QFileInfo(string).canonicalFilePath();

   104 #endif

   105         string = QDir::cleanPath(string);

   106     }

   107 

   108     if (string.length() > 2 && string[0].isLetter() && string[1] == QLatin1Char(':'))

   109         string[0] = string[0].toLower();

   110 

   111     //fix separators

   112     Q_ASSERT(!((flags & Option::FixPathToLocalSeparators) && (flags & Option::FixPathToTargetSeparators)));

   113     if (flags & Option::FixPathToLocalSeparators) {

   114 #if defined(Q_OS_WIN32)

   115         string = string.replace(QLatin1Char('/'), QLatin1Char('\\'));

   116 #else

   117         string = string.replace(QLatin1Char('\\'), QLatin1Char('/'));

   118 #endif

   119     } else if (flags & Option::FixPathToTargetSeparators) {

   120         string = string.replace(QLatin1Char('/'), Option::dir_sep)

   121                        .replace(QLatin1Char('\\'), Option::dir_sep);

   122     }

   123 

   124     if ((string.startsWith(QLatin1Char('"')) && string.endsWith(QLatin1Char('"'))) ||

   125         (string.startsWith(QLatin1Char('\'')) && string.endsWith(QLatin1Char('\''))))

   126         string = string.mid(1, string.length() - 2);

   127 

   128     return string;

   129 }

   130 

   131 ///////////////////////////////////////////////////////////////////////

   132 //

   133 // ProFileEvaluator::Private

   134 //

   135 ///////////////////////////////////////////////////////////////////////

   136 

   137 class ProFileEvaluator::Private : public AbstractProItemVisitor

   138 {

   139 public:

   140     Private(ProFileEvaluator *q_);

   141 

   142     ProFileEvaluator *q;

   143     int m_lineNo;                                   // Error reporting

   144     bool m_verbose;

   145 

   146     /////////////// Reading pro file

   147 

   148     bool read(ProFile *pro);

   149 

   150     ProBlock *currentBlock();

   151     void updateItem();

   152     bool parseLine(const QString &line);

   153     void insertVariable(const QString &line, int *i);

   154     void insertOperator(const char op);

   155     void insertComment(const QString &comment);

   156     void enterScope(bool multiLine);

   157     void leaveScope();

   158     void finalizeBlock();

   159 

   160     QStack<ProBlock *> m_blockstack;

   161     ProBlock *m_block;

   162 

   163     ProItem *m_commentItem;

   164     QString m_proitem;

   165     QString m_pendingComment;

   166     bool m_syntaxError;

   167     bool m_contNextLine;

   168     bool m_inQuote;

   169     int m_parens;

   170 

   171     /////////////// Evaluating pro file contents

   172 

   173     // implementation of AbstractProItemVisitor

   174     ProItem::ProItemReturn visitBeginProBlock(ProBlock *block);

   175     void visitEndProBlock(ProBlock *block);

   176     ProItem::ProItemReturn visitProLoopIteration();

   177     void visitProLoopCleanup();

   178     void visitBeginProVariable(ProVariable *variable);

   179     void visitEndProVariable(ProVariable *variable);

   180     ProItem::ProItemReturn visitBeginProFile(ProFile *value);

   181     ProItem::ProItemReturn visitEndProFile(ProFile *value);

   182     void visitProValue(ProValue *value);

   183     ProItem::ProItemReturn visitProFunction(ProFunction *function);

   184     void visitProOperator(ProOperator *oper);

   185     void visitProCondition(ProCondition *condition);

   186 

   187     QStringList valuesDirect(const QString &variableName) const { return m_valuemap[variableName]; }

   188     QStringList values(const QString &variableName) const;

   189     QStringList values(const QString &variableName, const ProFile *pro) const;

   190     QStringList values(const QString &variableName, const QHash<QString, QStringList> &place,

   191                        const ProFile *pro) const;

   192     QString propertyValue(const QString &val) const;

   193 

   194     bool isActiveConfig(const QString &config, bool regex = false);

   195     QStringList expandVariableReferences(const QString &value);

   196     void doVariableReplace(QString *str);

   197     QStringList evaluateExpandFunction(const QString &function, const QString &arguments);

   198     QString format(const char *format) const;

   199 

   200     QString currentFileName() const;

   201     QString currentDirectory() const;

   202     ProFile *currentProFile() const;

   203 

   204     ProItem::ProItemReturn evaluateConditionalFunction(const QString &function, const QString &arguments);

   205     bool evaluateFile(const QString &fileName);

   206     bool evaluateFeatureFile(const QString &fileName);

   207 

   208     static inline ProItem::ProItemReturn returnBool(bool b)

   209         { return b ? ProItem::ReturnTrue : ProItem::ReturnFalse; }

   210 

   211     QStringList evaluateFunction(ProBlock *funcPtr, const QStringList &argumentsList, bool *ok);

   212 

   213     QStringList qmakeFeaturePaths();

   214 

   215     struct State {

   216         bool condition;

   217         bool prevCondition;

   218     } m_sts;

   219     bool m_invertNext; // Short-lived, so not in State

   220     int m_skipLevel;

   221     bool m_cumulative;

   222     bool m_isFirstVariableValue;

   223     QString m_lastVarName;

   224     ProVariable::VariableOperator m_variableOperator;

   225     QString m_origfile;

   226     QString m_oldPath;                              // To restore the current path to the path

   227     QStack<ProFile*> m_profileStack;                // To handle 'include(a.pri), so we can track back to 'a.pro' when finished with 'a.pri'

   228     struct ProLoop {

   229         QString variable;

   230         QStringList oldVarVal;

   231         QStringList list;

   232         int index;

   233         bool infinite;

   234     };

   235     QStack<ProLoop> m_loopStack;

   236 

   237     // we need the following two variables for handling

   238     // CONFIG = foo bar $$CONFIG

   239     QHash<QString, QStringList> m_tempValuemap;         // used while evaluating (variable operator value1 value2 ...)

   240     QHash<const ProFile*, QHash<QString, QStringList> > m_tempFilevaluemap; // used while evaluating (variable operator value1 value2 ...)

   241 

   242     QHash<QString, QStringList> m_valuemap;         // VariableName must be us-ascii, the content however can be non-us-ascii.

   243     QHash<const ProFile*, QHash<QString, QStringList> > m_filevaluemap; // Variables per include file

   244     QHash<QString, QString> m_properties;

   245     QString m_outputDir;

   246 

   247     bool m_definingTest;

   248     QString m_definingFunc;

   249     QHash<QString, ProBlock *> m_testFunctions;

   250     QHash<QString, ProBlock *> m_replaceFunctions;

   251     QStringList m_returnValue;

   252     QStack<QHash<QString, QStringList> > m_valuemapStack;

   253     QStack<QHash<const ProFile*, QHash<QString, QStringList> > > m_filevaluemapStack;

   254 

   255     int m_prevLineNo;                               // Checking whether we're assigning the same TARGET

   256     ProFile *m_prevProFile;                         // See m_prevLineNo

   257 };

   258 

   259 Q_DECLARE_TYPEINFO(ProFileEvaluator::Private::State, Q_PRIMITIVE_TYPE);

   260 Q_DECLARE_TYPEINFO(ProFileEvaluator::Private::ProLoop, Q_MOVABLE_TYPE);

   261 

   262 ProFileEvaluator::Private::Private(ProFileEvaluator *q_)

   263   : q(q_)

   264 {

   265     // Global parser state

   266     m_prevLineNo = 0;

   267     m_prevProFile = 0;

   268 

   269     // Configuration, more or less

   270     m_verbose = true;

   271     m_cumulative = true;

   272 

   273     // Evaluator state

   274     m_sts.condition = false;

   275     m_sts.prevCondition = false;

   276     m_invertNext = false;

   277     m_skipLevel = 0;

   278     m_isFirstVariableValue = true;

   279     m_definingFunc.clear();

   280 }

   281 

   282 bool ProFileEvaluator::Private::read(ProFile *pro)

   283 {

   284     QFile file(pro->fileName());

   285     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {

   286         q->errorMessage(format("%1 not readable.").arg(pro->fileName()));

   287         return false;

   288     }

   289 

   290     // Parser state

   291     m_block = 0;

   292     m_commentItem = 0;

   293     m_inQuote = false;

   294     m_parens = 0;

   295     m_contNextLine = false;

   296     m_syntaxError = false;

   297     m_lineNo = 1;

   298     m_blockstack.clear();

   299     m_blockstack.push(pro);

   300 

   301     QTextStream ts(&file);

   302     while (!ts.atEnd()) {

   303         QString line = ts.readLine();

   304         if (!parseLine(line)) {

   305             q->errorMessage(format(".pro parse failure."));

   306             return false;

   307         }

   308         ++m_lineNo;

   309     }

   310     return true;

   311 }

   312 

   313 bool ProFileEvaluator::Private::parseLine(const QString &line0)

   314 {

   315     if (m_blockstack.isEmpty())

   316         return false;

   317 

   318     int parens = m_parens;

   319     bool inQuote = m_inQuote;

   320     bool escaped = false;

   321     QString line = line0.simplified();

   322 

   323     for (int i = 0; !m_syntaxError && i < line.length(); ++i) {

   324         ushort c = line.at(i).unicode();

   325         if (c == '#') { // Yep - no escaping possible

   326             insertComment(line.mid(i + 1));

   327             escaped = m_contNextLine;

   328             break;

   329         }

   330         if (!escaped) {

   331             if (c == '\\') {

   332                 escaped = true;

   333                 m_proitem += c;

   334                 continue;

   335             } else if (c == '"') {

   336                 inQuote = !inQuote;

   337                 m_proitem += c;

   338                 continue;

   339             }

   340         } else {

   341             escaped = false;

   342         }

   343         if (!inQuote) {

   344             if (c == '(') {

   345                 ++parens;

   346             } else if (c == ')') {

   347                 --parens;

   348             } else if (!parens) {

   349                 if (m_block && (m_block->blockKind() & ProBlock::VariableKind)) {

   350                     if (c == ' ')

   351                         updateItem();

   352                     else

   353                         m_proitem += c;

   354                     continue;

   355                 }

   356                 if (c == ':') {

   357                     enterScope(false);

   358                     continue;

   359                 }

   360                 if (c == '{') {

   361                     enterScope(true);

   362                     continue;

   363                 }

   364                 if (c == '}') {

   365                     leaveScope();

   366                     continue;

   367                 }

   368                 if (c == '=') {

   369                     insertVariable(line, &i);

   370                     continue;

   371                 }

   372                 if (c == '|' || c == '!') {

   373                     insertOperator(c);

   374                     continue;

   375                 }

   376             }

   377         }

   378 

   379         m_proitem += c;

   380     }

   381     m_inQuote = inQuote;

   382     m_parens = parens;

   383     m_contNextLine = escaped;

   384     if (escaped) {

   385         m_proitem.chop(1);

   386         updateItem();

   387         return true;

   388     } else {

   389         if (!m_syntaxError) {

   390             updateItem();

   391             finalizeBlock();

   392             return true;

   393         }

   394         return false;

   395     }

   396 }

   397 

   398 void ProFileEvaluator::Private::finalizeBlock()

   399 {

   400     if (m_blockstack.isEmpty()) {

   401         m_syntaxError = true;

   402     } else {

   403         if (m_blockstack.top()->blockKind() & ProBlock::SingleLine)

   404             leaveScope();

   405         m_block = 0;

   406         m_commentItem = 0;

   407     }

   408 }

   409 

   410 void ProFileEvaluator::Private::insertVariable(const QString &line, int *i)

   411 {

   412     ProVariable::VariableOperator opkind;

   413 

   414     if (m_proitem.isEmpty()) // Line starting with '=', like a conflict marker

   415         return;

   416 

   417     switch (m_proitem.at(m_proitem.length() - 1).unicode()) {

   418         case '+':

   419             m_proitem.chop(1);

   420             opkind = ProVariable::AddOperator;

   421             break;

   422         case '-':

   423             m_proitem.chop(1);

   424             opkind = ProVariable::RemoveOperator;

   425             break;

   426         case '*':

   427             m_proitem.chop(1);

   428             opkind = ProVariable::UniqueAddOperator;

   429             break;

   430         case '~':

   431             m_proitem.chop(1);

   432             opkind = ProVariable::ReplaceOperator;

   433             break;

   434         default:

   435             opkind = ProVariable::SetOperator;

   436     }

   437 

   438     ProBlock *block = m_blockstack.top();

   439     m_proitem = m_proitem.trimmed();

   440     ProVariable *variable = new ProVariable(m_proitem, block);

   441     variable->setLineNumber(m_lineNo);

   442     variable->setVariableOperator(opkind);

   443     block->appendItem(variable);

   444     m_block = variable;

   445 

   446     if (!m_pendingComment.isEmpty()) {

   447         m_block->setComment(m_pendingComment);

   448         m_pendingComment.clear();

   449     }

   450     m_commentItem = variable;

   451 

   452     m_proitem.clear();

   453 

   454     if (opkind == ProVariable::ReplaceOperator) {

   455         // skip util end of line or comment

   456         while (1) {

   457             ++(*i);

   458 

   459             // end of line?

   460             if (*i >= line.count())

   461                 break;

   462 

   463             // comment?

   464             if (line.at(*i).unicode() == '#') {

   465                 --(*i);

   466                 break;

   467             }

   468 

   469             m_proitem += line.at(*i);

   470         }

   471         m_proitem = m_proitem.trimmed();

   472     }

   473 }

   474 

   475 void ProFileEvaluator::Private::insertOperator(const char op)

   476 {

   477     updateItem();

   478 

   479     ProOperator::OperatorKind opkind;

   480     switch(op) {

   481         case '!':

   482             opkind = ProOperator::NotOperator;

   483             break;

   484         case '|':

   485             opkind = ProOperator::OrOperator;

   486             break;

   487         default:

   488             opkind = ProOperator::OrOperator;

   489     }

   490 

   491     ProBlock * const block = currentBlock();

   492     ProOperator * const proOp = new ProOperator(opkind);

   493     proOp->setLineNumber(m_lineNo);

   494     block->appendItem(proOp);

   495     m_commentItem = proOp;

   496 }

   497 

   498 void ProFileEvaluator::Private::insertComment(const QString &comment)

   499 {

   500     updateItem();

   501 

   502     QString strComment;

   503     if (!m_commentItem)

   504         strComment = m_pendingComment;

   505     else

   506         strComment = m_commentItem->comment();

   507 

   508     if (strComment.isEmpty())

   509         strComment = comment;

   510     else {

   511         strComment += QLatin1Char('\n');

   512         strComment += comment.trimmed();

   513     }

   514 

   515     strComment = strComment.trimmed();

   516 

   517     if (!m_commentItem)

   518         m_pendingComment = strComment;

   519     else

   520         m_commentItem->setComment(strComment);

   521 }

   522 

   523 void ProFileEvaluator::Private::enterScope(bool multiLine)

   524 {

   525     updateItem();

   526 

   527     ProBlock *parent = currentBlock();

   528     ProBlock *block = new ProBlock(parent);

   529     block->setLineNumber(m_lineNo);

   530     parent->setBlockKind(ProBlock::ScopeKind);

   531 

   532     parent->appendItem(block);

   533 

   534     if (multiLine)

   535         block->setBlockKind(ProBlock::ScopeContentsKind);

   536     else

   537         block->setBlockKind(ProBlock::ScopeContentsKind|ProBlock::SingleLine);

   538 

   539     m_blockstack.push(block);

   540     m_block = 0;

   541 }

   542 

   543 void ProFileEvaluator::Private::leaveScope()

   544 {

   545     updateItem();

   546     m_blockstack.pop();

   547     finalizeBlock();

   548 }

   549 

   550 ProBlock *ProFileEvaluator::Private::currentBlock()

   551 {

   552     if (m_block)

   553         return m_block;

   554 

   555     ProBlock *parent = m_blockstack.top();

   556     m_block = new ProBlock(parent);

   557     m_block->setLineNumber(m_lineNo);

   558     parent->appendItem(m_block);

   559 

   560     if (!m_pendingComment.isEmpty()) {

   561         m_block->setComment(m_pendingComment);

   562         m_pendingComment.clear();

   563     }

   564 

   565     m_commentItem = m_block;

   566 

   567     return m_block;

   568 }

   569 

   570 void ProFileEvaluator::Private::updateItem()

   571 {

   572     m_proitem = m_proitem.trimmed();

   573     if (m_proitem.isEmpty())

   574         return;

   575 

   576     ProBlock *block = currentBlock();

   577     if (block->blockKind() & ProBlock::VariableKind) {

   578         m_commentItem = new ProValue(m_proitem, static_cast<ProVariable*>(block));

   579     } else if (m_proitem.endsWith(QLatin1Char(')'))) {

   580         m_commentItem = new ProFunction(m_proitem);

   581     } else {

   582         m_commentItem = new ProCondition(m_proitem);

   583     }

   584     m_commentItem->setLineNumber(m_lineNo);

   585     block->appendItem(m_commentItem);

   586 

   587     m_proitem.clear();

   588 }

   589 

   590 

   591 ProItem::ProItemReturn ProFileEvaluator::Private::visitBeginProBlock(ProBlock *block)

   592 {

   593     if (block->blockKind() & ProBlock::ScopeContentsKind) {

   594         if (!m_definingFunc.isEmpty()) {

   595             if (!m_skipLevel || m_cumulative) {

   596                 QHash<QString, ProBlock *> *hash =

   597                         (m_definingTest ? &m_testFunctions : &m_replaceFunctions);

   598                 if (ProBlock *def = hash->value(m_definingFunc))

   599                     def->deref();

   600                 hash->insert(m_definingFunc, block);

   601                 block->ref();

   602                 block->setBlockKind(block->blockKind() | ProBlock::FunctionBodyKind);

   603             }

   604             m_definingFunc.clear();

   605             return ProItem::ReturnSkip;

   606         } else if (!(block->blockKind() & ProBlock::FunctionBodyKind)) {

   607             if (!m_sts.condition)

   608                 ++m_skipLevel;

   609             else

   610                 Q_ASSERT(!m_skipLevel);

   611         }

   612     } else {

   613         if (!m_skipLevel) {

   614             if (m_sts.condition) {

   615                 m_sts.prevCondition = true;

   616                 m_sts.condition = false;

   617             }

   618         } else {

   619             Q_ASSERT(!m_sts.condition);

   620         }

   621     }

   622     return ProItem::ReturnTrue;

   623 }

   624 

   625 void ProFileEvaluator::Private::visitEndProBlock(ProBlock *block)

   626 {

   627     if ((block->blockKind() & ProBlock::ScopeContentsKind)

   628         && !(block->blockKind() & ProBlock::FunctionBodyKind)) {

   629         if (m_skipLevel) {

   630             Q_ASSERT(!m_sts.condition);

   631             --m_skipLevel;

   632         } else if (!(block->blockKind() & ProBlock::SingleLine)) {

   633             // Conditionals contained inside this block may have changed the state.

   634             // So we reset it here to make an else following us do the right thing.

   635             m_sts.condition = true;

   636         }

   637     }

   638 }

   639 

   640 ProItem::ProItemReturn ProFileEvaluator::Private::visitProLoopIteration()

   641 {

   642     ProLoop &loop = m_loopStack.top();

   643 

   644     if (loop.infinite) {

   645         if (!loop.variable.isEmpty())

   646             m_valuemap[loop.variable] = QStringList(QString::number(loop.index++));

   647         if (loop.index > 1000) {

   648             q->errorMessage(format("ran into infinite loop (> 1000 iterations)."));

   649             return ProItem::ReturnFalse;

   650         }

   651     } else {

   652         QString val;

   653         do {

   654             if (loop.index >= loop.list.count())

   655                 return ProItem::ReturnFalse;

   656             val = loop.list.at(loop.index++);

   657         } while (val.isEmpty()); // stupid, but qmake is like that

   658         m_valuemap[loop.variable] = QStringList(val);

   659     }

   660     return ProItem::ReturnTrue;

   661 }

   662 

   663 void ProFileEvaluator::Private::visitProLoopCleanup()

   664 {

   665     ProLoop &loop = m_loopStack.top();

   666     m_valuemap[loop.variable] = loop.oldVarVal;

   667     m_loopStack.pop_back();

   668 }

   669 

   670 void ProFileEvaluator::Private::visitBeginProVariable(ProVariable *variable)

   671 {

   672     m_lastVarName = variable->variable();

   673     m_variableOperator = variable->variableOperator();

   674     m_isFirstVariableValue = true;

   675     m_tempValuemap = m_valuemap;

   676     m_tempFilevaluemap = m_filevaluemap;

   677 }

   678 

   679 void ProFileEvaluator::Private::visitEndProVariable(ProVariable *variable)

   680 {

   681     Q_UNUSED(variable);

   682     m_valuemap = m_tempValuemap;

   683     m_filevaluemap = m_tempFilevaluemap;

   684     m_lastVarName.clear();

   685 }

   686 

   687 void ProFileEvaluator::Private::visitProOperator(ProOperator *oper)

   688 {

   689     m_invertNext = (oper->operatorKind() == ProOperator::NotOperator);

   690 }

   691 

   692 void ProFileEvaluator::Private::visitProCondition(ProCondition *cond)

   693 {

   694     if (!m_skipLevel) {

   695         if (!cond->text().compare(QLatin1String("else"), Qt::CaseInsensitive)) {

   696             m_sts.condition = !m_sts.prevCondition;

   697         } else {

   698             m_sts.prevCondition = false;

   699             if (!m_sts.condition && isActiveConfig(cond->text(), true) ^ m_invertNext)

   700                 m_sts.condition = true;

   701         }

   702     }

   703     m_invertNext = false;

   704 }

   705 

   706 ProItem::ProItemReturn ProFileEvaluator::Private::visitBeginProFile(ProFile * pro)

   707 {

   708     PRE(pro);

   709     m_lineNo = pro->lineNumber();

   710     if (m_origfile.isEmpty())

   711         m_origfile = pro->fileName();

   712     if (m_oldPath.isEmpty()) {

   713         // change the working directory for the initial profile we visit, since

   714         // that is *the* profile. All the other times we reach this function will be due to

   715         // include(file) or load(file)

   716 

   717         m_oldPath = QDir::currentPath();

   718 

   719         m_profileStack.push(pro);

   720 

   721         const QString mkspecDirectory = propertyValue(QLatin1String("QMAKE_MKSPECS"));

   722         if (!mkspecDirectory.isEmpty()) {

   723             bool cumulative = m_cumulative;

   724             m_cumulative = false;

   725             // This is what qmake does, everything set in the mkspec is also set

   726             // But this also creates a lot of problems

   727             evaluateFile(mkspecDirectory + QLatin1String("/default/qmake.conf"));

   728             evaluateFile(mkspecDirectory + QLatin1String("/features/default_pre.prf"));

   729             m_cumulative = cumulative;

   730         }

   731 

   732         return returnBool(QDir::setCurrent(pro->directoryName()));

   733     }

   734 

   735     return ProItem::ReturnTrue;

   736 }

   737 

   738 ProItem::ProItemReturn ProFileEvaluator::Private::visitEndProFile(ProFile * pro)

   739 {

   740     PRE(pro);

   741     m_lineNo = pro->lineNumber();

   742     if (m_profileStack.count() == 1 && !m_oldPath.isEmpty()) {

   743         const QString &mkspecDirectory = propertyValue(QLatin1String("QMAKE_MKSPECS"));

   744         if (!mkspecDirectory.isEmpty()) {

   745             bool cumulative = m_cumulative;

   746             m_cumulative = false;

   747 

   748             evaluateFile(mkspecDirectory + QLatin1String("/features/default_post.prf"));

   749 

   750             QSet<QString> processed;

   751             forever {

   752                 bool finished = true;

   753                 QStringList configs = valuesDirect(QLatin1String("CONFIG"));

   754                 for (int i = configs.size() - 1; i >= 0; --i) {

   755                     const QString config = configs[i].toLower();

   756                     if (!processed.contains(config)) {

   757                         processed.insert(config);

   758                         if (evaluateFile(mkspecDirectory + QLatin1String("/features/")

   759                                          + config + QLatin1String(".prf"))) {

   760                             finished = false;

   761                             break;

   762                         }

   763                     }

   764                 }

   765                 if (finished)

   766                     break;

   767             }

   768 

   769             foreach (ProBlock *itm, m_replaceFunctions)

   770                 itm->deref();

   771             m_replaceFunctions.clear();

   772             foreach (ProBlock *itm, m_testFunctions)

   773                 itm->deref();

   774             m_testFunctions.clear();

   775 

   776             m_cumulative = cumulative;

   777         }

   778 

   779         m_profileStack.pop();

   780         return returnBool(QDir::setCurrent(m_oldPath));

   781     }

   782 

   783     return ProItem::ReturnTrue;

   784 }

   785 

   786 static void replaceInList(QStringList *varlist,

   787         const QRegExp &regexp, const QString &replace, bool global)

   788 {

   789     for (QStringList::Iterator varit = varlist->begin(); varit != varlist->end(); ) {

   790         if ((*varit).contains(regexp)) {

   791             (*varit).replace(regexp, replace);

   792             if ((*varit).isEmpty())

   793                 varit = varlist->erase(varit);

   794             else

   795                 ++varit;

   796             if(!global)

   797                 break;

   798         } else {

   799             ++varit;

   800         }

   801     }

   802 }

   803 

   804 void ProFileEvaluator::Private::visitProValue(ProValue *value)

   805 {

   806     PRE(value);

   807     m_lineNo = value->lineNumber();

   808     QString val = value->value();

   809 

   810     QString varName = m_lastVarName;

   811 

   812     QStringList v = expandVariableReferences(val);

   813 

   814     // Since qmake combines different values for the TARGET variable, we join

   815     // TARGET values that are on the same line. We can't do this later with all

   816     // values because this parser isn't scope-aware, so we'd risk joining

   817     // scope-specific targets together.

   818     if (varName == QLatin1String("TARGET")

   819             && m_lineNo == m_prevLineNo

   820             && currentProFile() == m_prevProFile) {

   821         QStringList targets = m_tempValuemap.value(QLatin1String("TARGET"));

   822         m_tempValuemap.remove(QLatin1String("TARGET"));

   823         QStringList lastTarget(targets.takeLast());

   824         lastTarget << v.join(QLatin1String(" "));

   825         targets.push_back(lastTarget.join(QLatin1String(" ")));

   826         v = targets;

   827     }

   828     m_prevLineNo = m_lineNo;

   829     m_prevProFile = currentProFile();

   830 

   831     switch (m_variableOperator) {

   832         case ProVariable::SetOperator:          // =

   833             if (!m_cumulative) {

   834                 if (!m_skipLevel) {

   835                     if (m_isFirstVariableValue) {

   836                         m_tempValuemap[varName] = v;

   837                         m_tempFilevaluemap[currentProFile()][varName] = v;

   838                     } else { // handle lines "CONFIG = foo bar"

   839                         m_tempValuemap[varName] += v;

   840                         m_tempFilevaluemap[currentProFile()][varName] += v;

   841                     }

   842                 }

   843             } else {

   844                 // We are greedy for values.

   845                 m_tempValuemap[varName] += v;

   846                 m_tempFilevaluemap[currentProFile()][varName] += v;

   847             }

   848             break;

   849         case ProVariable::UniqueAddOperator:    // *=

   850             if (!m_skipLevel || m_cumulative) {

   851                 insertUnique(&m_tempValuemap, varName, v);

   852                 insertUnique(&m_tempFilevaluemap[currentProFile()], varName, v);

   853             }

   854             break;

   855         case ProVariable::AddOperator:          // +=

   856             if (!m_skipLevel || m_cumulative) {

   857                 m_tempValuemap[varName] += v;

   858                 m_tempFilevaluemap[currentProFile()][varName] += v;

   859             }

   860             break;

   861         case ProVariable::RemoveOperator:       // -=

   862             if (!m_cumulative) {

   863                 if (!m_skipLevel) {

   864                     removeEach(&m_tempValuemap, varName, v);

   865                     removeEach(&m_tempFilevaluemap[currentProFile()], varName, v);

   866                 }

   867             } else {

   868                 // We are stingy with our values, too.

   869             }

   870             break;

   871         case ProVariable::ReplaceOperator:      // ~=

   872             {

   873                 // DEFINES ~= s/a/b/?[gqi]

   874 

   875                 doVariableReplace(&val);

   876                 if (val.length() < 4 || val[0] != QLatin1Char('s')) {

   877                     q->logMessage(format("the ~= operator can handle only the s/// function."));

   878                     break;

   879                 }

   880                 QChar sep = val.at(1);

   881                 QStringList func = val.split(sep);

   882                 if (func.count() < 3 || func.count() > 4) {

   883                     q->logMessage(format("the s/// function expects 3 or 4 arguments."));

   884                     break;

   885                 }

   886 

   887                 bool global = false, quote = false, case_sense = false;

   888                 if (func.count() == 4) {

   889                     global = func[3].indexOf(QLatin1Char('g')) != -1;

   890                     case_sense = func[3].indexOf(QLatin1Char('i')) == -1;

   891                     quote = func[3].indexOf(QLatin1Char('q')) != -1;

   892                 }

   893                 QString pattern = func[1];

   894                 QString replace = func[2];

   895                 if (quote)

   896                     pattern = QRegExp::escape(pattern);

   897 

   898                 QRegExp regexp(pattern, case_sense ? Qt::CaseSensitive : Qt::CaseInsensitive);

   899 

   900                 if (!m_skipLevel || m_cumulative) {

   901                     // We could make a union of modified and unmodified values,

   902                     // but this will break just as much as it fixes, so leave it as is.

   903                     replaceInList(&m_tempValuemap[varName], regexp, replace, global);

   904                     replaceInList(&m_tempFilevaluemap[currentProFile()][varName], regexp, replace, global);

   905                 }

   906             }

   907             break;

   908 

   909     }

   910     m_isFirstVariableValue = false;

   911 }

   912 

   913 ProItem::ProItemReturn ProFileEvaluator::Private::visitProFunction(ProFunction *func)

   914 {

   915     // Make sure that called subblocks don't inherit & destroy the state

   916     bool invertThis = m_invertNext;

   917     m_invertNext = false;

   918     if (!m_skipLevel)

   919         m_sts.prevCondition = false;

   920     if (m_cumulative || !m_sts.condition) {

   921         QString text = func->text();

   922         int lparen = text.indexOf(QLatin1Char('('));

   923         int rparen = text.lastIndexOf(QLatin1Char(')'));

   924         Q_ASSERT(lparen < rparen);

   925         QString arguments = text.mid(lparen + 1, rparen - lparen - 1);

   926         QString funcName = text.left(lparen);

   927         m_lineNo = func->lineNumber();

   928         ProItem::ProItemReturn result = evaluateConditionalFunction(funcName.trimmed(), arguments);

   929         if (result != ProItem::ReturnFalse && result != ProItem::ReturnTrue)

   930             return result;

   931         if (!m_skipLevel && ((result == ProItem::ReturnTrue) ^ invertThis))

   932             m_sts.condition = true;

   933     }

   934     return ProItem::ReturnTrue;

   935 }

   936 

   937 

   938 QStringList ProFileEvaluator::Private::qmakeFeaturePaths()

   939 {

   940     QStringList concat;

   941     {

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

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

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

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

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

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

   948         concat << base_concat + QDir::separator() + QLatin1String("qnx6");

   949         concat << base_concat;

   950     }

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

   952     QStringList feature_roots;

   953     QByteArray mkspec_path = qgetenv("QMAKEFEATURES");

   954     if (!mkspec_path.isNull())

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

   956     /*

   957     if (prop)

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

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

   960         QString path;

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

   962         if (last_slash != -1)

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

   964         foreach (const QString &concat_it, concat)

   965             feature_roots << (path + concat_it);

   966     }

   967     */

   968 

   969     QByteArray qmakepath = qgetenv("QMAKEPATH");

   970     if (!qmakepath.isNull()) {

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

   972         foreach (const QString &item, lst) {

   973             foreach (const QString &concat_it, concat)

   974                 feature_roots << (item + mkspecs_concat + concat_it);

   975         }

   976     }

   977     //if (!Option::mkfile::qmakespec.isEmpty())

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

   979     //if (!Option::mkfile::qmakespec.isEmpty()) {

   980     //    QFileInfo specfi(Option::mkfile::qmakespec);

   981     //    QDir specdir(specfi.absoluteFilePath());

   982     //    while (!specdir.isRoot()) {

   983     //        if (!specdir.cdUp() || specdir.isRoot())

   984     //            break;

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

   986     //            foreach (const QString &concat_it, concat)

   987     //                feature_roots << (specdir.path() + concat_it);

   988     //            break;

   989     //        }

   990     //    }

   991     //}

   992     foreach (const QString &concat_it, concat)

   993         feature_roots << (propertyValue(QLatin1String("QT_INSTALL_PREFIX")) +

   994                           mkspecs_concat + concat_it);

   995     foreach (const QString &concat_it, concat)

   996         feature_roots << (propertyValue(QLatin1String("QT_INSTALL_DATA")) +

   997                           mkspecs_concat + concat_it);

   998     return feature_roots;

   999 }

  1000 

  1001 QString ProFileEvaluator::Private::propertyValue(const QString &name) const

  1002 {

  1003     if (m_properties.contains(name))

  1004         return m_properties.value(name);

  1005     if (name == QLatin1String("QT_INSTALL_PREFIX"))

  1006         return QLibraryInfo::location(QLibraryInfo::PrefixPath);

  1007     if (name == QLatin1String("QT_INSTALL_DATA"))

  1008         return QLibraryInfo::location(QLibraryInfo::DataPath);

  1009     if (name == QLatin1String("QT_INSTALL_DOCS"))

  1010         return QLibraryInfo::location(QLibraryInfo::DocumentationPath);

  1011     if (name == QLatin1String("QT_INSTALL_HEADERS"))

  1012         return QLibraryInfo::location(QLibraryInfo::HeadersPath);

  1013     if (name == QLatin1String("QT_INSTALL_LIBS"))

  1014         return QLibraryInfo::location(QLibraryInfo::LibrariesPath);

  1015     if (name == QLatin1String("QT_INSTALL_BINS"))

  1016         return QLibraryInfo::location(QLibraryInfo::BinariesPath);

  1017     if (name == QLatin1String("QT_INSTALL_PLUGINS"))

  1018         return QLibraryInfo::location(QLibraryInfo::PluginsPath);

  1019     if (name == QLatin1String("QT_INSTALL_TRANSLATIONS"))

  1020         return QLibraryInfo::location(QLibraryInfo::TranslationsPath);

  1021     if (name == QLatin1String("QT_INSTALL_CONFIGURATION"))

  1022         return QLibraryInfo::location(QLibraryInfo::SettingsPath);

  1023     if (name == QLatin1String("QT_INSTALL_EXAMPLES"))

  1024         return QLibraryInfo::location(QLibraryInfo::ExamplesPath);

  1025     if (name == QLatin1String("QT_INSTALL_DEMOS"))

  1026         return QLibraryInfo::location(QLibraryInfo::DemosPath);

  1027     if (name == QLatin1String("QMAKE_MKSPECS"))

  1028         return qmake_mkspec_paths().join(Option::dirlist_sep);

  1029     if (name == QLatin1String("QMAKE_VERSION"))

  1030         return QLatin1String("1.0");        //### FIXME

  1031         //return qmake_version();

  1032 #ifdef QT_VERSION_STR

  1033     if (name == QLatin1String("QT_VERSION"))

  1034         return QLatin1String(QT_VERSION_STR);

  1035 #endif

  1036     return QLatin1String("UNKNOWN");        //###

  1037 }

  1038 

  1039 ProFile *ProFileEvaluator::Private::currentProFile() const

  1040 {

  1041     if (m_profileStack.count() > 0)

  1042         return m_profileStack.top();

  1043     return 0;

  1044 }

  1045 

  1046 QString ProFileEvaluator::Private::currentFileName() const

  1047 {

  1048     ProFile *pro = currentProFile();

  1049     if (pro)

  1050         return pro->fileName();

  1051     return QString();

  1052 }

  1053 

  1054 QString ProFileEvaluator::Private::currentDirectory() const

  1055 {

  1056     ProFile *cur = m_profileStack.top();

  1057     return cur->directoryName();

  1058 }

  1059 

  1060 void ProFileEvaluator::Private::doVariableReplace(QString *str)

  1061 {

  1062     *str = expandVariableReferences(*str).join(QString(Option::field_sep));

  1063 }

  1064 

  1065 QStringList ProFileEvaluator::Private::expandVariableReferences(const QString &str)

  1066 {

  1067     QStringList ret;

  1068 //    if (ok)

  1069 //        *ok = true;

  1070     if (str.isEmpty())

  1071         return ret;

  1072 

  1073     const ushort LSQUARE = '[';

  1074     const ushort RSQUARE = ']';

  1075     const ushort LCURLY = '{';

  1076     const ushort RCURLY = '}';

  1077     const ushort LPAREN = '(';

  1078     const ushort RPAREN = ')';

  1079     const ushort DOLLAR = '$';

  1080     const ushort BACKSLASH = '\\';

  1081     const ushort UNDERSCORE = '_';

  1082     const ushort DOT = '.';

  1083     const ushort SPACE = ' ';

  1084     const ushort TAB = '\t';

  1085     const ushort SINGLEQUOTE = '\'';

  1086     const ushort DOUBLEQUOTE = '"';

  1087 

  1088     ushort unicode, quote = 0;

  1089     const QChar *str_data = str.data();

  1090     const int str_len = str.length();

  1091 

  1092     ushort term;

  1093     QString var, args;

  1094 

  1095     int replaced = 0;

  1096     QString current;

  1097     for (int i = 0; i < str_len; ++i) {

  1098         unicode = str_data[i].unicode();

  1099         const int start_var = i;

  1100         if (unicode == DOLLAR && str_len > i+2) {

  1101             unicode = str_data[++i].unicode();

  1102             if (unicode == DOLLAR) {

  1103                 term = 0;

  1104                 var.clear();

  1105                 args.clear();

  1106                 enum { VAR, ENVIRON, FUNCTION, PROPERTY } var_type = VAR;

  1107                 unicode = str_data[++i].unicode();

  1108                 if (unicode == LSQUARE) {

  1109                     unicode = str_data[++i].unicode();

  1110                     term = RSQUARE;

  1111                     var_type = PROPERTY;

  1112                 } else if (unicode == LCURLY) {

  1113                     unicode = str_data[++i].unicode();

  1114                     var_type = VAR;

  1115                     term = RCURLY;

  1116                 } else if (unicode == LPAREN) {

  1117                     unicode = str_data[++i].unicode();

  1118                     var_type = ENVIRON;

  1119                     term = RPAREN;

  1120                 }

  1121                 forever {

  1122                     if (!(unicode & (0xFF<<8)) &&

  1123                        unicode != DOT && unicode != UNDERSCORE &&

  1124                        //unicode != SINGLEQUOTE && unicode != DOUBLEQUOTE &&

  1125                        (unicode < 'a' || unicode > 'z') && (unicode < 'A' || unicode > 'Z') &&

  1126                        (unicode < '0' || unicode > '9'))

  1127                         break;

  1128                     var.append(QChar(unicode));

  1129                     if (++i == str_len)

  1130                         break;

  1131                     unicode = str_data[i].unicode();

  1132                     // at this point, i points to either the 'term' or 'next' character (which is in unicode)

  1133                 }

  1134                 if (var_type == VAR && unicode == LPAREN) {