/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
* 
* Description: This module contains implementation of CStifParser 
* class member functions.
*
*/

// INCLUDE FILES
#include <e32std.h>
#include "StifParser.h"
#include "ParserTracing.h"
#include "StifFileParser.h"

// EXTERNAL DATA STRUCTURES
// None

// EXTERNAL FUNCTION PROTOTYPES
// None

// CONSTANTS
// None

// MACROS
// None

// LOCAL CONSTANTS AND MACROS
// None

// MODULE DATA STRUCTURES
// None

// LOCAL FUNCTION PROTOTYPES
// None

// FORWARD DECLARATIONS
// None

// ==================== LOCAL FUNCTIONS =======================================
// None

// ================= MEMBER FUNCTIONS =========================================

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: CStifParser

    Description: Default constructor

    C++ default constructor can NOT contain any code, that
    might leave.
    
    Parameters: TCommentType aCommentType: in: Comment type's indication
    
    Return Values: None

    Errors/Exceptions: None

    Status: Approved
    
-------------------------------------------------------------------------------
*/
CStifParser::CStifParser( TCommentType aCommentType ) :
    iBuffer( 0, 0 )
    {
    iCommentType = aCommentType;

    iParsingMode = EFileParsing;

    iIsUnicode = EFalse;
    
    iFileParser = NULL;
    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Connecting and opening configuration file if path and file information is 
    given. If path and file information is not given and information is given 
    in buffer then create parser according to the buffer.
    
    Parameters: const TDesC& aPath: in: Source path definition
                const TDesC& aConfig: in: Configuration filename
                const TDesC& aBuffer: in: Buffer of the parsed information

    Return Values: None

    Errors/Exceptions:  Leaves if called Connect method fails
                        Leaves if called SetSessionPath method fails
                        Leaves if called Open method fails
                        Leaves if HBufC::NewL operation leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
void CStifParser::ConstructL( const TDesC& aPath,
                                const TDesC& aConfig,
                                const TDesC& aBuffer)
    {
    if( aPath == KNullDesC && aConfig == KNullDesC && aBuffer != KNullDesC )
        {
        // Set mode
        iParsingMode = EBufferParsing;

        // Construct modifiable heap-based descriptor.
        iBufferTmp = HBufC::NewL( aBuffer.Length() );
        //iBuffer = iBufferTmp->Des();
        iBuffer.Set( iBufferTmp->Des() );
        // Copy content
        iBuffer.Copy( aBuffer );
        }

    else
        {
        User::LeaveIfError( iFileServer.Connect() );
    
        __TRACE( KInfo, ( _L( "STIFPARSER: Open configfile '%S%S'" ),
                &aPath, &aConfig ) );
                
        User::LeaveIfError( iFileServer.SetSessionPath( aPath ) );
        User::LeaveIfError( iFile.Open( 
                            iFileServer, aConfig, EFileRead | EFileShareAny ) );

        //Check whether the file is unicoded
        __TRACE(KInfo, (_L("STIFPARSER: Check if the file is unicode")));
        _LIT(KUnicode, "#UNICODE");
        const TInt KUnicodeLength(8 * 2 + 2); //times two, because we want to read unicode string using 8bit descriptor
                                              //two characters more because on some systems FEFF is always added on the beginning of unicode file
        TInt size(0);

        User::LeaveIfError(iFile.Size(size));

        if(size >= KUnicodeLength)
            {
            TBuf8<KUnicodeLength> buf;

            User::LeaveIfError(iFile.Read(0, buf));
            TPtrC16 bufuni((TUint16 *)(buf.Ptr()), buf.Length() / 2);
            if(bufuni.Find(KUnicode) != KErrNotFound)
                {
                iIsUnicode = ETrue;
                __TRACE(KInfo, (_L("STIFPARSER: File is unicode")));
                }
            }
        
        //Create file parser object
        iFileParser = CStifFileParser::NewL(iFileServer, iFile, iIsUnicode, iCommentType);
        }

    iOffset = 0;

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: NewL

    Description: Two-phased constructor.

    Starting creating parser with path and file information.

    Parameters: const TDesC& aPath: in: Source path definition
                const TDesC& aConfig: in: Configuration filename
                TCommentType aCommentType: in: Comment type's indication

    Return Values: CStifParser* : pointer to CStifParser object

    Errors/Exceptions: Leaves if ConstructL leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
EXPORT_C CStifParser* CStifParser::NewL( const TDesC& aPath,
                                            const TDesC& aConfig,
                                            TCommentType aCommentType )
    {
    __TRACE( KInfo, ( _L( "STIFPARSER: Debug information is used" ) ) );

    // Create CStifParser object
    CStifParser* parser = new (ELeave) CStifParser( aCommentType );

    CleanupStack::PushL( parser );
    parser->ConstructL( aPath, aConfig );
    CleanupStack::Pop( parser );

    return parser;

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: NewL

    Description: Two-phased constructor.

    Starting creating parser with buffer information.

    Parameters: const TDesC& aBuffer: in: Buffer of the parsed informations
                TCommentType aCommentType: in: Comment type's indication

    Return Values: CStifParser* : pointer to CStifParser object

    Errors/Exceptions: Leaves if ConstructL leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
EXPORT_C CStifParser* CStifParser::NewL( const TDesC& aBuffer,
                                            TCommentType aCommentType )
    {
    __TRACE( KInfo, ( _L( "STIFPARSER: Debug information is used" ) ) );

    // Create CStifParser object
    CStifParser* parser = new (ELeave) CStifParser( aCommentType );

    CleanupStack::PushL( parser );
    // No path and file name informations. Buffer is given
    parser->ConstructL( KNullDesC, KNullDesC, aBuffer );
    CleanupStack::Pop( parser );

    return parser;

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: ~CStifParser

    Description: Destructor

    Close file and the fileserver handles.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------
*/    
EXPORT_C CStifParser::~CStifParser()
    {

    if( iParsingMode == EBufferParsing )
        {
        delete iBufferTmp;
        }
    else
        {
        delete iFileParser;
        iFile.Close();
        iFileServer.Close();
        }

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: SectionL

    Description: Parses sections from configuration files.

    Open and read configuration source and parses a required section.
    If start tag is empty the parsing starts beginning of the configuration
    file. If end tag is empty the parsing goes end of configuration file.
    This method starts always from beginning of configuration file and parses
    first section if aSeeked parameters is not given.
    If configuration file includes several sections with both start and end
    tags so aSeeked parameter seeks the required section. The aSeeked
    parameters indicates section that will be parsed.

    Parameters: const TDesC& aStartTag: in: Indicates a start tag for parsing
                const TDesC& aEndTag: in: Indicates an end tag for parsing
                TInt aSeeked: in: a seeked section which will be parsed

    Return Values:  See NextSectionL() method

    Errors/Exceptions:  See NextSectionL() method

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C CStifSectionParser* CStifParser::SectionL( const TDesC& aStartTag,
                                                    const TDesC& aEndTag,
                                                    TInt aSeeked )
    {
    iOffset = 0;
    return NextSectionL( aStartTag, aEndTag, aSeeked );

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: NextSectionL

    Description: Parses sections from configuration files.

    Open and read configuration source and parses a required section.
    If start tag is empty the parsing starts beginning of the configuration
    file. If end tag is empty the parsing goes end of configuration file.
    This method will parse next section after the earlier section if aSeeked
    parameter is not given.
    If configuration file includes several sections with both start and end
    tags so aSeeked parameter seeks the required section. The aSeeked
    parameters indicates section that will be parsed.

    Parameters: const TDesC& aStartTag: in: Indicates a start tag for parsing
                const TDesC& aEndTag: in: Indicates an end tag for parsing
                TInt aSeeked: in: a seeked section which will be parsed

    Return Values:  CStifSectionParser* : pointer to CStifSectionParser object
                    NULL will return if NextSectionFileL (or NextSectionMemoryL) returns NULL

    Errors/Exceptions:  Leaves if NextSectionFileL leaves
                        Leaves if NextSectionMemoryL leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
EXPORT_C CStifSectionParser* CStifParser::NextSectionL( const TDesC& aStartTag,
                                                        const TDesC& aEndTag,
                                                        TInt aSeeked )
    {
	//If parsing mode is set to file, we parse directly in the file
	if(iParsingMode == EFileParsing)
		{
		return NextSectionFileL(aStartTag, aEndTag, aSeeked);
		}

	//If parsing mode is set to buffer, process in old way
    return NextSectionMemoryL(aStartTag, aEndTag, aSeeked);
    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: NextSectionMemoryL

    Description: Parses sections from configuration files.

    Open and read configuration source and parses a required section.
    If start tag is empty the parsing starts beginning of the configuration
    file. If end tag is empty the parsing goes end of configuration file.
    This method will parse next section after the earlier section if aSeeked
    parameter is not given.
    If configuration file includes several sections with both start and end
    tags so aSeeked parameter seeks the required section. The aSeeked
    parameters indicates section that will be parsed.

    Parameters: const TDesC& aStartTag: in: Indicates a start tag for parsing
                const TDesC& aEndTag: in: Indicates an end tag for parsing
                TInt aSeeked: in: a seeked section which will be parsed

    Return Values:  CStifSectionParser* : pointer to CStifSectionParser object
                    NULL will return if file size or aSeeked is not positive
                    NULL will return if start tag is not found
                    NULL will return if end tag is not found
                    NULL will return if parsed section length is not positive

    Errors/Exceptions:  Leaves if called Size method fails
                        Leaves if HBufC::NewLC method leaves
                        Leaves if called Read method fails
                        Leaves if CStifSectionParser::NewL methods leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
CStifSectionParser* CStifParser::NextSectionMemoryL( const TDesC& aStartTag,
                                                 	 const TDesC& aEndTag,
                                                     TInt aSeeked )
    {
    TInt size( 0 );
    // Parser is created straight with data
    if( iParsingMode == EBufferParsing )
        {
        size = iBuffer.Length();
        }
    // Parser is created with path and file informations
    else
        {
        User::LeaveIfError( iFile.Size( size ) );
        }

    // size or aSeeked cannot be 0 or negetive
    if( size <= 0 || aSeeked <= 0)
        {
        __TRACE(
            KInfo, ( _L( "STIFPARSER: NextSectionL method returns a NULL" ) ) );
        return NULL;
        }

    const TInt tmpSize = 128;//--UNICODE-- KMaxName; // 128 - set to even value, because KMaxName may change in the future
    TInt offset( 0 ); // Offset value to parts reading

    // Construct modifiable heap-based descriptor. tmp to CleanupStack
    HBufC* tmp = HBufC::NewLC( size );
    TPtr wholeSection = tmp->Des();

    // Construct modifiable heap-based descriptor. tmp2 to CleanupStack
    HBufC8* tmp2 = HBufC8::NewLC( tmpSize );    // 128
    TPtr8 buf = tmp2->Des();

    // Construct modifiable heap-based descriptor. tmp3 to CleanupStack
    HBufC* tmp3 = HBufC::NewLC( tmpSize );      // 128
    TPtr currentSection = tmp3->Des();

    // Parser is created straight with data
    if( iParsingMode == EBufferParsing )
        {
        // If 8 bit copy changes to 16
        wholeSection.Copy( iBuffer );
        }
    // Parser is created with path and file informations
    else
        {
        TPtrC16 currentSectionUnicode;
        do // Read data in parts(Maximum part size is KMaxName)
            {
            // Read data
            User::LeaveIfError( iFile.Read( offset, buf, tmpSize ) );

            // If file is unicode convert differently
            if(iIsUnicode)
                {
                // 8 bit to 16 with unicode conversion - simply point to byte array as to double-byte array
                currentSectionUnicode.Set((TUint16 *)(buf.Ptr()), buf.Length() / 2);
                // Appends current section to whole section
                wholeSection.Append( currentSectionUnicode );
                }
            else
                {
                // 8 bit to 16
                currentSection.Copy( buf );
                // Appends current section to whole section
                wholeSection.Append( currentSection );
                }

            offset += tmpSize;

            } while( offset < size );
        }

    CleanupStack::PopAndDestroy( tmp3 );
    CleanupStack::PopAndDestroy( tmp2 );

    // User wants section without c-style comments
    if( iCommentType == ECStyleComments )
        {
        ParseCommentsOff( wholeSection );
        }

    TLex lex( wholeSection );
    lex.SkipAndMark( iOffset );

    // For the required section length and positions
    TInt length( 0 );
    TInt lengthStartPos( 0 );
    TInt lengthEndPos( 0 );
    TBool eos( EFalse );
    TInt tagCount( 1 );

    // Check is aStartTag given
    if ( aStartTag.Length() == 0 )
        {
        // Skip line break, tabs, spaces etc.
        lex.SkipSpace();
        lengthStartPos = lex.Offset();
        }
    else
        {
        // While end of section
        while ( !lex.Eos() )
            {
            TPtrC ptr = lex.NextToken();
            // Start of the section is found and correct section
            if ( ptr == aStartTag && tagCount == aSeeked )
                {
                lengthStartPos = lex.Offset();
                break;
                }
            // Start tag is found but not correct section
            else if ( ptr == aStartTag )
                {
                tagCount++;
                }
            }
        }

    // If we are end of section lex.Eos() and eos will be ETrue
    eos = lex.Eos();

    // Seeked section is not found
    if ( tagCount != aSeeked )
        {
        __TRACE( KInfo, ( _L(
            "STIFPARSER: NextSectionL method: Seeked section is not found" ) ) );
        CleanupStack::PopAndDestroy( tmp );
        User::Leave( KErrNotFound );
        }

    // Check is aEndTag given
    if ( aEndTag.Length() == 0 )
        {
        lengthEndPos = wholeSection.Length();
        }
    else
        {
        // While end of section
        while ( !lex.Eos() )
            {
            TPtrC ptr = lex.NextToken();
            // End tag of the section is found
            if ( ptr == aEndTag )
                {
                lengthEndPos = lex.Offset();
                // Because Offset() position is after the aEndTag
                lengthEndPos -= aEndTag.Length();
                break;
                }
            }
        }

    // If we are end of section and lengthEndPos is 0
    if ( lengthEndPos == 0 )
        {
        // lex.Eos() and eos will be ETrue
        eos = lex.Eos();
        }

    // The length includes spaces and end of lines
    length = ( lengthEndPos - lengthStartPos );

    CStifSectionParser* section = NULL;

    // If eos is true or length is negative
    if ( eos || length <= 0  )
        {
        __TRACE(
            KInfo, ( _L( "STIFPARSER: NextSectionL method returns a NULL" ) ) );
        }
    else
        {
        // Make CStifSectionParser object and alloc required length
        section = CStifSectionParser::NewL( length );
        CleanupStack::PushL( section );

        // Copy required data to the section object
        section->SetData( wholeSection, lengthStartPos, length );

        //iOffset += lengthEndPos + aEndTag.Length();
        iOffset = lex.Offset();

        CleanupStack::Pop( section );
        }
    CleanupStack::PopAndDestroy( tmp );

    return section;

    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: NextSectionFileL

    Description: Parses sections from configuration files.

    Open and read configuration source and parses a required section.
    If start tag is empty the parsing starts beginning of the configuration
    file. If end tag is empty the parsing goes end of configuration file.
    This method will parse next section after the earlier section if aSeeked
    parameter is not given.
    If configuration file includes several sections with both start and end
    tags so aSeeked parameter seeks the required section. The aSeeked
    parameters indicates section that will be parsed.

    Parameters: const TDesC& aStartTag: in: Indicates a start tag for parsing
                const TDesC& aEndTag: in: Indicates an end tag for parsing
                TInt aSeeked: in: a seeked section which will be parsed

    Return Values:  CStifSectionParser* : pointer to CStifSectionParser object
                    NULL will return if file size or aSeeked is not positive
                    NULL will return if start tag is not found
                    NULL will return if end tag is not found
                    NULL will return if parsed section length is not positive

    Errors/Exceptions:  Leaves if called Size method fails
                        Leaves if HBufC::NewLC method leaves
                        Leaves if called Read method fails
                        Leaves if CStifSectionParser::NewL methods leaves

    Status: Proposal

-------------------------------------------------------------------------------
*/
CStifSectionParser* CStifParser::NextSectionFileL( const TDesC& aStartTag,
                                                   const TDesC& aEndTag,
                                                   TInt aSeeked )
    {
	HBufC *bufSection = iFileParser->NextSectionL(aStartTag, aEndTag, iOffset, aSeeked);

	if(bufSection)
		{
		CleanupStack::PushL(bufSection);
		TPtr bufSectionPtr(bufSection->Des());

		if(iCommentType == ECStyleComments)
			{
			ParseCommentsOff(bufSectionPtr);
			}

		// Make CStifSectionParser object and alloc required length
		CStifSectionParser* section = CStifSectionParser::NewL(bufSection->Length());
		CleanupStack::PushL(section);

		// Copy required data to the section object
		section->SetData(bufSectionPtr, 0, bufSection->Length());

		// Clean
		CleanupStack::Pop(section);
		CleanupStack::PopAndDestroy(bufSection);

		return section;
		}

	return NULL;
    }

/*
-------------------------------------------------------------------------------

    Class: CStifParser

    Method: ParseCommentsOff

    Description: Convert a section without comments.

    Parameters: TPtr& aBuf: inout: section to parsed

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------
*/
void CStifParser::ParseCommentsOff( TPtr& aBuf )
    {
    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );
    enum TSearchType
        {
        ENormalSearch,          // Search a '//' or a '/*'
        ECStyleSlashs,          // Search is '//'
        ECStyleSlashAndAsterisk,// Search is '/*'
        EDoRemove,              // Remove comment
        };

    TSearchType searchType( ENormalSearch );

    TLex lex( aBuf );

    // Remove comments
    do
        {
        switch( searchType )
            {
            case ENormalSearch:
                {
                if( lex.Get() == '/' )
                    {
                    // Peek next character( '/' )
                    if( lex.Peek() == '/' )
                        {
                        startPos = lex.Offset();
                        startPos--;
                        lex.Inc();
                        searchType = ECStyleSlashs;
                        }
                    // Peek next character( '*' )
                    else if( lex.Peek() == '*' )
                        {
                        startPos = lex.Offset();
                        startPos--;
                        lex.Inc();
                        searchType = ECStyleSlashAndAsterisk;
                        }
                    }
                break;
                }
            case ECStyleSlashs:
                {
                // Peek next character(10 or '\n' in UNIX style )
                if( lex.Peek() == 0x0A )
                    {
                    // Don't remove line break!!( Else this fails:
                    // 1st line:"this is parsed text 1"
                    // 2nd line:"this is parsed text 2 // this is comments"
                    // 1st and 2nd lines will be together and following
                    // operations may fail)
                    endPos = lex.Offset();
                    searchType = EDoRemove;
                    break;
                    }

                // Peek next character(13 or '\r' in Symbian OS)
                if ( lex.Peek() == 0x0D )
                    {
                    // Increment the lex position
                    lex.Inc();
                    // Peek next character(10 or '\n' in Symbian OS)
                    if ( lex.Peek() == 0x0A )
                        {
                        // Don't remove line break!!( Else this fails:
                        // 1st line:"this is parsed text 1"
                        // 2nd line:"this is parsed text 2 // this is comments"
                        // 1st and 2nd lines will be together and following
                        // operations may fail)
                        endPos = lex.Offset();
                        endPos = endPos - 1; // Two line break characters
                        searchType = EDoRemove;
                        break;
                        }
                    // 0x0A not found, decrement position
                    lex.UnGet();
                    }
                // Increment the lex position
                lex.Inc();
                // Take current end position
                endPos = lex.Offset();
                break;
                }

            case ECStyleSlashAndAsterisk:
                {
                // Peek next character( '*' )
                if ( lex.Peek() == '*' )
                    {
                    // Increment the lex position
                    lex.Inc();
                    // Peek next character( '/')
                    if ( lex.Peek() == '/' )
                        {
                        // End of the section is found and increment the lex position
                        lex.Inc();
                        endPos = lex.Offset();
                        searchType = EDoRemove;
                        break;
                        }
                    // '/' not found, decrement position
                    lex.UnGet();
                    }
                // Increment the lex position
                lex.Inc();

                // Take current end position
                endPos = lex.Offset();
                break;
                }
            default:
                {
                searchType = ENormalSearch;
                break;
                }

            } // End of switch

            // Remove comment
            if( searchType == EDoRemove )
                {
                length = endPos - startPos;
                aBuf.Delete( startPos, length );
                lex = aBuf;
                searchType = ENormalSearch;
                }

        } while ( !lex.Eos() );

    // If comment is started and configure file ends to eof we remove
    // comments althougt there are no end of line or '*/' characters
    if( searchType == ECStyleSlashs || searchType == ECStyleSlashs )
        {
        length = lex.Offset() - startPos;
        aBuf.Delete( startPos, length );
        }

    HandleSpecialMarks( aBuf );

    }

//
//-----------------------------------------------------------------------------
//
//    Class: CStifParser
//
//    Method: HandleSpecialMarks
//
//    Description: Handles special marks.( '\/\/', '\/\*' and '*/\/' ). This
//         		   is used when ECStyleComments comment type is used.
//
//    Parameters: TPtr& aBuf: inout: section to parsed
//
//    Return Values: None
//
//    Errors/Exceptions: None
//
//    Status: Proposal
//
//-----------------------------------------------------------------------------
//
void CStifParser::HandleSpecialMarks( TPtr& aBuf )
    {
    TLex lex( aBuf );
    TInt firstPos( 0 );
    TInt secondPos( 0 );

    //        // => \/\/ => //
    //        /* => \/\* => /*
    //        */ => \*\/ => */
  
    do
        {
        firstPos = lex.Offset();
        TChar get = lex.Get();
        // Check is '\'
        if( get == '\\' ) 
            {
            // Peek next character( '/' )
            if( lex.Peek() == '/' )
                {
                lex.Inc();
                secondPos = lex.Offset();
                // Peek next character( '\' )
                if( lex.Peek() == '\\' )
                    {
                    lex.Inc();
                    // Peek next character( '/' )
                    if( lex.Peek() == '/' )
                        {
                        // Delete mark '\/\/' and replace this with '//'
                        aBuf.Delete( secondPos, 1 );
                        aBuf.Delete( firstPos, 1 );
                        lex = aBuf;
                        }
                    // Peek next character( '/' )
                    else if( lex.Peek() == '*' )
                        {
						// Delete mark '\/\*' and replace this with '/*'                        
                        aBuf.Delete( secondPos, 1 );
                        aBuf.Delete( firstPos, 1 );
                        lex = aBuf;
                        }
                    }
                }
            // Peek next character( '/' )
            else if( lex.Peek() == '*' )
                {
                lex.Inc();
                secondPos = lex.Offset();
                // Peek next character( '\' )
                if( lex.Peek() == '\\' )
                    {
                    lex.Inc();
                    // Peek next character( '/' )
                    if( lex.Peek() == '/' )
                        {
                        // Delete mark '\*\/' and replace this with '*\'
                        aBuf.Delete( secondPos, 1 );
                        aBuf.Delete( firstPos, 1 );
                        lex = aBuf;
                        }
                    }
                }
            }
        firstPos = 0;
        secondPos = 0;
        } while ( !lex.Eos() );

    }

//  End of File
