// Copyright (c) 2002-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:
// $Header$
// This module implements TfrLex collection of static lexical functions.
// rev: mjdavey, symbian@mjdss.com, July 2002
// for: Typhoon (7.0s) & JetStream (8.0)
//
//
#include <e32std.h> //
#include <e32cons.h>
//-----------------------------------------------------------------------------
// Include Files
#include "TfrLex.h" // this module
//-----------------------------------------------------------------------------
// Extract (skip over) a term.
//-----------------------------------------------------------------------------
TInt TfrLex::Val( TLex& aLex, const TDesC& aTerm )
{
TLex term( aTerm );
TLexMark mark;
aLex.Mark( mark );
while ( !term.Eos() )
{
if ( aLex.Eos() || term.Get() != aLex.Get() )
{
aLex.UnGetToMark( mark );
return KErrNotFound;
}
}
return KErrNone;
}
//-----------------------------------------------------------------------------
// Extract (check if text begins with) a term.
TBool TfrLex::Val( const TDesC& aText, const TDesC& aTerm )
{
TLex lex( aText );
return ( Val( lex, aTerm ) == KErrNone );
}
//-----------------------------------------------------------------------------
// Extract (skip over) a term. Folded comparison.
TInt TfrLex::ValF( TLex& aLex, const TDesC& aTerm )
{
TLex term( aTerm );
TLexMark mark;
aLex.Mark( mark );
while ( !term.Eos() )
{
if ( aLex.Eos() || User::Fold(term.Get()) != User::Fold(aLex.Get()) )
{
aLex.UnGetToMark( mark );
return KErrNotFound;
}
}
return KErrNone;
}
//-----------------------------------------------------------------------------
// Extract (check if text begins with) a term.
TBool TfrLex::ValF( const TDesC& aText, const TDesC& aTerm )
{
TLex lex( aText );
return ( ValF( lex, aTerm ) == KErrNone );
}
//-----------------------------------------------------------------------------
// Extract (check if text begins with) a term.
//
// Skip spaces and get token up to end-of-string, a space char or up to the
// very character you define. The GetF supports tokens like "*". If a token
// begins with apostrophe but does not end to one, the function L E A V E S
// with error KErrArgument.
TPtrC TfrLex::GetL( TLex& aLex, const TChar aChar )
{
// Skip spaces and mark the token's start point.
aLex.SkipSpace();
TLexMark mark;
aLex.Mark(mark);
if (aLex.Peek() == '"' )
{
// Skip the " and do find next " followed by eos, space or aChar.
aLex.Inc();
TChar x;
while ( x = aLex.Get(), !x.Eos() )
{
if ( x == '"' )
{
// Found a " character - but is it the end of the token?
x = aLex.Peek(); // peek the next character
if ( x.Eos() || x.IsSpace() || x == aChar )
// End of token: return token.
return aLex.MarkedToken(mark);
}
}
// Unget and L E A V E because did not find the end " of token.
aLex.UnGetToMark(mark);
User::Leave(KErrArgument);
return aLex.MarkedToken(mark); // never reached (l e a v e).
}
else
{
// Is not a "*" token: find eos or the next space or the aChar
// and return the token.
TChar x;
while ( x = aLex.Peek(), !x.Eos() && !x.IsSpace() && x != aChar )
aLex.Inc();
return aLex.MarkedToken(mark);
}
}
//-----------------------------------------------------------------------------
// Skip spaces and get token up to end-of-string, a space char or up to the
// very characters you define. The GetF supports tokens like "*". If token
// begins with apostrophe but does not end to one, the function L E A V E S
// with error KErrArgument.
TPtrC TfrLex::GetL( TLex& aLex, const TDesC& aList )
{
// Skip spaces and mark the token's start point.
aLex.SkipSpace();
TLexMark mark;
aLex.Mark(mark);
if ( aLex.Peek() == '"' )
{
// Skip the " and do find next " followed by eos, space or any char
// in the aList.
aLex.Inc();
TChar x;
while ( x = aLex.Get(), !x.Eos() )
{
if ( x == '"' )
{
// Found a " character - but is it the end of the token?
x = aLex.Peek();
if ( x.Eos() || x.IsSpace() || aList.Locate(x) < 0 )
// End of token: return token.
return aLex.MarkedToken(mark);
}
}
// Unget and L E A V E because did not find the end " of token.
aLex.UnGetToMark(mark);
User::Leave(KErrArgument);
return aLex.MarkedToken(mark); // never reached (l e a v e).
}
else
{
// Is not a "*" token: find eos or the next space or any char
// in the aList and return the token.
TChar x;
while ( x = aLex.Peek(), !x.Eos() && !x.IsSpace() && aList.Locate(x) < 0 )
aLex.Inc();
return aLex.MarkedToken(mark);
}
}
//-----------------------------------------------------------------------------
// Skip spaces and then eat the very character or the very term you define.
// Return ETrue (was found and swallowed) or EFalse.
// Skip spaces and eat a particular character.
//
TBool TfrLex::Eat( TLex& aLex, const TChar aChar )
{
TLexMark unget;
if ( aChar.IsSpace() )
{
// A space character requires its own logic = go over
// the other space characters - x gets the next char.
TChar x;
aLex.Mark(unget);
while ( x = aLex.Get(), x.IsSpace() && x != aChar )
{};
if ( x == aChar )
return ETrue;
}
else
{
// For other, non-space, characters: skip spaces and
// get the next character x.
aLex.SkipSpace();
aLex.Mark(unget);
if ( aLex.Get() == aChar )
return ETrue;
}
// The character wasn't there, unget to the start point.
aLex.UnGetToMark(unget);
return EFalse;
}
//-----------------------------------------------------------------------------
// Skip spaces and eat a term, exact comparison.
TBool TfrLex::Eat( TLex& aLex, const TDesC& aTerm )
{
aLex.SkipSpace();
TLexMark unget;
aLex.Mark(unget);
if ( Val(aLex,aTerm) == KErrNone )
return ETrue;
aLex.UnGetToMark(unget);
return EFalse;
}
//-----------------------------------------------------------------------------
// Skip spaces and eat a term, folded comparison.
//
TBool TfrLex::EatF( TLex& aLex, const TDesC& aTerm )
{
aLex.SkipSpace();
TLexMark unget;
aLex.Mark(unget);
if ( ValF(aLex,aTerm) == KErrNone ) return ETrue;
aLex.UnGetToMark(unget);
return EFalse;
}
//-----------------------------------------------------------------------------
// Get from first non white space onwards.
TPtrC TfrLex::TrimLeft( const TDesC& aText )
{
TLex lex( aText );
lex.SkipSpaceAndMark();
return lex.Remainder();
}
//-----------------------------------------------------------------------------
// Get up to the last non white space.
TPtrC TfrLex::TrimRight( const TDesC& aText )
{
TLex lex( aText );
TPtrC remainder;
do
{
lex.SkipCharacters();
remainder.Set( lex.MarkedToken() );
lex.SkipSpace();
} while ( !lex.Eos() );
return remainder;
}
//-----------------------------------------------------------------------------
// Get from first non white space onwards and up to last non white space.
// Is TrimLeft and TrimRight.
TPtrC TfrLex::Trim( const TDesC& aText )
{
return TrimRight( TrimLeft( aText ) );
}
//-----------------------------------------------------------------------------
// Peel = Get text like "*" without the two apostrophes. If not like "*",
// then returns the text as such as the whole.
TPtrC TfrLex::Peel( const TDesC& aText )
{
TPtrC result;
TInt length = aText.Length();
if ( length >= 2 && (aText[0] == '"' && aText[length-1] == '"') )
result.Set( aText.Mid(1,length-2) );
else
result.Set( aText );
return result;
}
//-----------------------------------------------------------------------------
// Trim and then Peel.
TPtrC TfrLex::TrimAndPeel( const TDesC& aText )
{
return Peel(Trim(aText));
}
//-----------------------------------------------------------------------------
// Peel and them Trim.
TPtrC TfrLex::PeelAndTrim( const TDesC& aText )
{
return Trim(Peel(aText));
}
//-----------------------------------------------------------------------------
// End of File
//-----------------------------------------------------------------------------