/*
* 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 "SVGPointLexer.h"

#include "stdlib.h"
#include "string.h"

// Below define is used as a mask for getting LSB of 16bit number
// for endian-agnostic progressing.
#define KLSBMASK ( 0xFF )
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TSvgPointLexer::TSvgPointLexer( const TDesC& aDes ) :
                iLex( aDes ), iNegativeNumber( EFalse )
{
    iDataCopy = NULL;
    iDataCopy = aDes.Alloc();
    if ( iDataCopy )
    {
        iData = (TUint16 *)iDataCopy->Ptr();
        iDataEnd = iData + iDataCopy->Length();
    }
}

void TSvgPointLexer::Cleanup()
{
    if ( iDataCopy )
    {
        delete iDataCopy;
        iDataCopy = NULL;
    }
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt32 TSvgPointLexer::GetNext( TChar& aCommand, TFloatFixPt& aVal )
    {
    TReal32 realnum = 0.0;

    // Parse a command and minus symbol
    iNegativeNumber = EFalse;
    aCommand = SkipUntilNum();
    if ( iLex.Eos() && aCommand != 'z' )
        {
        return -1;
        }
    else if ( aCommand == 'z' )
        {
        // if 'z' was found return immediately
        // never parse for numbers
        return KErrNone;
        }

    // Parse a number with fraction
    iLex.Mark();
    if ( SkipToNumEnd() )
        {
         TInt result = TLex( iLex.MarkedToken() ).Val( realnum, '.' ) ;
	     if (result != KErrNone)
			{
			realnum= 0.0;
			return result;
			}
        }
    else
        {
        realnum = 0.0;
        }
    if ( iNegativeNumber )
        realnum = -realnum;
    aVal = ( TFloatFixPt ) realnum;

    return KErrNone;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------

TBool TSvgPointLexer::GetNextWithNumOfPoints( TFloatFixPt *aVal, TInt NoOfPoints)
    {
    TReal32 realnum = 0.0;
	TUint8 tmpchar;
    TInt i=0;

	for( i=0;i < NoOfPoints;i++ )
		{
        // Since iData is a TUint16 pointer, and we need to 
        // operate with 8bit ASCII, mask LSB to obtain the same
		tmpchar = *iData & KLSBMASK;
        // Traverse the string while character encountered is
        // ' ', LineFeed('\0xa'), ',', Carriage Return ('\0xd')
		while( !(tmpchar^32) || !(tmpchar^10) || !(tmpchar^44) || !(tmpchar^13) )
			{
			iData++;
            if ( iData < iDataEnd )    
                {
		        tmpchar = *iData & KLSBMASK;
                }
            else
                {
                // Exceeding buffer limits, return error
                return EFalse;
                }
			}

        // Check if character encountered is '-' 
		if( !(tmpchar^45) )
			{
			iData++;

            if ( iData < iDataEnd )
                {
    			if(SkipToNumEndWithoutLex(realnum) )
    				{
    				realnum = -realnum;
    				}
    			else
    				{
    				return EFalse;
    				}
                }
            else // if ( iData < iDataEnd )
                {
                // Exceeding buffer limits, return error
                return EFalse;
                }
			}
		else // Not a '-' char
			{
			    if( !(tmpchar^43) ) // to increment the data if '+' is given
			        {
			        iData++;    
			        }
			
			if( !SkipToNumEndWithoutLex(realnum) )
				{
				return EFalse;
				}
			}
        // Save the converted number into float array 
        // provided by caller.
		aVal[i] = ( TFloatFixPt )(realnum);
		}

	return ETrue;
    }


//
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt32 TSvgPointLexer::GetNextPoint( TChar& aCommand, TFloatFixPt& aX, TFloatFixPt& aY )
    {
    TReal32 realnum = 0.0;

    // Parse X value
    iNegativeNumber = EFalse;
    aCommand = SkipUntilNum();
    if ( iLex.Eos() )
        {
        return -1;
        }
    iLex.Mark();
    if ( SkipToNumEnd() )
        {
        TInt result = TLex( iLex.MarkedToken() ).Val( realnum, '.' ) ;
		if (result != KErrNone)
			{
			realnum= 0.0;
			return result;
			}
        }
    else
        {
        realnum = 0.0;
        }
    if ( iNegativeNumber )
        realnum = -realnum;
    aX = realnum;

    // Parse Y value
    iNegativeNumber = EFalse;
    iLex.Mark();
    SkipUntilNum();
    if ( iLex.Eos() )
        {
        return -1;
        }
    iLex.Mark();
    if ( SkipToNumEnd() )
        {
       TInt result = TLex( iLex.MarkedToken() ).Val( realnum, '.') ;
	   if (result != KErrNone)
			{
			realnum= 0.0;
			return result;
			}
        }
    else
        {
        realnum = 0.0;      // exponential description
        }
    if ( iNegativeNumber )
        realnum = -realnum;
    aY = realnum;

    return KErrNone;
    }

//
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool TSvgPointLexer::SkipToNumEnd()
    {
    TChar tmpchar = iLex.Peek();
    TBool tmpbool = ETrue;
    TBool acceptMinus = EFalse;

	while ( tmpchar.IsDigit() ||
            !(tmpchar^46) ||
            ( !(tmpchar^45) && acceptMinus ) )
        {
        iLex.Inc();
        tmpchar = iLex.Peek();
        acceptMinus = EFalse;

		if ( !(tmpchar^101) || !(tmpchar^69) )
            {
            // exponential value
            iLex.Inc();
            tmpchar = iLex.Peek();
            tmpbool = EFalse;
            acceptMinus = ETrue;
            }
        }
    return tmpbool;
    }

//
// ---------------------------------------------------------------------------
// TBool TSvgPointLexer::SkipToNumEndWithoutLex(TReal32 &aNum)
//   This function parses the number at the current position into aNum
// ---------------------------------------------------------------------------
TBool TSvgPointLexer::SkipToNumEndWithoutLex(TReal32 &aNum)
    {
    TBool numberFound = EFalse;
    TReal32 lNumber=0;
    // Since iData is a TUint16 pointer, and we need to 
    // operate with 8bit ASCII, mask LSB to obtain the same
    TUint8 tmpchar = *iData & KLSBMASK;
    TInt fractionPart=0;

    // Scan through the string while the character is 
    // between '0' and '9' 
    // or is '.'
    // and there are more characters in the string
    while ( (((tmpchar > 47) && (tmpchar < 58) )||
            !(tmpchar^46)) && iData < iDataEnd )
        {
        // If a '.' is not found
        if(tmpchar^46)
            {
            // This means that the char is between '0' and '9'
            numberFound = ETrue;
            // Append it to lNumber
            lNumber = 10*lNumber + (tmpchar -'0');

            if(fractionPart)
                {
                fractionPart++;
                }
            }
        else // '.' is found
            {
            fractionPart++;
            }
        
        iData++;
        if ( iData < iDataEnd )
            {
            tmpchar = *iData & KLSBMASK;
            
            // Check if characted is 'e' or 'E'
            // for eg. -3.486e-007
            // This is for floating point representation and is
            // not supported currently. Such numbers are treated 
            // as 0.0. 
            // The number is skipped.
            if ( (!(tmpchar^101) || !(tmpchar^69)) )
                {
                iData++;
                if ( iData < iDataEnd )
                    {
                    tmpchar = *iData & KLSBMASK;                    
                
                    // Check if character is '-', if so 
                    // skip it 
                    if( !(tmpchar^45) )
                        {
                        iData++;
                        if ( iData < iDataEnd )
                            {
                            tmpchar = *iData & KLSBMASK;
                            }
                        }
                    // Skip the numbers and decimal point after 'e'
                    while ( ( ( ( tmpchar > 47 ) && ( tmpchar < 58 ) ) ||
                        !( tmpchar^46 ) ) && ( iData < iDataEnd ) )
                        {
                        iData++;
                        if ( iData < iDataEnd )
                            {
                            tmpchar = *iData & KLSBMASK;
                            }
                        }
                    }
                aNum = 0.0;
                return numberFound;
               } // if (exponential number)  
            } // if iData < iDataEnd
        } // end while 
    // Account for decimal point by performing following calculation
    // lNumber = lNumber / ( 10^ ( fractionPart - 1 ) )
    if(numberFound)
        {
        TInt l=0;
        TInt k=1;
        while(l<(fractionPart-1))
            {
            k=(k*10);
            l++;
            }
        lNumber = (lNumber/k);
        aNum = lNumber;
        }

    return numberFound;
    }




//
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TChar TSvgPointLexer::SkipUntilNum()
    {
    TChar ret = '\0';
    iLex.SkipSpace();
    TChar tmpchar = iLex.Peek();
    // skip until finding a digit or '.'

    while ( !( tmpchar.IsDigit() || tmpchar == '.' ) && !iLex.Eos() )
        {
        if ( tmpchar == '-' )
            {
            iNegativeNumber = ETrue;
            }
        else if ( tmpchar == 'Z' || tmpchar == 'z' )
            {
            // if 'Z' or 'z' was found, return imediately.
            iLex.Inc();
            return 'z';
            }
        else if ( tmpchar != ' ' && tmpchar != ',' && tmpchar != '\n' )
            // a better way may be for only selected characters to be recognized and not ignored.
        {
            ret = tmpchar;
            }
        iLex.Inc();
        tmpchar = iLex.Peek();
        }

    return ret;
    }


//
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool TSvgPointLexer::GetCommand(TUint8 &a)
{
    a = '\0';
    TUint8 tmpchar;
    while (iData < iDataEnd )
        {
        tmpchar = *iData & KLSBMASK;
        // If character is a not between '0' and '9' and not '.' and '-'
        if (!((tmpchar > 47) && (tmpchar < 58)) && (tmpchar^46) && (tmpchar^45) )
             {
             // Check if character is an alphabet
             if((tmpchar >=65 && tmpchar <= 90) || (tmpchar >=97 && tmpchar <= 122) )
                {
                a = tmpchar;
                iData++;
                return ETrue;
                }
            else
                {
                iData++;
                }
             }
         else
             {
             return ETrue;
             }

        }
   return EFalse;

}