Converted tabs to spaces with tabconv.

1 files changed, 171 insertions, 171 deletions

diff --git a/src/experimental/parser.cpp b/src/experimental/parser.cpp
index 9f10256..5d0d7eb 100644
--- a/src/experimental/parser.cpp
+++ b/src/experimental/parser.cpp
@@ -21,231 +21,231 @@ Bu::Parser::~Parser()
 
 void Bu::Parser::pushLexer( Lexer *pLex )
 {
-        sLexer.push( pLex );
+    sLexer.push( pLex );
 }
 
 void Bu::Parser::popLexer()
 {
-        delete sLexer.peekPop();
+    delete sLexer.peekPop();
 }
 
 Lexer::Token *Bu::Parser::popToken()
 {
-        return sToken.peekPop();
+    return sToken.peekPop();
 }
 
 void Bu::Parser::pushToken( Lexer::Token *pTok )
 {
-        sToken.push( pTok );
+    sToken.push( pTok );
 }
 
 void Bu::Parser::parse()
 {
-        int iCurNt = iRootNonTerminal;
-        Lexer::Token *ptCur = sLexer.peek()->nextToken();
-        sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-        selectProduction( iCurNt, ptCur );
-        
-        while( !sState.isEmpty() )
-        {
-                switch( (*sState.peek()).eType )
-                {
-                        case State::typeTerminal:
-                                sio << "terminal: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        delete ptCur;
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeTerminalPush:
-                                sio << "terminalpush: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        sToken.push( ptCur );
-
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeNonTerminal:
-                                sio << "nonterminal: " << ptCur->iToken << " --> "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                {
-                                        int iNt = (*sState.peek()).iIndex;
-                                        sio << "Current state: " << *sState.peek() << sio.nl;
-                                        if( !selectProduction( iNt, ptCur ) )
-                                        {
-                                                throw Bu::ExceptionBase("Error parsing code.");
-                                        }
-                                }
-                                break;
-
-                        case State::typeReduction:
-                                sio << "reduction" << sio.nl;
-                                aReduction[(*sState.peek()).iIndex]( *this );
-                                advanceState();
-                                break;
-                }
-        }       
+    int iCurNt = iRootNonTerminal;
+    Lexer::Token *ptCur = sLexer.peek()->nextToken();
+    sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+    selectProduction( iCurNt, ptCur );
+    
+    while( !sState.isEmpty() )
+    {
+        switch( (*sState.peek()).eType )
+        {
+            case State::typeTerminal:
+                sio << "terminal: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    delete ptCur;
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeTerminalPush:
+                sio << "terminalpush: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    sToken.push( ptCur );
+
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeNonTerminal:
+                sio << "nonterminal: " << ptCur->iToken << " --> "
+                    << (*sState.peek()).iIndex << sio.nl;
+                {
+                    int iNt = (*sState.peek()).iIndex;
+                    sio << "Current state: " << *sState.peek() << sio.nl;
+                    if( !selectProduction( iNt, ptCur ) )
+                    {
+                        throw Bu::ExceptionBase("Error parsing code.");
+                    }
+                }
+                break;
+
+            case State::typeReduction:
+                sio << "reduction" << sio.nl;
+                aReduction[(*sState.peek()).iIndex]( *this );
+                advanceState();
+                break;
+        }
+    }   
 }
 
 bool Bu::Parser::selectProduction( int iNt, Lexer::Token *ptCur )
 {
-        NonTerminal &nt = aNonTerminal[iNt];
-        int j = 0;
-        for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
-                 i; i++,j++ )
-        {
-                if( (*i).isEmpty() )
-                        continue;
-                sio << "-->(Attempting production " << iNt << ":" << j << ": "
-                        << (*i).first() << ")" << sio.nl;
-                if( (*i).first().eType == State::typeTerminal ||
-                        (*i).first().eType == State::typeTerminalPush )
-                {
-                        if( (*i).first().iIndex == ptCur->iToken )
-                        {
-                                sState.push( (*i).begin() );
-                                sio.incIndent();
-                                sio << "Pushing production " << j << " from nt " << iNt
-                                        << sio.nl;
-                                return true;
-                        }
-                }
-                else if( (*i).first().eType == State::typeNonTerminal )
-                {
-                        sState.push( (*i).begin() );
-                        sio.incIndent();
-                        sio << "Pushing production " << j << " from nt " << iNt
-                                << " as test." << sio.nl;
-                        if( !selectProduction( (*i).first().iIndex, ptCur ) )
-                        {
-                                sio.decIndent();
-                                sState.pop();
-                                sio << "Production " << j << " from nt " << iNt
-                                        << " didn't work out." << sio.nl;
-                        }
-                        else
-                        {
-                                return true;
-                        }
-                }
-        }
-        if( nt.bCanSkip )
-        {
-                sio << "Nothing matches, skipping non-terminal." << sio.nl;
-                advanceState();
-                return true;
-        }
-        sio << "-->(Found nothing)" << sio.nl;
-        return false;
+    NonTerminal &nt = aNonTerminal[iNt];
+    int j = 0;
+    for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
+         i; i++,j++ )
+    {
+        if( (*i).isEmpty() )
+            continue;
+        sio << "-->(Attempting production " << iNt << ":" << j << ": "
+            << (*i).first() << ")" << sio.nl;
+        if( (*i).first().eType == State::typeTerminal ||
+            (*i).first().eType == State::typeTerminalPush )
+        {
+            if( (*i).first().iIndex == ptCur->iToken )
+            {
+                sState.push( (*i).begin() );
+                sio.incIndent();
+                sio << "Pushing production " << j << " from nt " << iNt
+                    << sio.nl;
+                return true;
+            }
+        }
+        else if( (*i).first().eType == State::typeNonTerminal )
+        {
+            sState.push( (*i).begin() );
+            sio.incIndent();
+            sio << "Pushing production " << j << " from nt " << iNt
+                << " as test." << sio.nl;
+            if( !selectProduction( (*i).first().iIndex, ptCur ) )
+            {
+                sio.decIndent();
+                sState.pop();
+                sio << "Production " << j << " from nt " << iNt
+                    << " didn't work out." << sio.nl;
+            }
+            else
+            {
+                return true;
+            }
+        }
+    }
+    if( nt.bCanSkip )
+    {
+        sio << "Nothing matches, skipping non-terminal." << sio.nl;
+        advanceState();
+        return true;
+    }
+    sio << "-->(Found nothing)" << sio.nl;
+    return false;
 }
 
 void Bu::Parser::advanceState()
 {
-        if( sState.isEmpty() )
-                return;
-
-        sState.peek()++;
-        if( !sState.peek() )
-        {
-                sio.decIndent();
-                sState.pop();
-                sio << "State advanced, End of production." << sio.nl;
-                advanceState();
-                return;
-        }
-        sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
+    if( sState.isEmpty() )
+        return;
+
+    sState.peek()++;
+    if( !sState.peek() )
+    {
+        sio.decIndent();
+        sState.pop();
+        sio << "State advanced, End of production." << sio.nl;
+        advanceState();
+        return;
+    }
+    sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
 }
 
 void Bu::Parser::setRootNonTerminal( int iRoot )
 {
-        iRootNonTerminal = iRoot;
+    iRootNonTerminal = iRoot;
 }
 
 void Bu::Parser::setRootNonTerminal( const Bu::String &sRoot )
 {
-        setRootNonTerminal( hNonTerminalName.get( sRoot ) );
+    setRootNonTerminal( hNonTerminalName.get( sRoot ) );
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( nt );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( nt );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( NonTerminal() );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( NonTerminal() );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 void Bu::Parser::setNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        aNonTerminal[hNonTerminalName.get(sName)] = nt;
+    aNonTerminal[hNonTerminalName.get(sName)] = nt;
 }
 
 int Bu::Parser::getNonTerminalId( const Bu::String &sName )
 {
-        return hNonTerminalName.get( sName );
+    return hNonTerminalName.get( sName );
 }
 
 bool Bu::Parser::hasNonTerminal( const Bu::String &sName )
 {
-        return hNonTerminalName.has( sName );
+    return hNonTerminalName.has( sName );
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName, const Reduction &r )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( r );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( r );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( Reduction() );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( Reduction() );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 void Bu::Parser::setReduction( const Bu::String &sName, const Reduction &r )
 {
-        aReduction[hReductionName.get(sName)] = r;
+    aReduction[hReductionName.get(sName)] = r;
 }
 
 int Bu::Parser::getReductionId( const Bu::String &sName )
 {
-        return hReductionName.get( sName );
+    return hReductionName.get( sName );
 }
 
 bool Bu::Parser::hasReduction( const Bu::String &sName )
 {
-        return hReductionName.has( sName );
+    return hReductionName.has( sName );
 }
 
 //
@@ -253,8 +253,8 @@ bool Bu::Parser::hasReduction( const Bu::String &sName )
 //
 
 Bu::Parser::State::State( Bu::Parser::State::Type eType, int iIndex ) :
-        eType( eType ),
-        iIndex( iIndex )
+    eType( eType ),
+    iIndex( iIndex )
 {
 }
 
@@ -267,7 +267,7 @@ Bu::Parser::State::~State()
 //
 
 Bu::Parser::NonTerminal::NonTerminal() :
-        bCanSkip( false )
+    bCanSkip( false )
 {
 }
 
@@ -277,35 +277,35 @@ Bu::Parser::NonTerminal::~NonTerminal()
 
 void Bu::Parser::NonTerminal::addProduction( Production p )
 {
-        lProduction.append( p );
+    lProduction.append( p );
 }
 
 void Bu::Parser::NonTerminal::setCanSkip()
 {
-        bCanSkip = true;
+    bCanSkip = true;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Parser::State::Type t )
 {
-        switch( t )
-        {
-                case Bu::Parser::State::typeTerminal:
-                        return f << "typeTerminal";
+    switch( t )
+    {
+        case Bu::Parser::State::typeTerminal:
+            return f << "typeTerminal";
 
-                case Bu::Parser::State::typeTerminalPush:
-                        return f << "typeTerminalPush";
+        case Bu::Parser::State::typeTerminalPush:
+            return f << "typeTerminalPush";
 
-                case Bu::Parser::State::typeNonTerminal:
-                        return f << "typeNonTerminal";
+        case Bu::Parser::State::typeNonTerminal:
+            return f << "typeNonTerminal";
 
-                case Bu::Parser::State::typeReduction:
-                        return f << "typeReduction";
-        }
-        return f << "***error***";
+        case Bu::Parser::State::typeReduction:
+            return f << "typeReduction";
+    }
+    return f << "***error***";
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Parser::State &s )
 {
-        return f << "{" << s.eType << ": " << s.iIndex << "}";
+    return f << "{" << s.eType << ": " << s.iIndex << "}";
 }