qmakeparser.cpp 42.1 KB
Newer Older
1
2
3
4
/**************************************************************************
**
** This file is part of Qt Creator
**
hjk's avatar
hjk committed
5
** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
6
**
Eike Ziller's avatar
Eike Ziller committed
7
** Contact: http://www.qt-project.org/
8
9
10
11
**
**
** GNU Lesser General Public License Usage
**
hjk's avatar
hjk committed
12
13
14
15
16
17
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18
**
con's avatar
con committed
19
** In addition, as a special exception, Nokia gives you certain additional
hjk's avatar
hjk committed
20
** rights. These rights are described in the Nokia Qt LGPL Exception
con's avatar
con committed
21
22
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
23
24
25
26
27
** Other Usage
**
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
28
29
30
**
**************************************************************************/

31
#include "qmakeparser.h"
32
33
34
35

#include "ioutils.h"
using namespace ProFileEvaluatorInternal;

36
#include <QFile>
37
#ifdef PROPARSER_THREAD_SAFE
38
# include <QThreadPool>
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#endif

QT_BEGIN_NAMESPACE

///////////////////////////////////////////////////////////////////////
//
// ProFileCache
//
///////////////////////////////////////////////////////////////////////

ProFileCache::~ProFileCache()
{
    foreach (const Entry &ent, parsed_files)
        if (ent.pro)
            ent.pro->deref();
}

void ProFileCache::discardFile(const QString &fileName)
{
#ifdef PROPARSER_THREAD_SAFE
    QMutexLocker lck(&mutex);
#endif
    QHash<QString, Entry>::Iterator it = parsed_files.find(fileName);
    if (it != parsed_files.end()) {
        if (it->pro)
            it->pro->deref();
        parsed_files.erase(it);
    }
}

void ProFileCache::discardFiles(const QString &prefix)
{
#ifdef PROPARSER_THREAD_SAFE
    QMutexLocker lck(&mutex);
#endif
    QHash<QString, Entry>::Iterator
            it = parsed_files.begin(),
            end = parsed_files.end();
    while (it != end)
        if (it.key().startsWith(prefix)) {
            if (it->pro)
                it->pro->deref();
            it = parsed_files.erase(it);
        } else {
            ++it;
        }
}


////////// Parser ///////////

#define fL1S(s) QString::fromLatin1(s)

92
93
namespace { // MSVC2010 doesn't seem to know the semantics of "static" ...

94
95
96
97
98
static struct {
    QString strelse;
    QString strfor;
    QString strdefineTest;
    QString strdefineReplace;
99
    QString stroption;
100
101
102
    QString strreturn;
    QString strnext;
    QString strbreak;
103
    QString strhost_build;
104
105
106
107
108
    QString strLINE;
    QString strFILE;
    QString strLITERAL_HASH;
    QString strLITERAL_DOLLAR;
    QString strLITERAL_WHITESPACE;
109
110
} statics;

111
112
}

113
void QMakeParser::initialize()
114
115
116
117
118
119
120
121
{
    if (!statics.strelse.isNull())
        return;

    statics.strelse = QLatin1String("else");
    statics.strfor = QLatin1String("for");
    statics.strdefineTest = QLatin1String("defineTest");
    statics.strdefineReplace = QLatin1String("defineReplace");
122
    statics.stroption = QLatin1String("option");
123
124
125
    statics.strreturn = QLatin1String("return");
    statics.strnext = QLatin1String("next");
    statics.strbreak = QLatin1String("break");
126
    statics.strhost_build = QLatin1String("host_build");
127
128
129
130
131
    statics.strLINE = QLatin1String("_LINE_");
    statics.strFILE = QLatin1String("_FILE_");
    statics.strLITERAL_HASH = QLatin1String("LITERAL_HASH");
    statics.strLITERAL_DOLLAR = QLatin1String("LITERAL_DOLLAR");
    statics.strLITERAL_WHITESPACE = QLatin1String("LITERAL_WHITESPACE");
132
133
}

134
QMakeParser::QMakeParser(ProFileCache *cache, QMakeParserHandler *handler)
135
    : m_cache(cache)
136
137
138
139
140
141
    , m_handler(handler)
{
    // So that single-threaded apps don't have to call initialize() for now.
    initialize();
}

142
ProFile *QMakeParser::parsedProFile(const QString &fileName, bool cache)
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
{
    ProFile *pro;
    if (cache && m_cache) {
        ProFileCache::Entry *ent;
#ifdef PROPARSER_THREAD_SAFE
        QMutexLocker locker(&m_cache->mutex);
#endif
        QHash<QString, ProFileCache::Entry>::Iterator it = m_cache->parsed_files.find(fileName);
        if (it != m_cache->parsed_files.end()) {
            ent = &*it;
#ifdef PROPARSER_THREAD_SAFE
            if (ent->locker && !ent->locker->done) {
                ++ent->locker->waiters;
                QThreadPool::globalInstance()->releaseThread();
                ent->locker->cond.wait(locker.mutex());
                QThreadPool::globalInstance()->reserveThread();
                if (!--ent->locker->waiters) {
                    delete ent->locker;
                    ent->locker = 0;
                }
            }
#endif
            if ((pro = ent->pro))
                pro->ref();
        } else {
            ent = &m_cache->parsed_files[fileName];
#ifdef PROPARSER_THREAD_SAFE
            ent->locker = new ProFileCache::Entry::Locker;
            locker.unlock();
#endif
            pro = new ProFile(fileName);
174
            if (!read(pro)) {
175
176
177
                delete pro;
                pro = 0;
            } else {
178
                pro->itemsRef()->squeeze();
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
                pro->ref();
            }
            ent->pro = pro;
#ifdef PROPARSER_THREAD_SAFE
            locker.relock();
            if (ent->locker->waiters) {
                ent->locker->done = true;
                ent->locker->cond.wakeAll();
            } else {
                delete ent->locker;
                ent->locker = 0;
            }
#endif
        }
    } else {
        pro = new ProFile(fileName);
195
        if (!read(pro)) {
196
197
198
199
200
201
202
            delete pro;
            pro = 0;
        }
    }
    return pro;
}

203
ProFile *QMakeParser::parsedProBlock(const QString &name, const QString &contents, SubGrammar grammar)
204
205
{
    ProFile *pro = new ProFile(name);
206
    if (!read(pro, contents, grammar)) {
207
208
209
210
211
212
        delete pro;
        pro = 0;
    }
    return pro;
}

213
bool QMakeParser::read(ProFile *pro)
214
215
216
217
{
    QFile file(pro->fileName());
    if (!file.open(QIODevice::ReadOnly)) {
        if (m_handler && IoUtils::exists(pro->fileName()))
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
218
219
            m_handler->message(QMakeParserHandler::ParserIoError,
                               fL1S("Cannot read %1: %2").arg(pro->fileName(), file.errorString()));
220
221
222
223
224
        return false;
    }

    QString content(QString::fromLocal8Bit(file.readAll()));
    file.close();
225
    return read(pro, content, FullGrammar);
226
227
}

228
void QMakeParser::putTok(ushort *&tokPtr, ushort tok)
229
230
231
232
{
    *tokPtr++ = tok;
}

233
void QMakeParser::putBlockLen(ushort *&tokPtr, uint len)
234
235
236
237
238
{
    *tokPtr++ = (ushort)len;
    *tokPtr++ = (ushort)(len >> 16);
}

239
void QMakeParser::putBlock(ushort *&tokPtr, const ushort *buf, uint len)
240
241
242
243
244
{
    memcpy(tokPtr, buf, len * 2);
    tokPtr += len;
}

245
void QMakeParser::putHashStr(ushort *&pTokPtr, const ushort *buf, uint len)
246
247
248
249
250
251
252
253
254
255
{
    uint hash = ProString::hash((const QChar *)buf, len);
    ushort *tokPtr = pTokPtr;
    *tokPtr++ = (ushort)hash;
    *tokPtr++ = (ushort)(hash >> 16);
    *tokPtr++ = (ushort)len;
    memcpy(tokPtr, buf, len * 2);
    pTokPtr = tokPtr + len;
}

256
void QMakeParser::finalizeHashStr(ushort *buf, uint len)
257
258
259
260
261
262
263
264
{
    buf[-4] = TokHashLiteral;
    buf[-1] = len;
    uint hash = ProString::hash((const QChar *)buf, len);
    buf[-3] = (ushort)hash;
    buf[-2] = (ushort)(hash >> 16);
}

265
bool QMakeParser::read(ProFile *pro, const QString &in, SubGrammar grammar)
266
{
267
    m_proFile = pro;
268
269
270
271
272
273
274
    m_lineNo = 1;

    // Final precompiled token stream buffer
    QString tokBuff;
    // Worst-case size calculations:
    // - line marker adds 1 (2-nl) to 1st token of each line
    // - empty assignment "A=":2 =>
275
276
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokAssign(1) + 0(1) +
    //   TokValueTerminator(1) == 8 (9)
277
    // - non-empty assignment "A=B C":5 =>
278
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokAssign(1) + 2(1) +
279
    //   TokLiteral(1) + len(1) + "B"(1) +
280
    //   TokLiteral(1) + len(1) + "C"(1) + TokValueTerminator(1) == 14 (15)
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
    // - variable expansion: "$$f":3 =>
    //   TokVariable(1) + hash(2) + len(1) + "f"(1) = 5
    // - function expansion: "$$f()":5 =>
    //   TokFuncName(1) + hash(2) + len(1) + "f"(1) + TokFuncTerminator(1) = 6
    // - scope: "X:":2 =>
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokCondition(1) +
    //   TokBranch(1) + len(2) + ... + len(2) + ... == 10
    // - test: "X():":4 =>
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokTestCall(1) + TokFuncTerminator(1) +
    //   TokBranch(1) + len(2) + ... + len(2) + ... == 11
    // - "for(A,B):":9 =>
    //   TokForLoop(1) + hash(2) + len(1) + "A"(1) +
    //   len(2) + TokLiteral(1) + len(1) + "B"(1) + TokValueTerminator(1) +
    //   len(2) + ... + TokTerminator(1) == 14 (15)
    tokBuff.reserve((in.size() + 1) * 5);
    ushort *tokPtr = (ushort *)tokBuff.constData(); // Current writing position

    // Expression precompiler buffer.
    QString xprBuff;
    xprBuff.reserve(tokBuff.capacity()); // Excessive, but simple
301
    ushort *buf = (ushort *)xprBuff.constData();
302
303

    // Parser state
304
305
    m_blockstack.clear();
    m_blockstack.resize(1);
306
307
308
309
310
311
312
313
314
315
316
317

    QStack<ParseCtx> xprStack;
    xprStack.reserve(10);

    // We rely on QStrings being null-terminated, so don't maintain a global end pointer.
    const ushort *cur = (const ushort *)in.unicode();
    m_canElse = false;
  freshLine:
    m_state = StNew;
    m_invert = false;
    m_operator = NoOperator;
    m_markLine = m_lineNo;
318
    m_inError = false;
319
    Context context = CtxTest;
320
    int parens = 0; // Braces in value context
321
    int argc = 0;
322
    int wordCount = 0; // Number of words in currently accumulated expression
323
    int lastIndent = 0; // Previous line's indentation, to detect accidental continuation abuse
324
325
    bool putSpace = false; // Only ever true inside quoted string
    bool lineMarked = true; // For in-expression markers
326
    ushort needSep = TokNewStr; // Complementary to putSpace: separator outside quotes
327
328
329
330
331
332
333
    ushort quote = 0;
    ushort term = 0;

    ushort *ptr = buf;
    ptr += 4;
    ushort *xprPtr = ptr;

334
#define FLUSH_LHS_LITERAL() \
335
336
337
    do { \
        if ((tlen = ptr - xprPtr)) { \
            finalizeHashStr(xprPtr, tlen); \
338
339
340
341
            if (needSep) { \
                wordCount++; \
                needSep = 0; \
            } \
342
343
344
345
346
        } else { \
            ptr -= 4; \
        } \
    } while (0)

347
#define FLUSH_RHS_LITERAL() \
348
349
350
351
    do { \
        if ((tlen = ptr - xprPtr)) { \
            xprPtr[-2] = TokLiteral | needSep; \
            xprPtr[-1] = tlen; \
352
353
354
355
            if (needSep) { \
                wordCount++; \
                needSep = 0; \
            } \
356
357
358
359
360
        } else { \
            ptr -= 2; \
        } \
    } while (0)

361
#define FLUSH_LITERAL() \
362
363
    do { \
        if (context == CtxTest) \
364
            FLUSH_LHS_LITERAL(); \
365
        else \
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
            FLUSH_RHS_LITERAL(); \
    } while (0)

#define FLUSH_VALUE_LIST() \
    do { \
        if (wordCount > 1) { \
            xprPtr = tokPtr; \
            if (*xprPtr == TokLine) \
                xprPtr += 2; \
            tokPtr[-1] = ((*xprPtr & TokMask) == TokLiteral) ? wordCount : 0; \
        } else { \
            tokPtr[-1] = 0; \
        } \
        tokPtr = ptr; \
        putTok(tokPtr, TokValueTerminator); \
381
382
383
384
385
386
    } while (0)

    forever {
        ushort c;

        // First, skip leading whitespace
387
388
        int indent;
        for (indent = 0; ; ++cur, ++indent) {
389
390
391
            c = *cur;
            if (c == '\n') {
                ++cur;
392
                goto flushLine;
393
            } else if (!c) {
394
                cur = 0;
395
                goto flushLine;
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
            } else if (c != ' ' && c != '\t' && c != '\r') {
                break;
            }
        }

        // Then strip comments. Yep - no escaping is possible.
        const ushort *end; // End of this line
        const ushort *cptr; // Start of next line
        for (cptr = cur;; ++cptr) {
            c = *cptr;
            if (c == '#') {
                for (end = cptr; (c = *++cptr);) {
                    if (c == '\n') {
                        ++cptr;
                        break;
                    }
                }
                if (end == cur) { // Line with only a comment (sans whitespace)
414
415
                    if (m_markLine == m_lineNo)
                        m_markLine++;
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
                    // Qmake bizarreness: such lines do not affect line continuations
                    goto ignore;
                }
                break;
            }
            if (!c) {
                end = cptr;
                break;
            }
            if (c == '\n') {
                end = cptr++;
                break;
            }
        }

        // Then look for line continuations. Yep - no escaping here as well.
        bool lineCont;
        forever {
            // We don't have to check for underrun here, as we already determined
            // that the line is non-empty.
            ushort ec = *(end - 1);
            if (ec == '\\') {
                --end;
                lineCont = true;
                break;
            }
            if (ec != ' ' && ec != '\t' && ec != '\r') {
                lineCont = false;
                break;
            }
            --end;
        }

            // Finally, do the tokenization
            ushort tok, rtok;
            int tlen;
452
          newWord:
453
454
455
456
457
458
459
            do {
                if (cur == end)
                    goto lineEnd;
                c = *cur++;
            } while (c == ' ' || c == '\t');
            forever {
                if (c == '$') {
460
                    if (*cur == '$') { // may be EOF, EOL, WS, '#' or '\\' if past end
461
462
463
464
465
                        cur++;
                        if (putSpace) {
                            putSpace = false;
                            *ptr++ = ' ';
                        }
466
                        FLUSH_LITERAL();
467
468
469
470
471
472
473
474
475
                        if (!lineMarked) {
                            lineMarked = true;
                            *ptr++ = TokLine;
                            *ptr++ = (ushort)m_lineNo;
                        }
                        term = 0;
                        tok = TokVariable;
                        c = *cur;
                        if (c == '[') {
476
                            ptr += 4;
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
                            tok = TokProperty;
                            term = ']';
                            c = *++cur;
                        } else if (c == '{') {
                            ptr += 4;
                            term = '}';
                            c = *++cur;
                        } else if (c == '(') {
                            ptr += 2;
                            tok = TokEnvVar;
                            term = ')';
                            c = *++cur;
                        } else {
                            ptr += 4;
                        }
                        xprPtr = ptr;
                        rtok = tok;
                        while ((c & 0xFF00) || c == '.' || c == '_' ||
                               (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
496
                               (c >= '0' && c <= '9') || (c == '/' && term)) {
497
498
499
500
501
502
503
504
505
506
507
508
                            *ptr++ = c;
                            if (++cur == end) {
                                c = 0;
                                goto notfunc;
                            }
                            c = *cur;
                        }
                        if (tok == TokVariable && c == '(')
                            tok = TokFuncName;
                      notfunc:
                        if (quote)
                            tok |= TokQuoted;
509
510
511
512
                        if (needSep) {
                            tok |= needSep;
                            wordCount++;
                        }
513
                        tlen = ptr - xprPtr;
514
515
516
517
                        if (rtok != TokVariable
                            || !resolveVariable(xprPtr, tlen, needSep, &ptr,
                                                &buf, &xprBuff, &tokPtr, &tokBuff, cur, in)) {
                            if (rtok == TokVariable || rtok == TokProperty) {
518
519
520
521
522
                                xprPtr[-4] = tok;
                                uint hash = ProString::hash((const QChar *)xprPtr, tlen);
                                xprPtr[-3] = (ushort)hash;
                                xprPtr[-2] = (ushort)(hash >> 16);
                                xprPtr[-1] = tlen;
523
524
525
                            } else {
                                xprPtr[-2] = tok;
                                xprPtr[-1] = tlen;
526
                            }
527
528
529
530
531
532
533
534
535
536
537
538
                        }
                        if ((tok & TokMask) == TokFuncName) {
                            cur++;
                          funcCall:
                            {
                                xprStack.resize(xprStack.size() + 1);
                                ParseCtx &top = xprStack.top();
                                top.parens = parens;
                                top.quote = quote;
                                top.terminator = term;
                                top.context = context;
                                top.argc = argc;
539
                                top.wordCount = wordCount;
540
541
542
543
544
545
546
                            }
                            parens = 0;
                            quote = 0;
                            term = 0;
                            argc = 1;
                            context = CtxArgs;
                          nextToken:
547
548
                            wordCount = 0;
                          nextWord:
549
550
                            ptr += (context == CtxTest) ? 4 : 2;
                            xprPtr = ptr;
551
552
                            needSep = TokNewStr;
                            goto newWord;
553
554
555
556
557
558
559
                        }
                        if (term) {
                          checkTerm:
                            if (c != term) {
                                parseError(fL1S("Missing %1 terminator [found %2]")
                                    .arg(QChar(term))
                                    .arg(c ? QString(c) : QString::fromLatin1("end-of-line")));
560
                                pro->setOk(false);
561
562
                                m_inError = true;
                                // Just parse on, as if there was a terminator ...
563
564
                            } else {
                                cur++;
565
566
567
568
569
                            }
                        }
                      joinToken:
                        ptr += (context == CtxTest) ? 4 : 2;
                        xprPtr = ptr;
570
                        needSep = 0;
571
572
                        goto nextChr;
                    }
573
                } else if (c == '\\') {
574
                    static const char symbols[] = "[]{}()$\\'\"";
575
576
                    ushort c2;
                    if (cur != end && !((c2 = *cur) & 0xff00) && strchr(symbols, c2)) {
577
578
                        c = c2;
                        cur++;
579
580
                    } else {
                        deprecationWarning(fL1S("Unescaped backslashes are deprecated"));
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
                    }
                } else if (quote) {
                    if (c == quote) {
                        quote = 0;
                        if (putSpace) {
                            putSpace = false;
                            *ptr++ = ' ';
                        }
                        goto nextChr;
                    } else if (c == ' ' || c == '\t') {
                        putSpace = true;
                        goto nextChr;
                    } else if (c == '!' && ptr == xprPtr && context == CtxTest) {
                        m_invert ^= true;
                        goto nextChr;
                    }
                } else if (c == '\'' || c == '"') {
                    quote = c;
                    goto nextChr;
                } else if (c == ' ' || c == '\t') {
601
602
                    FLUSH_LITERAL();
                    goto nextWord;
603
604
605
606
607
608
                } else if (context == CtxArgs) {
                    // Function arg context
                    if (c == '(') {
                        ++parens;
                    } else if (c == ')') {
                        if (--parens < 0) {
609
                            FLUSH_RHS_LITERAL();
610
611
612
613
614
615
616
617
618
                            *ptr++ = TokFuncTerminator;
                            int theargc = argc;
                            {
                                ParseCtx &top = xprStack.top();
                                parens = top.parens;
                                quote = top.quote;
                                term = top.terminator;
                                context = top.context;
                                argc = top.argc;
619
                                wordCount = top.wordCount;
620
621
622
623
624
625
                                xprStack.resize(xprStack.size() - 1);
                            }
                            if (term == ':') {
                                finalizeCall(tokPtr, buf, ptr, theargc);
                                goto nextItem;
                            } else if (term == '}') {
626
                                c = (cur == end) ? 0 : *cur;
627
628
629
630
631
632
633
                                goto checkTerm;
                            } else {
                                Q_ASSERT(!term);
                                goto joinToken;
                            }
                        }
                    } else if (!parens && c == ',') {
634
                        FLUSH_RHS_LITERAL();
635
636
637
638
639
640
641
                        *ptr++ = TokArgSeparator;
                        argc++;
                        goto nextToken;
                    }
                } else if (context == CtxTest) {
                    // Test or LHS context
                    if (c == '(') {
642
643
644
645
646
647
                        FLUSH_LHS_LITERAL();
                        if (wordCount != 1) {
                            if (wordCount)
                                parseError(fL1S("Extra characters after test expression."));
                            else
                                parseError(fL1S("Opening parenthesis without prior test name."));
648
649
                            pro->setOk(false);
                            ptr = buf; // Put empty function name
650
651
652
653
654
655
656
657
                        }
                        *ptr++ = TokTestCall;
                        term = ':';
                        goto funcCall;
                    } else if (c == '!' && ptr == xprPtr) {
                        m_invert ^= true;
                        goto nextChr;
                    } else if (c == ':') {
658
659
                        FLUSH_LHS_LITERAL();
                        finalizeCond(tokPtr, buf, ptr, wordCount);
660
661
662
663
664
665
666
667
                        if (m_state == StNew)
                            parseError(fL1S("And operator without prior condition."));
                        else
                            m_operator = AndOperator;
                      nextItem:
                        ptr = buf;
                        goto nextToken;
                    } else if (c == '|') {
668
669
                        FLUSH_LHS_LITERAL();
                        finalizeCond(tokPtr, buf, ptr, wordCount);
670
671
672
673
674
675
                        if (m_state != StCond)
                            parseError(fL1S("Or operator without prior condition."));
                        else
                            m_operator = OrOperator;
                        goto nextItem;
                    } else if (c == '{') {
676
677
                        FLUSH_LHS_LITERAL();
                        finalizeCond(tokPtr, buf, ptr, wordCount);
678
679
                        flushCond(tokPtr);
                        ++m_blockstack.top().braceLevel;
680
681
682
683
                        if (grammar == TestGrammar) {
                            parseError(fL1S("Opening scope not permitted in this context."));
                            pro->setOk(false);
                        }
684
685
                        goto nextItem;
                    } else if (c == '}') {
686
687
                        FLUSH_LHS_LITERAL();
                        finalizeCond(tokPtr, buf, ptr, wordCount);
688
                        flushScopes(tokPtr);
689
                      closeScope:
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
                        if (!m_blockstack.top().braceLevel) {
                            parseError(fL1S("Excess closing brace."));
                        } else if (!--m_blockstack.top().braceLevel
                                   && m_blockstack.count() != 1) {
                            leaveScope(tokPtr);
                            m_state = StNew;
                            m_canElse = false;
                            m_markLine = m_lineNo;
                        }
                        goto nextItem;
                    } else if (c == '+') {
                        tok = TokAppend;
                        goto do2Op;
                    } else if (c == '-') {
                        tok = TokRemove;
                        goto do2Op;
                    } else if (c == '*') {
                        tok = TokAppendUnique;
                        goto do2Op;
                    } else if (c == '~') {
                        tok = TokReplace;
                      do2Op:
                        if (*cur == '=') {
                            cur++;
                            goto doOp;
                        }
                    } else if (c == '=') {
                        tok = TokAssign;
                      doOp:
719
                        FLUSH_LHS_LITERAL();
720
721
                        flushCond(tokPtr);
                        putLineMarker(tokPtr);
722
723
724
725
                        if (grammar == TestGrammar) {
                            parseError(fL1S("Assignment not permitted in this context."));
                            pro->setOk(false);
                        } else if (wordCount != 1) {
726
                            parseError(fL1S("Assignment needs exactly one word on the left hand side."));
727
728
729
730
                            pro->setOk(false);
                            // Put empty variable name.
                        } else {
                            putBlock(tokPtr, buf, ptr - buf);
731
732
733
734
735
736
                        }
                        putTok(tokPtr, tok);
                        context = CtxValue;
                        ptr = ++tokPtr;
                        goto nextToken;
                    }
737
738
739
740
741
                } else { // context == CtxValue
                    if (c == '{') {
                        ++parens;
                    } else if (c == '}') {
                        if (!parens) {
742
743
                            FLUSH_RHS_LITERAL();
                            FLUSH_VALUE_LIST();
744
745
746
747
                            context = CtxTest;
                            goto closeScope;
                        }
                        --parens;
748
749
750
                    } else if (c == '=') {
                        if (indent < lastIndent)
                            languageWarning(fL1S("Possible accidental line continuation"));
751
                    }
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
                }
                if (putSpace) {
                    putSpace = false;
                    *ptr++ = ' ';
                }
                *ptr++ = c;
              nextChr:
                if (cur == end)
                    goto lineEnd;
                c = *cur++;
            }

          lineEnd:
            if (lineCont) {
                if (quote) {
                    putSpace = true;
                } else {
769
770
                    FLUSH_LITERAL();
                    needSep = TokNewStr;
771
772
773
774
775
776
                    ptr += (context == CtxTest) ? 4 : 2;
                    xprPtr = ptr;
                }
            } else {
                cur = cptr;
              flushLine:
777
                FLUSH_LITERAL();
778
779
                if (quote) {
                    parseError(fL1S("Missing closing %1 quote").arg(QChar(quote)));
780
781
782
783
784
785
                    if (!xprStack.isEmpty()) {
                        context = xprStack.at(0).context;
                        xprStack.clear();
                    }
                    goto flErr;
                } else if (!xprStack.isEmpty()) {
786
                    parseError(fL1S("Missing closing parenthesis in function call"));
787
788
789
790
791
792
793
794
795
796
797
                    context = xprStack.at(0).context;
                    xprStack.clear();
                  flErr:
                    pro->setOk(false);
                    if (context == CtxValue) {
                        tokPtr[-1] = 0; // sizehint
                        putTok(tokPtr, TokValueTerminator);
                    } else {
                        bogusTest(tokPtr);
                    }
                } else if (context == CtxValue) {
798
                    FLUSH_VALUE_LIST();
799
800
                    if (parens)
                        languageWarning(fL1S("Possible braces mismatch"));
801
                } else {
802
                    finalizeCond(tokPtr, buf, ptr, wordCount);
803
                }
804
                if (!cur)
805
                    break;
806
807
808
                ++m_lineNo;
                goto freshLine;
            }
809

810
        lastIndent = indent;
811
812
813
814
815
816
        lineMarked = false;
      ignore:
        cur = cptr;
        ++m_lineNo;
    }

817
818
819
820
821
822
823
    flushScopes(tokPtr);
    if (m_blockstack.size() > 1) {
        parseError(fL1S("Missing closing brace(s)."));
        pro->setOk(false);
    }
    while (m_blockstack.size())
        leaveScope(tokPtr);
824
825
    tokBuff.resize(tokPtr - (ushort *)tokBuff.constData()); // Reserved capacity stays
    *pro->itemsRef() = tokBuff;
826
827
    return true;

828
#undef FLUSH_VALUE_LIST
829
830
831
832
833
#undef FLUSH_LITERAL
#undef FLUSH_LHS_LITERAL
#undef FLUSH_RHS_LITERAL
}

834
void QMakeParser::putLineMarker(ushort *&tokPtr)
835
836
837
838
839
840
841
842
{
    if (m_markLine) {
        *tokPtr++ = TokLine;
        *tokPtr++ = (ushort)m_markLine;
        m_markLine = 0;
    }
}

843
void QMakeParser::enterScope(ushort *&tokPtr, bool special, ScopeState state)
844
{
845
    uchar nest = m_blockstack.top().nest;
846
847
848
    m_blockstack.resize(m_blockstack.size() + 1);
    m_blockstack.top().special = special;
    m_blockstack.top().start = tokPtr;
849
    m_blockstack.top().nest = nest;
850
851
852
853
854
855
856
    tokPtr += 2;
    m_state = state;
    m_canElse = false;
    if (special)
        m_markLine = m_lineNo;
}

857
void QMakeParser::leaveScope(ushort *&tokPtr)
858
859
860
861
862
863
864
865
866
867
868
869
870
871
{
    if (m_blockstack.top().inBranch) {
        // Put empty else block
        putBlockLen(tokPtr, 0);
    }
    if (ushort *start = m_blockstack.top().start) {
        putTok(tokPtr, TokTerminator);
        uint len = tokPtr - start - 2;
        start[0] = (ushort)len;
        start[1] = (ushort)(len >> 16);
    }
    m_blockstack.resize(m_blockstack.size() - 1);
}

Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
872
// If we are on a fresh line, close all open one-line scopes.
873
void QMakeParser::flushScopes(ushort *&tokPtr)
874
875
876
877
878
879
880
881
882
883
884
885
886
{
    if (m_state == StNew) {
        while (!m_blockstack.top().braceLevel && m_blockstack.size() > 1)
            leaveScope(tokPtr);
        if (m_blockstack.top().inBranch) {
            m_blockstack.top().inBranch = false;
            // Put empty else block
            putBlockLen(tokPtr, 0);
        }
        m_canElse = false;
    }
}

Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
887
// If there is a pending conditional, enter a new scope, otherwise flush scopes.
888
void QMakeParser::flushCond(ushort *&tokPtr)
889
890
891
892
893
894
895
896
897
898
{
    if (m_state == StCond) {
        putTok(tokPtr, TokBranch);
        m_blockstack.top().inBranch = true;
        enterScope(tokPtr, false, StNew);
    } else {
        flushScopes(tokPtr);
    }
}

899
void QMakeParser::finalizeTest(ushort *&tokPtr)
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
{
    flushScopes(tokPtr);
    putLineMarker(tokPtr);
    if (m_operator != NoOperator) {
        putTok(tokPtr, (m_operator == AndOperator) ? TokAnd : TokOr);
        m_operator = NoOperator;
    }
    if (m_invert) {
        putTok(tokPtr, TokNot);
        m_invert = false;
    }
    m_state = StCond;
    m_canElse = true;
}

915
void QMakeParser::bogusTest(ushort *&tokPtr)
916
917
918
919
920
921
922
923
924
{
    flushScopes(tokPtr);
    m_operator = NoOperator;
    m_invert = false;
    m_state = StCond;
    m_canElse = true;
    m_proFile->setOk(false);
}

925
void QMakeParser::finalizeCond(ushort *&tokPtr, ushort *uc, ushort *ptr, int wordCount)
926
{
927
928
929
    if (wordCount != 1) {
        if (wordCount) {
            parseError(fL1S("Extra characters after test expression."));
930
            bogusTest(tokPtr);
931
        }
932
        return;
933
    }
934
935
936
937
938
939
940
941
942
943
944
945
946
947

    // Check for magic tokens
    if (*uc == TokHashLiteral) {
        uint nlen = uc[3];
        ushort *uce = uc + 4 + nlen;
        if (uce == ptr) {
            m_tmp.setRawData((QChar *)uc + 4, nlen);
            if (!m_tmp.compare(statics.strelse, Qt::CaseInsensitive)) {
                if (m_invert || m_operator != NoOperator) {
                    parseError(fL1S("Unexpected operator in front of else."));
                    return;
                }
                BlockScope &top = m_blockstack.top();
                if (m_canElse && (!top.special || top.braceLevel)) {
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
948
949
                    // A list of tests (the last one likely with side effects),
                    // but no assignment, scope, etc.
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
                    putTok(tokPtr, TokBranch);
                    // Put empty then block
                    putBlockLen(tokPtr, 0);
                    enterScope(tokPtr, false, StCtrl);
                    return;
                }
                forever {
                    BlockScope &top = m_blockstack.top();
                    if (top.inBranch && (!top.special || top.braceLevel)) {
                        top.inBranch = false;
                        enterScope(tokPtr, false, StCtrl);
                        return;
                    }
                    if (top.braceLevel || m_blockstack.size() == 1)
                        break;
                    leaveScope(tokPtr);
                }
                parseError(fL1S("Unexpected 'else'."));
                return;
            }
        }
    }

    finalizeTest(tokPtr);
    putBlock(tokPtr, uc, ptr - uc);
    putTok(tokPtr, TokCondition);
}

978
void QMakeParser::finalizeCall(ushort *&tokPtr, ushort *uc, ushort *ptr, int argc)
979
980
981
982
983
984
985
986
987
988
{
    // Check for magic tokens
    if (*uc == TokHashLiteral) {
        uint nlen = uc[3];
        ushort *uce = uc + 4 + nlen;
        if (*uce == TokTestCall) {
            uce++;
            m_tmp.setRawData((QChar *)uc + 4, nlen);
            const QString *defName;
            ushort defType;
989
            uchar nest;
990
991
992
993
            if (m_tmp == statics.strfor) {
                if (m_invert || m_operator == OrOperator) {
                    // '|' could actually work reasonably, but qmake does nonsense here.
                    parseError(fL1S("Unexpected operator in front of for()."));
994
                    bogusTest(tokPtr);
995
996
                    return;
                }
997
998
                flushCond(tokPtr);
                putLineMarker(tokPtr);
999
                if (*uce == (TokLiteral|TokNewStr)) {
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
                    nlen = uce[1];
                    uc = uce + 2 + nlen;
                    if (*uc == TokFuncTerminator) {
                        // for(literal) (only "ever" would be legal if qmake was sane)
                        putTok(tokPtr, TokForLoop);
                        putHashStr(tokPtr, (ushort *)0, (uint)0);
                        putBlockLen(tokPtr, 1 + 3 + nlen + 1);
                        putTok(tokPtr, TokHashLiteral);
                        putHashStr(tokPtr, uce + 2, nlen);
                      didFor:
                        putTok(tokPtr, TokValueTerminator);
                        enterScope(tokPtr, true, StCtrl);
1012
                        m_blockstack.top().nest |= NestLoop;
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
                        return;
                    } else if (*uc == TokArgSeparator && argc == 2) {
                        // for(var, something)
                        uc++;
                        putTok(tokPtr, TokForLoop);
                        putHashStr(tokPtr, uce + 2, nlen);
                      doFor:
                        nlen = ptr - uc;
                        putBlockLen(tokPtr, nlen + 1);
                        putBlock(tokPtr, uc, nlen);
                        goto didFor;
                    }
                } else if (argc == 1) {
                    // for(non-literal) (this wouldn't be here if qmake was sane)
                    putTok(tokPtr, TokForLoop);
                    putHashStr(tokPtr, (ushort *)0, (uint)0);
                    uc = uce;
                    goto doFor;
                }
                parseError(fL1S("Syntax is for(var, list), for(var, forever) or for(ever)."));
                return;
            } else if (m_tmp == statics.strdefineReplace) {
                defName = &statics.strdefineReplace;
                defType = TokReplaceDef;
                goto deffunc;
            } else if (m_tmp == statics.strdefineTest) {
                defName = &statics.strdefineTest;
                defType = TokTestDef;
              deffunc:
                if (m_invert) {
                    parseError(fL1S("Unexpected operator in front of function definition."));
1044
                    bogusTest(tokPtr);
1045
1046
                    return;
                }
1047
1048
                flushScopes(tokPtr);
                putLineMarker(tokPtr);
1049
                if (*uce == (TokLiteral|TokNewStr)) {
1050
1051
1052
1053
1054
1055
1056
1057
1058
                    uint nlen = uce[1];
                    if (uce[nlen + 2] == TokFuncTerminator) {
                        if (m_operator != NoOperator) {
                            putTok(tokPtr, (m_operator == AndOperator) ? TokAnd : TokOr);
                            m_operator = NoOperator;
                        }
                        putTok(tokPtr, defType);
                        putHashStr(tokPtr, uce + 2, nlen);
                        enterScope(tokPtr, true, StCtrl);
1059
                        m_blockstack.top().nest = NestFunction;
1060
1061
1062
1063
1064
                        return;
                    }
                }
                parseError(fL1S("%1(function) requires one literal argument.").arg(*defName));
                return;
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
            } else if (m_tmp == statics.strreturn) {
                if (argc > 1) {
                    parseError(fL1S("return() requires zero or one argument."));
                    bogusTest(tokPtr);
                    return;
                }
                defType = TokReturn;
                nest = NestFunction;
                goto ctrlstm2;
            } else if (m_tmp == statics.strnext) {
                defType = TokNext;
                goto ctrlstm;
            } else if (m_tmp == statics.strbreak) {
                defType = TokBreak;
              ctrlstm:
                if (*uce != TokFuncTerminator) {
                    parseError(fL1S("%1() requires zero arguments.").arg(m_tmp));
                    bogusTest(tokPtr);
                    return;
                }
                nest = NestLoop;
              ctrlstm2:
                if (m_invert) {
                    parseError(fL1S("Unexpected NOT operator in front of %1().").arg(m_tmp));
                    bogusTest(tokPtr);
                    return;
                }
                if (!(m_blockstack.top().nest & nest)) {
                    parseError(fL1S("Unexpected %1().").arg(m_tmp));
                    bogusTest(tokPtr);
                    return;
                }
                finalizeTest(tokPtr);
                putBlock(tokPtr, uce, ptr - uce - 1); // Only for TokReturn
                putTok(tokPtr, defType);
                return;
1101
1102
1103
1104
            } else if (m_tmp == statics.stroption) {
                if (m_state != StNew || m_blockstack.top().braceLevel || m_blockstack.size() > 1
                        || m_invert || m_operator != NoOperator) {
                    parseError(fL1S("option() must appear outside any control structures."));
1105
                    bogusTest(tokPtr);
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
                    return;
                }
                if (*uce == (TokLiteral|TokNewStr)) {
                    uint nlen = uce[1];
                    if (uce[nlen + 2] == TokFuncTerminator) {
                        m_tmp.setRawData((QChar *)uce + 2, nlen);
                        if (m_tmp == statics.strhost_build) {
                            m_proFile->setHostBuild(true);
                        } else {
                            parseError(fL1S("Unknown option() %1.").arg(m_tmp));
                        }
                        return;
                    }
                }
                parseError(fL1S("option() requires one literal argument."));
                return;
1122
1123
1124
1125
1126
1127
1128
1129
            }
        }
    }

    finalizeTest(tokPtr);
    putBlock(tokPtr, uc, ptr - uc);
}

1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
bool QMakeParser::resolveVariable(ushort *xprPtr, int tlen, int needSep, ushort **ptr,
                                  ushort **buf, QString *xprBuff,
                                  ushort **tokPtr, QString *tokBuff,
                                  const ushort *cur, const QString &in)
{
    QString out;
    m_tmp.setRawData((const QChar *)xprPtr, tlen);
    if (m_tmp == statics.strLINE) {
        out.setNum(m_lineNo);
    } else if (m_tmp == statics.strFILE) {
        out = m_proFile->fileName();
        // The string is typically longer than the variable reference, so we need
        // to ensure that there is enough space in the output buffer - as unlikely
        // as an overflow is to actually happen in practice.
        int need = (in.length() - (cur - (const ushort *)in.constData()) + 2) * 5 + out.length();
        int tused = *tokPtr - (ushort *)tokBuff->constData();
        int xused;
        int total;
        bool ptrFinal = xprPtr >= (ushort *)tokBuff->constData()
                && xprPtr < (ushort *)tokBuff->constData() + tokBuff->capacity();
        if (ptrFinal) {
            xused = xprPtr - (ushort *)tokBuff->constData();
            total = xused + need;
        } else {
            xused = xprPtr - *buf;
            total = tused + xused + need;
        }
        if (tokBuff->capacity() < total) {
            tokBuff->reserve(total);
            *tokPtr = (ushort *)tokBuff->constData() + tused;
            xprBuff->reserve(total);
            *buf = (ushort *)xprBuff->constData();
            xprPtr = (ptrFinal ? (ushort *)tokBuff->constData() : *buf) + xused;
        }
    } else if (m_tmp == statics.strLITERAL_HASH) {
        out = QLatin1String("#");
    } else if (m_tmp == statics.strLITERAL_DOLLAR) {
        out = QLatin1String("$");
    } else if (m_tmp == statics.strLITERAL_WHITESPACE) {
        out = QLatin1String("\t");
    } else {
        return false;
    }
    xprPtr -= 2; // Was set up for variable reference
    xprPtr[-2] = TokLiteral | needSep;
    xprPtr[-1] = out.length();
    memcpy(xprPtr, out.constData(), out.length() * 2);
    *ptr = xprPtr + out.length();
    return true;
}

Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
1181
void QMakeParser::message(int type, const QString &msg) const
1182
{
1183
    if (!m_inError && m_handler)
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
1184
        m_handler->message(type, msg, m_proFile->fileName(), m_lineNo);
1185
1186
1187
}

QT_END_NAMESPACE