/*
* 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;
}