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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the tools applications 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$

**

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

/*

    This file is a self-contained interactive indenter for C++ and Qt

    Script.

    The general problem of indenting a C++ program is ill posed. On

    the one hand, an indenter has to analyze programs written in a

    free-form formal language that is best described in terms of

    tokens, not characters, not lines. On the other hand, indentation

    applies to lines and white space characters matter, and otherwise

    the programs to indent are formally invalid in general, as they

    are begin edited.

    The approach taken here works line by line. We receive a program

    consisting of N lines or more, and we want to compute the

    indentation appropriate for the Nth line. Lines beyond the Nth

    lines are of no concern to us, so for simplicity we pretend the

    program has exactly N lines and we call the Nth line the "bottom

    line". Typically, we have to indent the bottom line when it's

    still empty, so we concentrate our analysis on the N - 1 lines

    that precede.

    By inspecting the (N - 1)-th line, the (N - 2)-th line, ...

    backwards, we determine the kind of the bottom line and indent it

    accordingly.

      * The bottom line is a comment line. See

        bottomLineStartsInCComment() and

        indentWhenBottomLineStartsInCComment().

      * The bottom line is a continuation line. See isContinuationLine()

        and indentForContinuationLine().

      * The bottom line is a standalone line. See

        indentForStandaloneLine().

    Certain tokens that influence the indentation, notably braces,

    are looked for in the lines. This is done by simple string

    comparison, without a real tokenizer. Confusing constructs such

    as comments and string literals are removed beforehand.

*/

#include <qregexp.h>

#include <qstringlist.h>

QT_BEGIN_NAMESPACE

/* qmake ignore Q_OBJECT */

/*

    The indenter avoids getting stuck in almost infinite loops by

    imposing arbitrary limits on the number of lines it analyzes when

    looking for a construct.

    For example, the indenter never considers more than BigRoof lines

    backwards when looking for the start of a C-style comment.

*/

static const int SmallRoof = 40;

static const int BigRoof = 400;

/*

    The indenter supports a few parameters:

      * ppHardwareTabSize is the size of a '\t' in your favorite editor.

      * ppIndentSize is the size of an indentation, or software tab

        size.

      * ppContinuationIndentSize is the extra indent for a continuation

        line, when there is nothing to align against on the previous

        line.

      * ppCommentOffset is the indentation within a C-style comment,

        when it cannot be picked up.

*/

static int ppHardwareTabSize = 8;

static int ppIndentSize = 4;

static int ppContinuationIndentSize = 8;

static const int ppCommentOffset = 2;

void setTabSize( int size )

{

    ppHardwareTabSize = size;

}

void setIndentSize( int size )

{

    ppIndentSize = size;

    ppContinuationIndentSize = 2 * size;

}

static QRegExp *literal = 0;

static QRegExp *label = 0;

static QRegExp *inlineCComment = 0;

static QRegExp *braceX = 0;

static QRegExp *iflikeKeyword = 0;

/*

    Returns the first non-space character in the string t, or

    QChar::Null if the string is made only of white space.

*/

static QChar firstNonWhiteSpace( const QString& t )

{

    int i = 0;

    while ( i < (int) t.length() ) {

        if ( !t[i].isSpace() )

            return t[i];

        i++;

    }

    return QChar::Null;

}

/*

    Returns true if string t is made only of white space; otherwise

    returns false.

*/

static bool isOnlyWhiteSpace( const QString& t )

{

    return firstNonWhiteSpace( t ).isNull();

}

/*

    Assuming string t is a line, returns the column number of a given

    index. Column numbers and index are identical for strings that don't

    contain '\t's.

*/

int columnForIndex( const QString& t, int index )

{

    int col = 0;

    if ( index > (int) t.length() )

        index = t.length();

    for ( int i = 0; i < index; i++ ) {

        if ( t[i] == QChar('\t') ) {

            col = ( (col / ppHardwareTabSize) + 1 ) * ppHardwareTabSize;

        } else {

            col++;

        }

    }

    return col;

}

/*

    Returns the indentation size of string t.

*/

int indentOfLine( const QString& t )

{

    return columnForIndex( t, t.indexOf(firstNonWhiteSpace(t)) );

}

/*

    Replaces t[k] by ch, unless t[k] is '\t'. Tab characters are better

    left alone since they break the "index equals column" rule. No

    provisions are taken against '\n' or '\r', which shouldn't occur in

    t anyway.

*/

static inline void eraseChar( QString& t, int k, QChar ch )

{

    if ( t[k] != '\t' )

        t[k] = ch;

}

/*

   Removes some nefast constructs from a code line and returns the

   resulting line.

*/

static QString trimmedCodeLine( const QString& t )

{

    QString trimmed = t;

    int k;

    /*

        Replace character and string literals by X's, since they may

        contain confusing characters (such as '{' and ';'). "Hello!" is

        replaced by XXXXXXXX. The literals are rigourously of the same

        length before and after; otherwise, we would break alignment of

        continuation lines.

    */

    k = 0;

    while ( (k = trimmed.indexOf(*literal, k)) != -1 ) {

        for ( int i = 0; i < literal->matchedLength(); i++ )

            eraseChar( trimmed, k + i, 'X' );

        k += literal->matchedLength();

    }

    /*

        Replace inline C-style comments by spaces. Other comments are

        handled elsewhere.

    */

    k = 0;

    while ( (k = trimmed.indexOf(*inlineCComment, k)) != -1 ) {

        for ( int i = 0; i < inlineCComment->matchedLength(); i++ )

            eraseChar( trimmed, k + i, ' ' );

        k += inlineCComment->matchedLength();

    }

    /*

        Replace goto and switch labels by whitespace, but be careful

        with this case:

        foo1: bar1;

                bar2;

    */

    while ( trimmed.lastIndexOf(':') != -1 && trimmed.indexOf(*label) != -1 ) {

        QString cap1 = label->cap( 1 );

        int pos1 = label->pos( 1 );

        int stop = cap1.length();

        if ( pos1 + stop < (int) trimmed.length() && ppIndentSize < stop )

            stop = ppIndentSize;

        int i = 0;

        while ( i < stop ) {

            eraseChar( trimmed, pos1 + i, ' ' );

            i++;

        }

        while ( i < (int) cap1.length() ) {

            eraseChar( trimmed, pos1 + i, ';' );

            i++;

        }

    }

    /*

        Remove C++-style comments.

    */

    k = trimmed.indexOf( "//" );

    if ( k != -1 )

        trimmed.truncate( k );

    return trimmed;

}

/*

    Returns '(' if the last parenthesis is opening, ')' if it is

    closing, and QChar::Null if there are no parentheses in t.

*/

static inline QChar lastParen( const QString& t )

{

    int i = t.length();

    while ( i > 0 ) {

        i--;

        if ( t[i] == QChar('(') || t[i] == QChar(')') )

            return t[i];

    }

    return QChar::Null;

}

/*

    Returns true if typedIn the same as okayCh or is null; otherwise

    returns false.

*/

static inline bool okay( QChar typedIn, QChar okayCh )

{

    return typedIn == QChar::Null || typedIn == okayCh;

}

/*

    The "linizer" is a group of functions and variables to iterate

    through the source code of the program to indent. The program is

    given as a list of strings, with the bottom line being the line

    to indent. The actual program might contain extra lines, but

    those are uninteresting and not passed over to us.

*/

struct LinizerState

{

    QString line;

    int braceDepth;

    bool leftBraceFollows;

    QStringList::ConstIterator iter;

    bool inCComment;

    bool pendingRightBrace;

};

static QStringList *yyProgram = 0;

static LinizerState *yyLinizerState = 0;

// shorthands

static const QString *yyLine = 0;

static const int *yyBraceDepth = 0;

static const bool *yyLeftBraceFollows = 0;

/*

    Saves and restores the state of the global linizer. This enables

    backtracking.

*/

#define YY_SAVE() \

        LinizerState savedState = *yyLinizerState

#define YY_RESTORE() \

        *yyLinizerState = savedState

/*

    Advances to the previous line in yyProgram and update yyLine

    accordingly. yyLine is cleaned from comments and other damageable

    constructs. Empty lines are skipped.

*/

static bool readLine()

{

    int k;

    yyLinizerState->leftBraceFollows =

            ( firstNonWhiteSpace(yyLinizerState->line) == QChar('{') );

    do {

        if ( yyLinizerState->iter == yyProgram->begin() ) {

            yyLinizerState->line.clear();

            return false;

        }

        --yyLinizerState->iter;

        yyLinizerState->line = *yyLinizerState->iter;

        yyLinizerState->line = trimmedCodeLine( yyLinizerState->line );

        /*

            Remove C-style comments that span multiple lines. If the

            bottom line starts in a C-style comment, we are not aware

            of that and eventually yyLine will contain a slash-aster.

            Notice that both if's can be executed, since

            yyLinizerState->inCComment is potentially set to false in

            the first if. The order of the if's is also important.

        */

        if ( yyLinizerState->inCComment ) {

            QString slashAster( "/*" );

            k = yyLinizerState->line.indexOf( slashAster );

            if ( k == -1 ) {

                yyLinizerState->line.clear();

            } else {

                yyLinizerState->line.truncate( k );

                yyLinizerState->inCComment = false;

            }

        }

        if ( !yyLinizerState->inCComment ) {

            QString asterSlash( "*/" );

            k = yyLinizerState->line.indexOf( asterSlash );

            if ( k != -1 ) {

                for ( int i = 0; i < k + 2; i++ )

                    eraseChar( yyLinizerState->line, i, ' ' );

                yyLinizerState->inCComment = true;

            }

        }

        /*

            Remove preprocessor directives.

        */

        k = 0;

        while ( k < (int) yyLinizerState->line.length() ) {

            QChar ch = yyLinizerState->line[k];

            if ( ch == QChar('#') ) {

                yyLinizerState->line.clear();

            } else if ( !ch.isSpace() ) {

                break;

            }

            k++;

        }

        /*

            Remove trailing spaces.

        */

        k = yyLinizerState->line.length();

        while ( k > 0 && yyLinizerState->line[k - 1].isSpace() )

            k--;

        yyLinizerState->line.truncate( k );

        /*

            '}' increment the brace depth and '{' decrements it and not

            the other way around, as we are parsing backwards.

        */

        yyLinizerState->braceDepth +=

                yyLinizerState->line.count( '}' ) -

                yyLinizerState->line.count( '{' );

        /*

            We use a dirty trick for

                } else ...

            We don't count the '}' yet, so that it's more or less

            equivalent to the friendly construct

                }

                else ...

        */

        if ( yyLinizerState->pendingRightBrace )

            yyLinizerState->braceDepth++;

        yyLinizerState->pendingRightBrace =

                ( yyLinizerState->line.indexOf(*braceX) == 0 );

        if ( yyLinizerState->pendingRightBrace )

            yyLinizerState->braceDepth--;

    } while ( yyLinizerState->line.isEmpty() );

    return true;

}

/*

    Resets the linizer to its initial state, with yyLine containing the

    line above the bottom line of the program.

*/

static void startLinizer()

{

    yyLinizerState->braceDepth = 0;

    yyLinizerState->inCComment = false;

    yyLinizerState->pendingRightBrace = false;

    yyLine = &yyLinizerState->line;

    yyBraceDepth = &yyLinizerState->braceDepth;

    yyLeftBraceFollows = &yyLinizerState->leftBraceFollows;

    yyLinizerState->iter = yyProgram->end();

    --yyLinizerState->iter;

    yyLinizerState->line = *yyLinizerState->iter;

    readLine();

}

/*

    Returns true if the start of the bottom line of yyProgram (and

    potentially the whole line) is part of a C-style comment;

    otherwise returns false.

*/

static bool bottomLineStartsInCComment()

{

    QString slashAster( "/*" );

    QString asterSlash( "*/" );

    /*

        We could use the linizer here, but that would slow us down

        terribly. We are better to trim only the code lines we need.

    */

    QStringList::ConstIterator p = yyProgram->end();

    --p; // skip bottom line

    for ( int i = 0; i < BigRoof; i++ ) {

        if ( p == yyProgram->begin() )

            return false;

        --p;

        if ( (*p).indexOf(slashAster) != -1 || (*p).indexOf(asterSlash) != -1 ) {

            QString trimmed = trimmedCodeLine( *p );

            if ( trimmed.indexOf(slashAster) != -1 ) {

                return true;

            } else if ( trimmed.indexOf(asterSlash) != -1 ) {

                return false;

            }

        }

    }

    return false;

}

/*

    Returns the recommended indent for the bottom line of yyProgram

    assuming that it starts in a C-style comment, a condition that is

    tested elsewhere.

    Essentially, we're trying to align against some text on the

    previous line.

*/

static int indentWhenBottomLineStartsInCComment()

{

    int k = yyLine->lastIndexOf( "/*" );

    if ( k == -1 ) {

        /*

          We found a normal text line in a comment. Align the

          bottom line with the text on this line.

        */

        return indentOfLine( *yyLine );

    } else {

        /*

          The C-style comment starts on this line. If there is

          text on the same line, align with it. Otherwise, align

          with the slash-aster plus a given offset.

        */

        int indent = columnForIndex( *yyLine, k );

        k += 2;

        while ( k < (int) yyLine->length() ) {

            if ( !(*yyLine)[k].isSpace() )

                return columnForIndex( *yyLine, k );

            k++;

        }

        return indent + ppCommentOffset;

    }

}

/*

    A function called match...() modifies the linizer state. If it

    returns true, yyLine is the top line of the matched construct;