/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the tools applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

/*
  tokenizer.h
*/

#ifndef TOKENIZER_H
#define TOKENIZER_H

#include "location.h"

#include <QtCore/qfile.h>
#include <QtCore/qstack.h>
#include <QtCore/qstring.h>

QT_BEGIN_NAMESPACE

/*
  Here come the C++ tokens we support.  The first part contains
  all-purpose tokens; then come keywords.

  If you add a keyword, make sure to modify the keyword array in
  tokenizer.cpp as well, and possibly adjust Tok_FirstKeyword and
  Tok_LastKeyword.
*/
enum {
    Tok_Eoi,
    Tok_Ampersand,
    Tok_Aster,
    Tok_Caret,
    Tok_LeftParen,
    Tok_RightParen,
    Tok_LeftParenAster,
    Tok_Equal,
    Tok_LeftBrace,
    Tok_RightBrace,
    Tok_Semicolon,
    Tok_Colon,
    Tok_LeftAngle,
    Tok_RightAngle,
    Tok_Comma,
    Tok_Ellipsis,
    Tok_Gulbrandsen,
    Tok_LeftBracket,
    Tok_RightBracket,
    Tok_Tilde,
    Tok_SomeOperator,
    Tok_Number,
    Tok_String,
    Tok_Doc,
    Tok_Comment,
    Tok_Ident,
    Tok_At,
    Tok_char,
    Tok_class,
    Tok_const,
    Tok_double,
    Tok_enum,
    Tok_explicit,
    Tok_friend,
    Tok_inline,
    Tok_int,
    Tok_long,
    Tok_namespace,
    Tok_operator,
    Tok_private,
    Tok_protected,
    Tok_public,
    Tok_short,
    Tok_signals,
    Tok_signed,
    Tok_slots,
    Tok_static,
    Tok_struct,
    Tok_template,
    Tok_typedef,
    Tok_typename,
    Tok_union,
    Tok_unsigned,
    Tok_using,
    Tok_virtual,
    Tok_void,
    Tok_volatile,
    Tok_int64,
    Tok_default,
    Tok_delete,
    Tok_final,
    Tok_override,
    Tok_Q_OBJECT,
    Tok_Q_OVERRIDE,
    Tok_Q_PROPERTY,
    Tok_Q_PRIVATE_PROPERTY,
    Tok_Q_DECLARE_SEQUENTIAL_ITERATOR,
    Tok_Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR,
    Tok_Q_DECLARE_ASSOCIATIVE_ITERATOR,
    Tok_Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR,
    Tok_Q_DECLARE_FLAGS,
    Tok_Q_SIGNALS,
    Tok_Q_SLOTS,
    Tok_QT_COMPAT,
    Tok_QT_COMPAT_CONSTRUCTOR,
    Tok_QT_DEPRECATED,
    Tok_QT_MOC_COMPAT,
    Tok_QT_MODULE,
    Tok_QT3_SUPPORT,
    Tok_QT3_SUPPORT_CONSTRUCTOR,
    Tok_QT3_MOC_SUPPORT,
    Tok_QDOC_PROPERTY,
    Tok_QPrivateSignal,
    Tok_FirstKeyword = Tok_char,
    Tok_LastKeyword = Tok_QPrivateSignal
};

/*
  The Tokenizer class implements lexical analysis of C++ source
  files.

  Not every operator or keyword of C++ is recognized; only those
  that are interesting to us. Some Qt keywords or macros are also
  recognized.
*/

class Tokenizer
{
    Q_DECLARE_TR_FUNCTIONS(QDoc::Tokenizer)

public:
    Tokenizer(const Location &loc, const QByteArray &in);
    Tokenizer(const Location &loc, QFile &file);

    ~Tokenizer();

    int getToken();
    void setParsingFnOrMacro(bool macro) { parsingMacro = macro; }
    bool parsingFnOrMacro() const { return parsingMacro; }

    const Location &location() const { return yyTokLoc; }
    QString previousLexeme() const;
    QString lexeme() const;
    QString version() const { return yyVersion; }
    int braceDepth() const { return yyBraceDepth; }
    int parenDepth() const { return yyParenDepth; }
    int bracketDepth() const { return yyBracketDepth; }
    Location &tokenLocation() { return yyTokLoc; }

    static void initialize();
    static void terminate();
    static bool isTrue(const QString &condition);

private:
    void init();
    void start(const Location &loc);
    /*
      Represents the maximum amount of characters that a token can be composed
      of.

      When a token with more characters than the maximum amount is encountered, a
      warning is issued and parsing continues, discarding all characters from the
      currently parsed token that don't fit into the buffer.
    */
    enum { yyLexBufSize = 1048576 };
    int getch() { return yyPos == yyIn.size() ? EOF : yyIn[yyPos++]; }

    inline int getChar()
    {
        if (yyCh == EOF)
            return EOF;
        if (yyLexLen < yyLexBufSize - 1) {
            yyLex[yyLexLen++] = (char)yyCh;
            yyLex[yyLexLen] = '\0';
        }
        yyCurLoc.advance(yyCh);
        int ch = getch();
        if (ch == EOF)
            return EOF;
        // cast explicitly to make sure the value of ch
        // is in range [0..255] to avoid assert messages
        // when using debug CRT that checks its input.
        return int(uint(uchar(ch)));
    }

    int getTokenAfterPreprocessor();
    void pushSkipping(bool skip);
    bool popSkipping();

    Location yyTokLoc;
    Location yyCurLoc;
    char *yyLexBuf1;
    char *yyLexBuf2;
    char *yyPrevLex;
    char *yyLex;
    size_t yyLexLen;
    QStack<bool> yyPreprocessorSkipping;
    int yyNumPreprocessorSkipping;
    int yyBraceDepth;
    int yyParenDepth;
    int yyBracketDepth;
    int yyCh;

    QString yyVersion;
    bool parsingMacro;

protected:
    QByteArray yyIn;
    int yyPos;
};

QT_END_NAMESPACE

#endif
