// Copyright (c) 2000-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:

//

#include <cbnfparser.h>

#include <cnodeleteattribute.h>

#include <attrlut.h>

#include <estatus.h>

#include <e32base.h>

#include "BNFPanicCodes.h"

/** Allocates and constructs a new BNF parser.

@return New parser

@param aLUT Attribute lookup table in which to store attributes for 

the rule tree

*/

EXPORT_C CBNFParser* CBNFParser::NewL(CAttributeLookupTable& aLUT)

	{

	CBNFParser* model = new (ELeave) CBNFParser(aLUT);

	return (model);

	}

/** Constructor.

@param aLUT Attribute lookup table

*/

EXPORT_C CBNFParser::CBNFParser(CAttributeLookupTable& aLUT)

    : iLUT(aLUT)

	{

// store pointers to these to avoid continual unnecessary calls to the CBNFNode DLL

	iReferenceString=CBNFNode::KReference();

	iRangeStart=CBNFNode::KRangeStart();

	iRangeEnd=CBNFNode::KRangeEnd();

	iMoreMinimum=CBNFNode::KNMoreMinimum();

	iMoreCount=CBNFNode::KNMoreCount();

	iMoreMaximum=CBNFNode::KNMoreMaximum();

	iPreRuleCallback=CBNFNode::KPreRuleCallback();

	iPostRuleCallback=CBNFNode::KPostRuleCallback();

	}

/** Destructor.

*/

EXPORT_C CBNFParser::~CBNFParser()

	{

	delete iTree;

	}

/**  Reset the parser to a state where it can accept and parse new input.

If no BNF tree yet exists the virtual method TreeL() is called to obtain the BNF tree for this parser.

Any existing state of parsing and input data is destroyed. */

EXPORT_C void CBNFParser::ResetL()

	{

	if (iTree == NULL)

		iTree = TreeL();

	iRuleStack.Clear();

	iRuleStack.PushL(iTree);

	iSubRuleMatched = EFalse;

	iSubRule = NULL;

	iStringComplete = EFalse;

	iString.Reset();

	}

/** Gets the attribute look-up table used by this parser.

@return Attribute look-up table

*/

EXPORT_C CAttributeLookupTable& CBNFParser::AttributeLUT() const

    {

	return iLUT;

	}

/** Processes a reference rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::ReferenceL(CBNFNode& aRule, CFragmentedString::TStringMatch& /*aMatched*/)

// Handle a reference node.

// The pointer to the refered rule is stored as an attribute to a node which

// is stored as an attribute to the reference node. Nice and simple, isn't it? :-)

    {

    // new to this Reference, or returning from a sub match?

    if (iSubRule)

		// No operation is required when returning from the refered rule - continue up.

        return ETrue;

    else

        {

        CNoDeleteAttributeT<CBNFNode*>* attributeNode = REINTERPRET_CAST(CNoDeleteAttributeT<CBNFNode*>*, aRule.Attribute(iReferenceString));

//        iRuleStack.Pop(); //Optimisation not possible as other bnf parts use this 'rule' node to find the next sibling (i.e. And, Or etc)

        iRuleStack.PushL(attributeNode->Attribute());

        }

    return EFalse;

    }

/** Processes an EExact rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::ExactL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle an EExact rule

// Attempts to match a string with the stream.

    {

    if ((aMatched=iString.Match(REINTERPRET_CAST(HBufC*, aRule.Data())->Des()))==CFragmentedString::EMatch)

        iString.ConsumeMatched();

    return ETrue;

    }

/** Processes an ERange rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::RangeL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle ERange rule

// Checks if the next character in the stream fits into the chracter range defined by the rule

    {

    CNoDeleteAttributeT<TInt>* rangeStartAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TInt>*, aRule.Attribute(iRangeStart));

    TInt rangeStart;

    if (rangeStartAttribute)

        rangeStart = rangeStartAttribute->Attribute();

    else

        rangeStart = 0;

    CNoDeleteAttributeT<TInt>* rangeEndAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TInt>*, aRule.Attribute(iRangeEnd));

    TInt rangeEnd;

    if (rangeEndAttribute)

        rangeEnd = rangeEndAttribute->Attribute();

    else

        rangeEnd = 0;

    if ((aMatched = iString.MatchRange(rangeStart, rangeEnd)) == CFragmentedString::EMatch)

        iString.ConsumeMatched();

    return ETrue;

    }

/** Processes an ESelect rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::SelectL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle Select rule

// Check if the next character in the stream matches to any of the chracters included

// into the set defined by the select rule.

// The selection can also be performed as inverted selection (by using "^" as the first char)

// in which case all the other characters but the ones defined in the set match correctly to the stream.

    {

    if ((*aRule.Data())[0] == '^')

        aMatched = iString.MatchNotSelect((*REINTERPRET_CAST(HBufC*, aRule.Data())).Mid(1));

    else

        aMatched = iString.MatchSelect(*REINTERPRET_CAST(HBufC*, aRule.Data()));

//!	if (aMatched == CFragmentedString::EMatch)

    iString.ConsumeMatched();

    return ETrue;

    }

/** Processes an EWithout rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::WithoutL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle EWithout rule

// An example Without rule: [A-Z] - B

// Here we are trying to match all characters from A-Z except character B.

// The rule is performed here by first executing the latter part of the rule (in the example

// by trying to match B). If the latter rule matches, then the stream contains the chracter

// string we didn't want it to include and hence the Without rule is false. However, if the

// latter rule doesn't match we proceed to matching the first part of the rule and if it

// does match the whole Without rule is true.

// The Without rule node has two children of which the first one (child on index 0)

// is the rule we are trying to match and the second child is the "except" part of the rule.

    {

    TBool performedMatch = EFalse;

    // new to this Without, or returning from a sub match?

    CBNFNode* newRule = NULL;

    if (iSubRule)

        {

        if (iSubRule == aRule.Child(1))

            {

            iString.ResetToMark();

            iString.DeleteMark();

            if (!iSubRuleMatched)

                newRule = REINTERPRET_CAST(CBNFNode*, aRule.Child(0));

            else

                aMatched = CFragmentedString::ENoMatch;

            }

        }

    else

        {

        iString.Mark(); // Mark can leave

        StartConditional((enum TParserNodeTypes)aRule.Type());

        newRule = REINTERPRET_CAST(CBNFNode*, aRule.Child(1));

        }

    if (newRule)

        {

        iRuleStack.PushL(newRule);

        iSubRule = NULL; // going down

        }

    else

        {

        EndConditional((enum TParserNodeTypes)aRule.Type(), iSubRuleMatched);

        performedMatch = ETrue;

        }

    return performedMatch;

    }

/** Processes an EAnd rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::AndL(CBNFNode& aRule, CFragmentedString::TStringMatch& /*aMatched*/)

// Handle And rule

// An EAnd rule is true if all of its children are true. Processing the child nodes of

// the And rule continues until all the children has been processed of one of them doesn't

// match. Notice, that the order of the child rules has signifigance, since we are

// matching a chracter stream and the first child is matched first, followed by the second etc.

    {

    TBool performedMatch = EFalse;

    // new to this And, or returning from a sub match?

    CBNFNode* newRule = NULL;

    if (iSubRule)

        {

        if (iSubRuleMatched)

            {

            newRule = REINTERPRET_CAST(CBNFNode*, iSubRule->NextSibling());

            if (!newRule)

                performedMatch = ETrue;

            }

        else

            performedMatch = ETrue;

        }

    else

        {

        newRule = REINTERPRET_CAST(CBNFNode*, aRule.Child(0));

        StartConditional((enum TParserNodeTypes)aRule.Type());

        }

    if (newRule)

        {

        iRuleStack.PushL(newRule);

        iSubRule = NULL; // going down

        }

    else

		{

        EndConditional((enum TParserNodeTypes)aRule.Type(), iSubRuleMatched);

//!		performedMatch = ETrue;

		}

    return performedMatch;

    }

/** Processes an EOr rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::OrL(CBNFNode& aRule, CFragmentedString::TStringMatch& /*aMatched*/)

// Handle Or rule

// We attempt to match the child rules of the Or node and stop when we have the first match.

// With the Or type rule each of the child rules are matched agaist the same bit of input

// stream. Before we start processing the first child rule we set a mark to the input stream

// and if a child rule doesn't match, we rollback the input stream to the mark and try

// to match the next child.

    {

    TBool performedMatch = EFalse;

    CBNFNode* newRule = NULL;

    // new to this Or, or returning from a sub match?

    if (iSubRule)

        {

        if (!iSubRuleMatched)

            {

            newRule = REINTERPRET_CAST(CBNFNode*, iSubRule->NextSibling());

            }

        EndConditional((enum TParserNodeTypes)aRule.Type(), iSubRuleMatched);

        }

    else

        {

        newRule = REINTERPRET_CAST(CBNFNode*, aRule.Child(0));

        iString.Mark(); // Mark can leave

        }

    if (newRule)

        {

        iRuleStack.PushL(newRule);

        iSubRule = NULL; // going down

        iString.ResetToMark();

        StartConditional((enum TParserNodeTypes)aRule.Type());

        }

    else

        {

        performedMatch = ETrue;

        if (!iSubRuleMatched)

            iString.ResetToMark();

        iString.DeleteMark();

        }

    return performedMatch;

    }

EXPORT_C TBool CBNFParser::OptionalL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle Optional rule

// Process the subrule attached to the optional rule.

// An optional rule is always successfully processed regardless to success or failure of matching

// the subrule. This is because of the nature of the optional rule - the subrule here either may

// or may not be there.

    {

    TBool performedMatch = EFalse;

    // new to this Optional, or returning from a sub match?

    if (iSubRule)

        {

        performedMatch = ETrue;

        aMatched = CFragmentedString::EMatch;

        iOptionalMatched = iSubRuleMatched;

        if (!iSubRuleMatched)

            iString.ResetToMark();

        iString.DeleteMark();

        }

    else

        {

        iString.Mark(); // Mark can leave

        iRuleStack.PushL(REINTERPRET_CAST(CBNFNode*, aRule.Child(0)));

        iSubRule = NULL;

        }

    return performedMatch;

    }    

/** Processes an ENMore rule node.

It is called by PerformRuleL().

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule The rule node being processed

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C TBool CBNFParser::NMoreL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Handle NMore rule

// NMore rule implements the "multiplier" elements of BNF (* and +).

// We attempt to match the subrule and if it matches we try again until it doesn't match

// or we run into the upperlimit set to this rule.

// An NMore rule may contain lower and upper limits for the number of times the matching

// can or needs to be done. These are included as attributes to the NMore node. The NMore

// node also holds a counter attribute, which holds the amount of times this rule has been

// matched.

    {

    TBool performedMatch = EFalse;

    // new to this NMore, or returning from a sub match?

    if (iSubRule)

        {

        CNoDeleteAttributeT<TInt>* countAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TInt>*, aRule.Attribute(iMoreCount));

        CNoDeleteAttributeT<TInt>* maxCountAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TInt>*, aRule.Attribute(iMoreMaximum));

        if (iSubRuleMatched)

            countAttribute->SetAttribute(countAttribute->Attribute()+1);

        else

            {

            performedMatch = ETrue;

            CNoDeleteAttributeT<TInt>* minCountAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TInt>*, aRule.Attribute(iMoreMinimum));

            if ((minCountAttribute == NULL) || (countAttribute->Attribute() >= minCountAttribute->Attribute()))

                aMatched = CFragmentedString::EMatch;

            iString.ResetToMark();

            }

        if ((maxCountAttribute) && (countAttribute->Attribute() >= maxCountAttribute->Attribute()))

            performedMatch = ETrue;

        iString.DeleteMark();

        }

    else

        {

        aRule.DeleteAttribute(iMoreCount);

        CNoDeleteAttributeT<TInt>* countAttribute = new (ELeave) CNoDeleteAttributeT<TInt>(0);

        CleanupStack::PushL(countAttribute);

        aRule.AddAttributeL(iMoreCount, countAttribute);

        CleanupStack::Pop();

        }

    if (!performedMatch)

        {

        iRuleStack.PushL(REINTERPRET_CAST(CBNFNode*, aRule.Child(0)));

        iSubRule = NULL;

        iString.Mark(); // Mark can leave

        }

    return performedMatch;

    }

/** Executes a pre-rule callback function.

@param aRule Node specifying the callback

*/

EXPORT_C

void

CBNFParser::ExecutePreRuleCallbackL(CBNFNode& aRule)

    {

    CNoDeleteAttributeT<TRuleCallback*>* preRuleAttribute;

    if ((preRuleAttribute= REINTERPRET_CAST(CNoDeleteAttributeT<TRuleCallback*>*, aRule.Attribute(iPreRuleCallback)))!=NULL)

        (*preRuleAttribute->Attribute())(*this);

    }

/** Executes a post-rule callback function.

@param aRule Node specifying the callback

*/

EXPORT_C

void

CBNFParser::ExecutePostRuleCallbackL(CBNFNode& aRule)

    {

    CNoDeleteAttributeT<TRuleCallback*>* postRuleAttribute;

    if ((postRuleAttribute = REINTERPRET_CAST(CNoDeleteAttributeT<TRuleCallback*>*, aRule.Attribute(iPostRuleCallback)))!=NULL)

        (*postRuleAttribute->Attribute())(*this);

    }

/** Handles a node in the rule tree.

It calls the appropriate handler method for the rule type.

@return ETrue if the function completed processing this node, otherwise EFalse

@param aRule Rule node

@param aMatched On return, flag indicating if input stream matched the rule

*/

EXPORT_C

TBool

CBNFParser::PerformRuleL(CBNFNode& aRule, CFragmentedString::TStringMatch& aMatched)

// Dispatches a rule node of given type to the appropriate handler

	{

    TBool performedMatch;

    switch (aRule.Type())

        {

    case EReference:

        performedMatch = ReferenceL(aRule, aMatched);

        break;

    case EExact:

        performedMatch = ExactL(aRule, aMatched);

        break;

    case ERange:

        performedMatch = RangeL(aRule, aMatched);

        break;

    case ESelect:

        performedMatch = SelectL(aRule, aMatched);

        break;

    case EWithout:

        performedMatch = WithoutL(aRule, aMatched);

        break;

    case ERoot:

    case EAnd:

        performedMatch = AndL(aRule, aMatched);

        break;

    case EOr:

        performedMatch = OrL(aRule, aMatched);

        break;

    case EOptional:

        performedMatch = OptionalL(aRule, aMatched);

        break;

    case ENMore:

        performedMatch = NMoreL(aRule, aMatched);

        break;

    case EIncomplete:

    default:

        __ASSERT_DEBUG(EFalse, User::Panic(_L("CBNFPARSE"), 1));

        // Oh dear an incomplete node in the rule tree. FAIL NOW!!!

        performedMatch = ETrue;

        aMatched = CFragmentedString::ENoMatch;

        break;

        }

    return performedMatch;

    }

EXPORT_C TBool CBNFParser::ParseL()

// Performs the actual parsing.

// Consumes as much of the input data as it can using the iTree BNF tree.

// Whilst parsing the appropriate callbacks are invoked on the parsed rules allowing actions to be performed.

// Should the input data be fully consumed and the parser has not been notified that there is no more input data

// this method returns leaving the parser in a state waiting for more input.

	{

	iParsing = EActive;

	while ((State() == EActive) && (!iRuleStack.IsEmpty()))

		{

		// find next rule

		CBNFNode *currentRule = iRuleStack.Head();

		// are we going up or down the tree?

 		if (iSubRule == NULL)

            ExecutePreRuleCallbackL(*currentRule);

        if (PerformRuleL(*currentRule, iMatched))

			{

			switch (iMatched)