/****************************************************************************

**

** Copyright (C) 2001-2004 Roberto Raggi

** All rights reserved.

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

**

** This file is part of the qt3to4 porting application of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** 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, Nokia gives you certain additional

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef RPP_H

#define RPP_H

#include "tokenengine.h"

#include "rpplexer.h"

#include "tokens.h"

#include "smallobject.h"

#include <QHash>

#include <QStringList>

#include <QFile>

#include <QByteArray>

#include <QDir>

#include <QMultiMap>

#include <ctype.h>

QT_BEGIN_NAMESPACE

namespace Rpp

{

struct Item;

struct ItemComposite;

struct Source;

struct Directive;

struct EmptyDirective;

struct ErrorDirective;

struct PragmaDirective;

struct IncludeDirective;

struct ConditionalDirective;

struct DefineDirective;

struct UndefDirective;

struct LineDirective;

struct NonDirective;

struct IfSection;

struct IfLikeDirective;

struct IfDirective;

struct ElifDirective;

struct IfdefLikeDirective;

struct IfdefDirective;

struct IfndefDirective;

struct ElseDirective;

struct EndifDirective;

struct Text;

struct Token;

struct TokenComposite;

struct IdToken;

struct NonIdToken;

struct PastingToken;

struct LineComment;

struct MultiLineComment;

struct WhiteSpace;

struct MacroDefinition;

struct MacroFunctionDefinition;

struct MacroParameters;

struct MacroParameter;

struct Expression;

struct UnaryExpression;

struct BinaryExpression;

struct ConditionalExpression;

struct StringLiteral;

struct IntLiteral;

struct MacroReference;

struct MacroFunctionReference;

struct MacroArguments;

struct MacroArgument;

struct Item

{

    virtual ~Item() {}

    virtual Item *parent() const = 0;

    virtual ItemComposite *toItemComposite() const

    { return 0; }

    virtual Item *toItem() const

    { return const_cast<Item *>(this); }

    virtual Directive *toDirective() const

    { return 0; }

    virtual Text *toText() const

    { return 0; }

    virtual Token *toToken() const

    { return 0; }

    virtual Source *toSource() const

    { return 0; }

    virtual Expression *toExpression() const

    { return 0; }

    virtual IfSection *toIfSection() const

    { return 0; }

    // Text returns the original text for an item, e.g.

    // the way it is found in the source

    virtual TokenEngine::TokenSection text() const

     { return TokenEngine::TokenSection(); }

protected:

    //using the default constructor for an item is

    //only allowded for subclasses.

    Item() {};

};

struct ItemComposite

{

    virtual ~ItemComposite() {}

    virtual int count() const = 0;

    virtual Item *item(int index) const = 0;

    virtual void add(Item *item) = 0;

/*

    Classes that inherit ItemComposite must implement this

    function themselves

    virtual ItemComposite *toItemComposite() const

    { return const_cast<ItemComposite *>(this); }

*/

};

struct Directive: public Item

{

    inline Directive(Item *parent = 0)

        : m_parent(parent), m_numLines(0) {}

    virtual Item *parent() const

    { return m_parent; }

    inline void setParent(Item *parent)

    { m_parent = parent;}

    void setNumLines(const int numLines)

    {m_numLines = numLines;}

    virtual Directive *toDirective() const

    { return const_cast<Directive *>(this); }

    virtual EmptyDirective *toEmptyDirective() const

    { return 0; }

    virtual ErrorDirective *toErrorDirective() const

    { return 0; }

    virtual PragmaDirective *toPragmaDirective() const

    { return 0; }

    virtual IncludeDirective *toIncludeDirective() const

    { return 0; }

    virtual ConditionalDirective *toConditionalDirective() const

    { return 0; }

    virtual DefineDirective *toDefineDirective() const

    { return 0; }

    virtual UndefDirective *toUndefDirective() const

    { return 0; }

    virtual LineDirective *toLineDirective() const

    { return 0; }

    virtual NonDirective *toNonDirective() const

    { return 0; }

    void setTokenSection(TokenEngine::TokenSection section)

    { m_tokenSection = section; }

    TokenEngine::TokenSection text() const

    { return m_tokenSection; }

protected:

    Item *m_parent;

    int m_numLines;

    TokenEngine::TokenSection m_tokenSection;

};

struct Token: public Item

{

    inline Token(Item *parent = 0)

        : m_tokenIndex(0), m_parent(parent) {}

    virtual Item *parent() const

    { return m_parent; }

    virtual MacroArguments *toMacroArguments() const

    { return 0; }

    virtual IdToken *toIdToken() const

    { return 0; }

    virtual NonIdToken *toNonIdToken() const

    { return 0; }

    virtual LineComment *toLineComment() const

    { return 0; }

    virtual MultiLineComment *toMultiLineComment() const

    { return 0; }

    virtual WhiteSpace *toWhiteSpace() const

    { return 0; }

    virtual Token *toToken() const

    { return const_cast<Token *>(this); }

    void setToken(int tokenIndex)

    { m_tokenIndex = tokenIndex;}

    int index() const

    { return m_tokenIndex; }

protected:

    int m_tokenIndex;

    Item *m_parent;

};

struct Text: public Item

{

    inline Text(Item *parent = 0)

        : m_parent(parent) {}

    virtual Text *toText() const

    { return const_cast<Text *>(this); }

    virtual Item *parent() const

    { return m_parent; }

    void setTokenSection(TokenEngine::TokenSection tokenSection)

    {m_tokenSection = tokenSection; }

    TokenEngine::TokenSection text() const

    { return m_tokenSection; }

    QVector<TokenEngine::TokenSection> cleanedText() const

    { return m_cleanedSection; }

    void setTokens( const QVector<Token *> &tokens )

    { m_tokens = tokens; }

    void addToken(Token *token)

    {m_tokens.append(token);}

    Token *token(int index) const

    {return m_tokens.at(index);}

    inline int count() const

    {return m_tokens.count();}

    QVector<Token *> tokenList() const

    { return m_tokens; }

protected:

    Item *m_parent;

    TokenEngine::TokenSection m_tokenSection;    // all tokens

    QVector<TokenEngine::TokenSection> m_cleanedSection; //comments removed

    QVector<Token *> m_tokens;

};

struct IdToken: public Token

{

    inline IdToken(Item *parent = 0)

        : Token(parent) {}

    virtual IdToken *toIdToken() const

    { return const_cast<IdToken *>(this); }

};

struct NonIdToken: public Token

{

    inline  NonIdToken(Item *parent = 0)

        : Token(parent) {}

    virtual NonIdToken *toNonIdToken() const

    { return const_cast< NonIdToken *>(this); }

};

struct LineComment : public NonIdToken

{

    inline LineComment(Item *parent = 0)

       : NonIdToken(parent) {}

    virtual LineComment *toLineComment() const

    { return const_cast< LineComment *>(this); }

};

struct MultiLineComment: public NonIdToken

{

    inline MultiLineComment(Item *parent = 0)

        : NonIdToken(parent) {}

    virtual MultiLineComment *toMultiLineComment() const

    { return const_cast< MultiLineComment *>(this); }

protected:

};

struct WhiteSpace: public NonIdToken

{

    inline WhiteSpace(Item *parent = 0)

        : NonIdToken(parent) {}

    virtual WhiteSpace *toWhiteSpace() const

    { return const_cast<WhiteSpace *>(this); }

};

struct Source: public Item, public ItemComposite

{

    Source(Item *parent = 0)

        :m_parent(parent) {}

    virtual Source *toSource() const

    { return const_cast<Source *>(this); }

    ItemComposite *toItemComposite() const

    { return const_cast<Source *>(this); }

    virtual int count() const

    { return m_items.count(); }

    virtual Item *item(int index) const

    {  return m_items.at(index); }

    inline QString fileName() const

    { return m_fileName; }

    void setFileName(const QString &fileName);

    virtual Item *parent() const

    { return m_parent; }

    inline void add(Item *item)

    {  m_items.append(item); }

private:

    Item *m_parent;

    QVector<Item *> m_items;

    QString m_fileName;

};

struct EmptyDirective: public Directive

{

    EmptyDirective(Item *item)

    : Directive(item) {}

    virtual EmptyDirective *toEmptyDirective() const

    { return const_cast<EmptyDirective *>(this); }

};

struct ErrorDirective: public Directive

{

    ErrorDirective(Item *item)

    : Directive(item) {}

    virtual ErrorDirective *toErrorDirective() const

    { return const_cast<ErrorDirective *>(this); }

};

struct PragmaDirective: public Directive

{

    PragmaDirective(Item *item)

    : Directive(item) {}

    virtual PragmaDirective *toPragmaDirective() const

    { return const_cast<PragmaDirective *>(this); }

};

struct IncludeDirective: public Directive

{

    enum IncludeType {QuoteInclude, AngleBracketInclude};

    IncludeDirective(Item *item)

    : Directive(item), m_includeType(QuoteInclude) {}

    IncludeDirective() : Directive() {}

    virtual IncludeDirective *toIncludeDirective() const

    { return const_cast<IncludeDirective *>(this); }

    void setFilenameTokens(const TokenEngine::TokenList &filenameTokens)

    { m_filenameTokens = filenameTokens; }

    TokenEngine::TokenList filenameTokens() const

    { return m_filenameTokens; }

    void setFilename(const QByteArray &filename)

    { m_filename = filename; }

    QByteArray filename() const

    { return m_filename;}

    void setIncludeType(IncludeType includeType)

    { m_includeType = includeType; }

    IncludeType includeType() const

    { return m_includeType; }

private:

    TokenEngine::TokenList m_filenameTokens;

    QByteArray m_filename;

    IncludeType m_includeType;

};

struct ConditionalDirective: public Directive, public ItemComposite

{

    inline ConditionalDirective(Item *parent = 0)

    :Directive(parent) {}

    virtual ConditionalDirective *toConditionalDirective() const

    { return const_cast<ConditionalDirective *>(this); }

    ItemComposite *toItemComposite() const

    { return const_cast<ConditionalDirective *>(this); }

    virtual IfDirective *toIfDirective() const

    { return 0; }

    virtual IfdefDirective *toIfdefDirective() const

    { return 0; }

    virtual IfndefDirective *toIfndefDirective() const

    { return 0; }

    virtual ElifDirective *toElifDirective() const

    { return 0; }

    virtual ElseDirective *toElseDirective() const

    { return 0; }

    int count() const

    { return m_items.count(); }

    Item *item(int index) const

    { return m_items.at(index); }

    void add(Item *item)

    { m_items.append(item); }

protected:

    QVector<Item *> m_items;

};

struct IfSection: public Item, public ItemComposite

{

    IfSection(Item *parent)

    :m_parent(parent), m_ifGroup(0), m_elseGroup(0), m_endifLine(0) {}

    IfSection *toIfSection() const

    { return const_cast<IfSection *>(this); }

    ItemComposite *toItemComposite() const

    { return const_cast<IfSection *>(this); }

    void setParent(Item *parent)

    { m_parent = parent; }

    Item *parent() const

    { return m_parent; }

    void setIfGroup(ConditionalDirective *ifGroup)

    { m_ifGroup = ifGroup; m_items.append(ifGroup); }

    ConditionalDirective *ifGroup() const

    { return m_ifGroup; }

    void addElifGroup(ConditionalDirective *elifGroup)

    { m_elifGroups.append(elifGroup); m_items.append(elifGroup); }

    QVector<ConditionalDirective *> elifGroups() const

    { return m_elifGroups; }

    void setElseGroup(ConditionalDirective *elseGroup)

    { m_elseGroup = elseGroup; m_items.append(elseGroup); }

    ConditionalDirective *elseGroup() const

    { return m_elseGroup; }

    void setEndifLine(Directive *endifLine)

    { m_endifLine = endifLine; m_items.append(endifLine); }

    Directive *endifLine() const