/******************************************************************************** Copyright (C) 1992-$THISYEAR$ Trolltech AS. All rights reserved.**** This file is part of the $MODULE$ of the Qt Toolkit.**** $LICENSE$**** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.******************************************************************************//*  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>/* 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.find(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.find(*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.find(*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.findRev(':') != -1 && trimmed.find(*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.find( QString::fromLatin1("//") );    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;// shorthandsstatic 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 = QString::null;	    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.find( slashAster );	    if ( k == -1 ) {		yyLinizerState->line = QString::null;	    } else {		yyLinizerState->line.truncate( k );		yyLinizerState->inCComment = false;	    }	}	if ( !yyLinizerState->inCComment ) {	    QString asterSlash( "*/" );	    k = yyLinizerState->line.find( 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 = QString::null;	    } 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.find(*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).find(slashAster) != -1 || (*p).find(asterSlash) != -1 ) {	    QString trimmed = trimmedCodeLine( *p );	    if ( trimmed.find(slashAster) != -1 ) {		return true;	    } else if ( trimmed.find(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->findRev( QString::fromLatin1("/*") );    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;  otherwise, the linizer is left in an unknown state.  A function called is...() keeps the linizer state intact.*//*  Returns true if the current line (and upwards) forms a braceless  control statement; otherwise returns false.  The first line of the following example is a "braceless control  statement":      if ( x )	  y;*/static bool matchBracelessControlStatement(){    int delimDepth = 0;    if ( yyLine->endsWith(QString::fromLatin1("else")) )	return true;    if ( !yyLine->endsWith(QString::fromLatin1(")")) )	return false;    for ( int i = 0; i < SmallRoof; i++ ) {	int j = yyLine->length();	while ( j > 0 ) {	    j--;	    QChar ch = (*yyLine)[j];	    switch ( ch.unicode() ) {	    case ')':		delimDepth++;		break;	    case '(':		delimDepth--;		if ( delimDepth == 0 ) {		    if ( yyLine->find(*iflikeKeyword) != -1 ) {			/*			  We have			      if ( x )				  y			  "if ( x )" is not part of the statement			  "y".			*/			return true;		    }		}		if ( delimDepth == -1 ) {		    /*		      We have			  if ( (1 +				2)		      and not			  if ( 1 +			       2 )		    */		    return false;		}		break;	    case '{':	    case '}':	    case ';':		/*		  We met a statement separator, but not where we		  expected it. What follows is probably a weird		  continuation line. Be careful with ';' in for,		  though.		*/		if ( ch != QChar(';') || delimDepth == 0 )		    return false;	    }