qmakeparser.cpp 44.1 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
3
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** Contact: http://www.qt-project.org/legal
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8
9
10
11
12
13
14
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15
16
**
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17
18
19
20
21
22
23
24
25
** Alternatively, 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.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
con's avatar
con committed
26
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
29

30
#include "qmakeparser.h"
31
32

#include "ioutils.h"
33
using namespace QMakeInternal;
34

35
#include <qfile.h>
36
#ifdef PROPARSER_THREAD_SAFE
37
# include <qthreadpool.h>
38
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
#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)

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

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

110
111
}

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

    statics.strelse = QLatin1String("else");
    statics.strfor = QLatin1String("for");
    statics.strdefineTest = QLatin1String("defineTest");
    statics.strdefineReplace = QLatin1String("defineReplace");
121
    statics.stroption = QLatin1String("option");
122
123
124
    statics.strreturn = QLatin1String("return");
    statics.strnext = QLatin1String("next");
    statics.strbreak = QLatin1String("break");
125
    statics.strhost_build = QLatin1String("host_build");
126
127
128
129
130
    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");
131
132
}

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

141
ProFile *QMakeParser::parsedProFile(const QString &fileName, bool cache)
142
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
{
    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);
173
            if (!read(pro)) {
174
175
176
                delete pro;
                pro = 0;
            } else {
177
                pro->itemsRef()->squeeze();
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
                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);
194
        if (!read(pro)) {
195
196
197
198
199
200
201
            delete pro;
            pro = 0;
        }
    }
    return pro;
}

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

213
214
215
216
217
218
void QMakeParser::discardFileFromCache(const QString &fileName)
{
    if (m_cache)
        m_cache->discardFile(fileName);
}

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

Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
229
    QByteArray bcont = file.readAll();
230
    if (bcont.startsWith("\xef\xbb\xbf")) {
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
231
232
233
234
235
236
237
        // UTF-8 BOM will cause subtle errors
        m_handler->message(QMakeParserHandler::ParserIoError,
                           fL1S("Unexpected UTF-8 BOM in %1").arg(pro->fileName()));
        return false;
    }
    QString content(QString::fromLocal8Bit(bcont));
    bcont.clear();
238
    file.close();
239
    return read(pro, content, 1, FullGrammar);
240
241
}

242
void QMakeParser::putTok(ushort *&tokPtr, ushort tok)
243
244
245
246
{
    *tokPtr++ = tok;
}

247
void QMakeParser::putBlockLen(ushort *&tokPtr, uint len)
248
249
250
251
252
{
    *tokPtr++ = (ushort)len;
    *tokPtr++ = (ushort)(len >> 16);
}

253
void QMakeParser::putBlock(ushort *&tokPtr, const ushort *buf, uint len)
254
255
256
257
258
{
    memcpy(tokPtr, buf, len * 2);
    tokPtr += len;
}

259
void QMakeParser::putHashStr(ushort *&pTokPtr, const ushort *buf, uint len)
260
261
262
263
264
265
266
267
268
269
{
    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;
}

270
void QMakeParser::finalizeHashStr(ushort *buf, uint len)
271
272
273
274
275
276
277
278
{
    buf[-4] = TokHashLiteral;
    buf[-1] = len;
    uint hash = ProString::hash((const QChar *)buf, len);
    buf[-3] = (ushort)hash;
    buf[-2] = (ushort)(hash >> 16);
}

279
bool QMakeParser::read(ProFile *pro, const QString &in, int line, SubGrammar grammar)
280
{
281
    m_proFile = pro;
282
    m_lineNo = line;
283
284
285
286
287
288

    // 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 =>
289
290
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokAssign(1) + 0(1) +
    //   TokValueTerminator(1) == 8 (9)
291
    // - non-empty assignment "A=B C":5 =>
292
    //   TokHashLiteral(1) + hash(2) + len(1) + "A"(1) + TokAssign(1) + 2(1) +
293
    //   TokLiteral(1) + len(1) + "B"(1) +
294
    //   TokLiteral(1) + len(1) + "C"(1) + TokValueTerminator(1) == 14 (15)
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
    // - 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
315
    ushort *buf = (ushort *)xprBuff.constData();
316
317

    // Parser state
318
319
    m_blockstack.clear();
    m_blockstack.resize(1);
320
321
322
323
324
325
326
327
328
329
330
331

    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;
332
    m_inError = false;
333
    int parens = 0; // Braces in value context
334
    int argc = 0;
335
    int wordCount = 0; // Number of words in currently accumulated expression
336
    int lastIndent = 0; // Previous line's indentation, to detect accidental continuation abuse
337
338
    bool putSpace = false; // Only ever true inside quoted string
    bool lineMarked = true; // For in-expression markers
339
    ushort needSep = TokNewStr; // Complementary to putSpace: separator outside quotes
340
341
342
    ushort quote = 0;
    ushort term = 0;

343
344
345
346
347
348
349
350
351
    Context context;
    ushort *ptr;
    if (grammar == ValueGrammar) {
        context = CtxPureValue;
        ptr = tokPtr + 2;
    } else {
        context = CtxTest;
        ptr = buf + 4;
    }
352
353
    ushort *xprPtr = ptr;

354
#define FLUSH_LHS_LITERAL() \
355
356
357
    do { \
        if ((tlen = ptr - xprPtr)) { \
            finalizeHashStr(xprPtr, tlen); \
358
359
360
361
            if (needSep) { \
                wordCount++; \
                needSep = 0; \
            } \
362
363
364
365
366
        } else { \
            ptr -= 4; \
        } \
    } while (0)

367
#define FLUSH_RHS_LITERAL() \
368
369
370
371
    do { \
        if ((tlen = ptr - xprPtr)) { \
            xprPtr[-2] = TokLiteral | needSep; \
            xprPtr[-1] = tlen; \
372
373
374
375
            if (needSep) { \
                wordCount++; \
                needSep = 0; \
            } \
376
377
378
379
380
        } else { \
            ptr -= 2; \
        } \
    } while (0)

381
#define FLUSH_LITERAL() \
382
383
    do { \
        if (context == CtxTest) \
384
            FLUSH_LHS_LITERAL(); \
385
        else \
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
            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); \
401
402
    } while (0)

403
404
405
406
407
408
409
410
411
412
413
414
415
    const ushort *end; // End of this line
    const ushort *cptr; // Start of next line
    bool lineCont;
    int indent;

    if (context == CtxPureValue) {
        end = (const ushort *)in.unicode() + in.length();
        cptr = 0;
        lineCont = false;
        indent = 0; // just gcc being stupid
        goto nextChr;
    }

416
417
418
419
    forever {
        ushort c;

        // First, skip leading whitespace
420
        for (indent = 0; ; ++cur, ++indent) {
421
422
423
            c = *cur;
            if (c == '\n') {
                ++cur;
424
                goto flushLine;
425
            } else if (!c) {
426
                cur = 0;
427
                goto flushLine;
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
            } else if (c != ' ' && c != '\t' && c != '\r') {
                break;
            }
        }

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

          lineEnd:
            if (lineCont) {
                if (quote) {
                    putSpace = true;
                } else {
806
807
                    FLUSH_LITERAL();
                    needSep = TokNewStr;
808
809
810
811
812
813
                    ptr += (context == CtxTest) ? 4 : 2;
                    xprPtr = ptr;
                }
            } else {
                cur = cptr;
              flushLine:
814
                FLUSH_LITERAL();
815
816
                if (quote) {
                    parseError(fL1S("Missing closing %1 quote").arg(QChar(quote)));
817
818
819
820
821
822
                    if (!xprStack.isEmpty()) {
                        context = xprStack.at(0).context;
                        xprStack.clear();
                    }
                    goto flErr;
                } else if (!xprStack.isEmpty()) {
823
                    parseError(fL1S("Missing closing parenthesis in function call"));
824
825
826
827
828
829
830
                    context = xprStack.at(0).context;
                    xprStack.clear();
                  flErr:
                    pro->setOk(false);
                    if (context == CtxValue) {
                        tokPtr[-1] = 0; // sizehint
                        putTok(tokPtr, TokValueTerminator);
831
832
                    } else if (context == CtxPureValue) {
                        putTok(tokPtr, TokValueTerminator);
833
834
835
836
                    } else {
                        bogusTest(tokPtr);
                    }
                } else if (context == CtxValue) {
837
                    FLUSH_VALUE_LIST();
838
839
                    if (parens)
                        languageWarning(fL1S("Possible braces mismatch"));
840
841
842
                } else if (context == CtxPureValue) {
                    tokPtr = ptr;
                    putTok(tokPtr, TokValueTerminator);
843
                } else {
844
                    finalizeCond(tokPtr, buf, ptr, wordCount);
845
                }
846
                if (!cur)
847
                    break;
848
849
850
                ++m_lineNo;
                goto freshLine;
            }
851

852
        lastIndent = indent;
853
854
855
856
857
858
        lineMarked = false;
      ignore:
        cur = cptr;
        ++m_lineNo;
    }

859
860
861
862
863
864
865
    flushScopes(tokPtr);
    if (m_blockstack.size() > 1) {
        parseError(fL1S("Missing closing brace(s)."));
        pro->setOk(false);
    }
    while (m_blockstack.size())
        leaveScope(tokPtr);
866
867
    tokBuff.resize(tokPtr - (ushort *)tokBuff.constData()); // Reserved capacity stays
    *pro->itemsRef() = tokBuff;
868
869
    return true;

870
#undef FLUSH_VALUE_LIST
871
872
873
874
875
#undef FLUSH_LITERAL
#undef FLUSH_LHS_LITERAL
#undef FLUSH_RHS_LITERAL
}

876
void QMakeParser::putLineMarker(ushort *&tokPtr)
877
878
879
880
881
882
883
884
{
    if (m_markLine) {
        *tokPtr++ = TokLine;
        *tokPtr++ = (ushort)m_markLine;
        m_markLine = 0;
    }
}

885
void QMakeParser::enterScope(ushort *&tokPtr, bool special, ScopeState state)
886
{
887
    uchar nest = m_blockstack.top().nest;
888
889
890
    m_blockstack.resize(m_blockstack.size() + 1);
    m_blockstack.top().special = special;
    m_blockstack.top().start = tokPtr;
891
    m_blockstack.top().nest = nest;
892
893
894
895
896
897
898
    tokPtr += 2;
    m_state = state;
    m_canElse = false;
    if (special)
        m_markLine = m_lineNo;
}

899
void QMakeParser::leaveScope(ushort *&tokPtr)
900
901
902
903
904
905
906
907
908
909
910
911
912
913
{
    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
914
// If we are on a fresh line, close all open one-line scopes.
915
void QMakeParser::flushScopes(ushort *&tokPtr)
916
917
918
919
920
921
922
923
924
925
926
927
928
{
    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
929
// If there is a pending conditional, enter a new scope, otherwise flush scopes.
930
void QMakeParser::flushCond(ushort *&tokPtr)
931
932
933
934
935
936
937
938
939
940
{
    if (m_state == StCond) {
        putTok(tokPtr, TokBranch);
        m_blockstack.top().inBranch = true;
        enterScope(tokPtr, false, StNew);
    } else {
        flushScopes(tokPtr);
    }
}

941
void QMakeParser::finalizeTest(ushort *&tokPtr)
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
{
    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;
}

957
void QMakeParser::bogusTest(ushort *&tokPtr)
958
959
960
961
962
963
964
965
966
{
    flushScopes(tokPtr);
    m_operator = NoOperator;
    m_invert = false;
    m_state = StCond;
    m_canElse = true;
    m_proFile->setOk(false);
}

967
void QMakeParser::finalizeCond(ushort *&tokPtr, ushort *uc, ushort *ptr, int wordCount)
968
{
969
970
971
    if (wordCount != 1) {
        if (wordCount) {
            parseError(fL1S("Extra characters after test expression."));
972
            bogusTest(tokPtr);
973
        }
974
        return;
975
    }
976
977
978
979
980
981
982
983
984
985
986
987
988
989

    // 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
990
991
                    // A list of tests (the last one likely with side effects),
                    // but no assignment, scope, etc.
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
                    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);
}

1020
void QMakeParser::finalizeCall(ushort *&tokPtr, ushort *uc, ushort *ptr, int argc)
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
{
    // 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;
            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()."));
1035
                    bogusTest(tokPtr);
1036
1037
                    return;
                }
1038
1039
                flushCond(tokPtr);
                putLineMarker(tokPtr);
1040
                if (*uce == (TokLiteral|TokNewStr)) {
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
                    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);
1053
                        m_blockstack.top().nest |= NestLoop;
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
                        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."));
1085
                    bogusTest(tokPtr);
1086
1087
                    return;
                }
1088
1089
                flushScopes(tokPtr);
                putLineMarker(tokPtr);
1090
                if (*uce == (TokLiteral|TokNewStr)) {
1091
1092
1093
1094
1095
1096
1097
1098
1099
                    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);
1100
                        m_blockstack.top().nest = NestFunction;
1101
1102
1103
1104
1105
                        return;
                    }
                }
                parseError(fL1S("%1(function) requires one literal argument.").arg(*defName));
                return;
1106
            } else if (m_tmp == statics.strreturn) {
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
                if (m_blockstack.top().nest & NestFunction) {
                    if (argc > 1) {
                        parseError(fL1S("return() requires zero or one argument."));
                        bogusTest(tokPtr);
                        return;
                    }
                } else {
                    if (*uce != TokFuncTerminator) {
                        parseError(fL1S("Top-level return() requires zero arguments."));
                        bogusTest(tokPtr);
                        return;
                    }
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
                }
                defType = TokReturn;
                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;
                }
1133
1134
                if (!(m_blockstack.top().nest & NestLoop)) {
                    parseError(fL1S("Unexpected %1().").arg(m_tmp));
1135
1136
1137
                    bogusTest(tokPtr);
                    return;
                }
1138
1139
1140
              ctrlstm2:
                if (m_invert) {
                    parseError(fL1S("Unexpected NOT operator in front of %1().").arg(m_tmp));
1141
1142
1143
1144
1145
1146
1147
                    bogusTest(tokPtr);
                    return;
                }
                finalizeTest(tokPtr);
                putBlock(tokPtr, uce, ptr - uce - 1); // Only for TokReturn
                putTok(tokPtr, defType);
                return;
1148
1149
1150
1151
            } 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."));
1152
                    bogusTest(tokPtr);
1153
1154
1155
1156
1157
1158
                    return;
                }
                if (*uce == (TokLiteral|TokNewStr)) {
                    uint nlen = uce[1];
                    if (uce[nlen + 2] == TokFuncTerminator) {
                        m_tmp.setRawData((QChar *)uce + 2, nlen);
1159
                        if (m_tmp == statics.strhost_build)
1160
                            m_proFile->setHostBuild(true);
1161
                        else
1162
1163
1164
1165
1166
1167
                            parseError(fL1S("Unknown option() %1.").arg(m_tmp));
                        return;
                    }
                }
                parseError(fL1S("option() requires one literal argument."));
                return;
1168
1169
1170
1171
1172
1173
1174
1175
            }
        }
    }

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

1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
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
1227
void QMakeParser::message(int type, const QString &msg) const
1228
{
1229
    if (!m_inError && m_handler)
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
1230
        m_handler->message(type, msg, m_proFile->fileName(), m_lineNo);
1231
1232
1233
}

QT_END_NAMESPACE