/*
* Copyright (c) 2003 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:  SVG Implementation source file
 *
*/


#include "SVGTokenizer.h"

TTokenizer::TTokenizer( const TPtrC& aString )
{
    iString.Set( Trim( aString ) );
    iCurrentIndex = 0;
    iPreviousIndex = 0;
}

TBool TTokenizer::IsAtEnd()
{
    return iCurrentIndex >= EndIndex();
}

TInt TTokenizer::EndIndex()
{
    return iString.Length();
}

TUint16 TTokenizer::NextChar()
{
    if ( IsAtEnd() )
        return '\0';
    else
        return iString[iCurrentIndex];
}

void TTokenizer::Advance( TInt aCount )
{
    iCurrentIndex += aCount;
    if ( iCurrentIndex > EndIndex() )
        iCurrentIndex = EndIndex();
    else if ( iCurrentIndex < 0 )
        iCurrentIndex = 0;

    iPreviousIndex = iCurrentIndex;
}

TBool TTokenizer::SkipInteger()
{
    if ( iCurrentIndex >= EndIndex() )
        return EFalse;

    if ( NextChar() == '-' || NextChar() == '+' )
    {
        TInt index = iCurrentIndex;
        iCurrentIndex++;
        if ( SkipInteger() )
        {
            iPreviousIndex = index;
            return ETrue;
        }
        else
        {
            iCurrentIndex = index;
            iPreviousIndex = iCurrentIndex;
            return EFalse;
        }
    }

    iPreviousIndex = iCurrentIndex;
    TInt index = iCurrentIndex;

    while ( index < EndIndex() && IsDigit( iString[index] ) )
    {
        index++;
    }
    if ( IsAtEnd() )
        return EFalse;

    iCurrentIndex = index;
    return ETrue;
}

TBool TTokenizer::SkipDecimal()
{
    if ( iCurrentIndex >= EndIndex() )
        return EFalse;

    if ( NextChar() == '-' || NextChar() == '+' )
    {
        TInt index = iCurrentIndex;
        iCurrentIndex++;
        if ( NextChar() != '-' && NextChar() != '+' && SkipDecimal() )
        {
            iPreviousIndex = index;
            return ETrue;
        }
        else
        {
            iCurrentIndex = index;
            iPreviousIndex = iCurrentIndex;
            return EFalse;
        }
    }

    if ( NextChar() == '.' )
    {
        TInt index = iCurrentIndex;
        Advance( 1 ); // skip '.'
        if ( !IsDigit( NextChar() ) )
        {
            // Only found '.' and no digits following
            Advance( -1 );
            return EFalse;
        }
        else
        {
            // '.xxx'
            SkipInteger();
            iPreviousIndex = index;
            return ETrue;
        }
    }
    else if ( IsDigit( NextChar() ) )
    {
        SkipInteger();
        if ( NextChar() != '.' )
        {
            // 'xxx'
            return ETrue;
        }
        else
        {
            TInt index = iPreviousIndex;//iCurrentIndex;
            Advance( 1 ); // skip '.'

            SkipInteger();
            iPreviousIndex = index;
            return ETrue;
        }

    }
    return EFalse;
}

TBool TTokenizer::SkipHex()
{
    if ( iCurrentIndex >= EndIndex() )
        return EFalse;

    iPreviousIndex = iCurrentIndex;
    TInt index = iCurrentIndex;

    while ( index < EndIndex() && IsHexDigit( iString[index] ) )
    {
        index++;
    }
    if ( IsAtEnd() )
        return EFalse;

    iCurrentIndex = index;
    return ETrue;
}

TBool TTokenizer::SkipWhiteSpace()
{
    if ( iCurrentIndex >= EndIndex() )
        return EFalse;

    iPreviousIndex = iCurrentIndex;
    TInt index = iCurrentIndex;

    while ( index < EndIndex() && IsWhiteSpace( iString[index] ) )
    {
        index++;
    }
    if ( IsAtEnd() )
        return EFalse;

    iCurrentIndex = index;
    return ETrue;
}

TBool TTokenizer::SkipUntil( TUint16 aChar )
{
    if ( IsAtEnd() )
        return EFalse;

    iPreviousIndex = iCurrentIndex;

    TPtrC remaining( &iString.Ptr()[iCurrentIndex], iString.Length() - iCurrentIndex );
    TInt index = IndexOf( remaining, aChar );
    if ( index == -1 )
        return EFalse;

    iCurrentIndex += index;
    return ETrue;
}

TBool TTokenizer::SkipUntilEnd( )
{
    if ( IsAtEnd() )
        return EFalse;

    iPreviousIndex = iCurrentIndex;

    TPtrC remaining( &iString.Ptr()[iCurrentIndex], iString.Length() - iCurrentIndex );
    TInt index = remaining.Length();

    iCurrentIndex += index;
    return ETrue;
}

TBool TTokenizer::StartsWith( const TDesC& aString )
{
    if ( IsAtEnd() || aString.Length() > iString.Length() - iCurrentIndex )
        return EFalse;

    TPtrC remaining( &iString.Ptr()[iCurrentIndex], aString.Length() );
    return remaining == aString;
}

TPtrC TTokenizer::SkippedString()
{
    return TPtrC( &iString.Ptr()[iPreviousIndex], iCurrentIndex - iPreviousIndex );
}

TPtrC TTokenizer::Remainder()
{
    if ( iString.Length() == 0 )
        return TPtrC( NULL, 0 );
    else
        return TPtrC( &iString.Ptr()[iCurrentIndex], iString.Length() -  iCurrentIndex );
}
//------------------------------------------------------
// Helping Functions
//------------------------------------------------------
TBool TTokenizer::IsWhiteSpace( TUint16 aChar )
{
    return ( aChar == ' ' ) || ( aChar == '\t' ) || ( aChar == '\n' );
}

TBool TTokenizer::IsDigit( TUint16 aChar )
{
    return ( aChar >= '0' && aChar <= '9' );
}

TBool TTokenizer::IsHexDigit( TUint16 aChar )
{
    return ( aChar >= '0' && aChar <= '9' ) ||
           ( aChar >= 'a' && aChar <= 'f' ) ||
           ( aChar >= 'A' && aChar <= 'F' );
}

TInt TTokenizer::IndexOf( const TDesC& aString, TUint16 aChar )
{
    TInt length = aString.Length();
    for ( TInt i = 0; i < length; i++ )
    {
        if ( aString[i] == aChar )
            return i;
    }
    return -1;
}

TPtrC TTokenizer::Trim( const TDesC& aString )
{
    TInt startIndex = 0;
    for ( ; startIndex < aString.Length() && IsWhiteSpace( aString[startIndex] ); startIndex++ )
    {
    }

    TInt endIndex = aString.Length();
    for ( ; endIndex > 0 && IsWhiteSpace( aString[endIndex-1] ); endIndex-- )
    {
    }

    return TPtrC( &aString.Ptr()[startIndex], endIndex - startIndex );
}

TBool TTokenizer::ParseDecimal( const TDesC& aString, TReal32& aValue, TPtrC& aRemainder )
    {
    TTokenizer tokenizer( aString );
    tokenizer.SkipWhiteSpace();
    
    // blank, setting to zero
    if ( tokenizer.IsAtEnd() )
        {
        return EFalse;
        }
    
    if ( tokenizer.SkipDecimal() )
        {
        // Decimal number, extract it
        TPtrC decimalString = tokenizer.SkippedString();
        TLex lex( decimalString );
        // Specify the decimal seperator, instead of using
        // locale specific seperator.
        lex.Val( aValue, '.' );
        
        tokenizer.SkipWhiteSpace();
        aRemainder.Set( tokenizer.Remainder() );
        return ETrue;
        }
    return EFalse;
    }