/*

* Copyright (c) 2002 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:  CGI parser and generator

*

*/

// INCLUDE FILES

#include <escapeutils.h>

#include "nsmlcgiscriptparser.h"

#include "nsmlconstants.h" //PtrArrCleanupItem

// ============================ MEMBER FUNCTIONS ===============================

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

// TNSmlCGIScriptParser::TNSmlCGIScriptParser

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

//

EXPORT_C TNSmlCGIScriptParser::TNSmlCGIScriptParser()

    {

    //logical separator table initialization

    KNSmlCGIScriptLogSep[ENSmlCGIScriptLogicalOperatorAnd] = &KNSmlCGIScriptLogicalSeparatorAndStr;

    KNSmlCGIScriptLogSep[ENSmlCGIScriptLogicalOperatorOr] = &KNSmlCGIScriptLogicalSeparatorOrStr;

    //logical operator table initialization

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorEqualToCaseSensitive] = &KNSmlCGIScriptComparatorEqualToCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorEqualToCaseInSensitive] = &KNSmlCGIScriptComparatorEqualToCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorNotEqualToCaseSensitive] = &KNSmlCGIScriptComparatorNotEqualToCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorNotEqualToCaseInSensitive] = &KNSmlCGIScriptComparatorNotEqualToCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorGreaterThanCaseSensitive] = &KNSmlCGIScriptComparatorGreaterThanCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorGreaterThanCaseInSensitive] = &KNSmlCGIScriptComparatorGreaterThanCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorGreaterThanOrEqualToCaseSensitive] = &KNSmlCGIScriptComparatorGreaterThanOrEqualToCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorGreaterThanOrEqualToCaseInSensitive] = &KNSmlCGIScriptComparatorGreaterThanOrEqualToCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorLessThanCaseSensitive] = &KNSmlCGIScriptComparatorLessThanCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorLessThanCaseInSensitive] = &KNSmlCGIScriptComparatorLessThanCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorLessThanOrEqualCaseSensitive] = &KNSmlCGIScriptComparatorLessThanOrEqualCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorLessThanOrEqualCaseInSensitive] = &KNSmlCGIScriptComparatorLessThanOrEqualCaseInSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorContainsValueCaseSensitive] = &KNSmlCGIScriptComparatorContainsValueCaseSensitiveStr; 

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorContainsValueCaseInSensitive] = &KNSmlCGIScriptComparatorContainsValueCaseInSensitiveStr;

    KNSmlCGIScriptLogOps[ENSmlCGIScriptComparatorNull] = &KNSmlCGIScriptNullStr;

    //special usage table initialization

    KNSmlCGIScriptSpecialUsageStrings[0] = &KNSmlCGIScriptNullValue;

    KNSmlCGIScriptSpecialUsageStrings[1] = &KNSmlCGIScriptLuidValue;

    }

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

// TNSmlCGIScriptParser::ParseL

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

//

EXPORT_C void TNSmlCGIScriptParser::ParseL(

    CNSmlCGIScript& aSp, 

    const CArrayPtr<TNSmlDataTypesForCGIScriptNames>& aDatatypes) const

    {

    aSp.Clear();

    TNSmlCGIScriptParseStateInfo psInfo(aSp.CGIScript(), &aDatatypes);

    if (psInfo.iCGIScript == NULL)

        {

        return;

        }

    TNSmlCGIScriptParseData pd;

    //Main parse loop

    for ( psInfo.iCurrPos = 0; psInfo.iCurrPos < psInfo.iCGIScript->Length();

        psInfo.iCurrPos++ )

        {

        if ( IsParseSplitPoint(*psInfo.iCGIScript, psInfo.iCurrPos) )

            {

            for (psInfo.iState = psInfo.iNextState; ParseStateL(psInfo, pd); 

                 psInfo.iState = psInfo.iNextState )

                {

                }

            if ( pd.iParseDataReady )

                {

                AddScriptPartL( aSp, pd );

                pd.iParseDataReady = EFalse;

                }

            psInfo.iStartPos = psInfo.iCurrPos + 1;

            }

        }

    // parsing script's last value

    psInfo.iState = psInfo.iNextState;

    ParseStateL( psInfo, pd );

    if ( pd.iParseDataReady )

        {

        AddScriptPartL( aSp, pd );

        }

    else{

        User::Leave( ENSmlCGIParserErrorParsing );

        }

    aSp.SetLogicalOperator( pd.iSeparator );

    }

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

// TNSmlCGIScriptParser::GenerateL

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

//

EXPORT_C void TNSmlCGIScriptParser::GenerateL(CNSmlCGIScript& aSp) const

    {

    typedef CArrayPtrFlat<HBufC> CBufParts;

    CBufParts* bufParts = new (ELeave) CBufParts(aSp.Count());

    CleanupStack::PushL( PtrArrCleanupItem(HBufC, bufParts) );

    TInt i;

    //generates all script parts and appends them to array.

    for (i = 0;i < aSp.Count();i++)

        {

        const TNSmlCGIScriptPart* sp = aSp.Get(i);

        HBufC* bufTmp = GenerateScriptPartL(*sp);

        CleanupStack::PushL(bufTmp);

        bufParts->AppendL(bufTmp);

        CleanupStack::Pop(bufTmp);

        }

    //collects all parts to a single CGI script.

    SetCGIScriptL(aSp, *bufParts);

    CleanupStack::PopAndDestroy(bufParts);

    }

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

// TNSmlCGIScriptParser::IsParseSplitPoint

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

//

TBool TNSmlCGIScriptParser::IsParseSplitPoint(const TDesC& aCGIScript, TInt aStartFrom) const

    {

    if (aCGIScript[aStartFrom] == '&')

        {

        for (TInt i(0); i < KNSmlCGIScriptSpecialUsageStringsCount; i++)

            {

            if (Compare(*KNSmlCGIScriptSpecialUsageStrings[i], aCGIScript, aStartFrom))

                {

                return EFalse;

                }

            }

        return ETrue;

        }

    return EFalse;

    }

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

// TNSmlCGIScriptParser::ParseStateL

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

//

TBool TNSmlCGIScriptParser::ParseStateL(

    TNSmlCGIScriptParseStateInfo & aPSInfo, 

    TNSmlCGIScriptParseData & aPD) const

    {

    TBool retV(ETrue);

    switch (aPSInfo.iState)

        {

        case ENSmlCGIScriptParseStateKeyWord:

            aPD.iKeyword.Set(aPSInfo.iCGIScript->Mid(aPSInfo.iStartPos, 

                aPSInfo.iCurrPos - aPSInfo.iStartPos));

            aPD.iDataType = FindDataTypeL(*aPSInfo.iDatatypes, aPD.iKeyword);

            if (aPD.iDataType == ENSmlCGIScriptDataTypeNoValue)

                {

                aPSInfo.iNextState = ENSmlCGIScriptParseStateLogSep;

                aPD.iValue.Set(TPtrC());

                aPD.iComparator = ENSmlCGIScriptComparatorNull;

                aPD.iParseDataReady = ETrue;

                }

            else

                {

                aPSInfo.iNextState = ENSmlCGIScriptParseStateLogOp;

                }

            break;

        case ENSmlCGIScriptParseStateLogOp:

            aPD.iComparator = LogOpL(*aPSInfo.iCGIScript,

                aPSInfo.iCurrPos + 1);

            aPSInfo.iCurrPos += LogOpL(aPD.iComparator).Length() - 1;

            aPSInfo.iNextState = ENSmlCGIScriptParseStateValue;

            retV = EFalse;

            break;

        case ENSmlCGIScriptParseStateValue:

            {

            aPD.iValue.Set(aPSInfo.iCGIScript->Mid(aPSInfo.iStartPos, 

                aPSInfo.iCurrPos - aPSInfo.iStartPos));

            aPSInfo.iNextState = ENSmlCGIScriptParseStateLogSep;

            aPD.iParseDataReady = ETrue;

            break;

            }

        case ENSmlCGIScriptParseStateLogSep:

            {

            TNSmlCGIScriptLogicalOperator loTmp(

                LogSepL(*aPSInfo.iCGIScript, aPSInfo.iCurrPos + 1) );

            if ( aPD.iSeparator != ENSmlCGIScriptLogicalOperatorNull && 

                (loTmp != aPD.iSeparator) )

                {

                //Error: query may contain only 1 type of logical separator

                User::Leave(ENSmlCGIParserErrorWrongSeparator);

                }

            aPD.iSeparator = loTmp;

            aPSInfo.iCurrPos += LogSepL( aPD.iSeparator ).Length() - 1;

            aPSInfo.iNextState = ENSmlCGIScriptParseStateKeyWord;

            retV = EFalse;

            }

            break;

        default:

            User::Leave(ENSmlCGIParserErrorParsing);

            break;

        }

    return retV;

    }

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

// TNSmlCGIScriptParser::AddScriptPartL

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

//

TBool TNSmlCGIScriptParser::AddScriptPartL(CNSmlCGIScript& aSp, 

    TNSmlCGIScriptParseData& aPD)

    {

    TNSmlCGIScriptDataType datatype(aPD.iDataType);

    TNSmlCGIScriptPart* sp = new (ELeave) TNSmlCGIScriptPart;

    CleanupStack::PushL(sp);

    sp->iData = NULL;

    sp->iName = HBufC::NewLC(aPD.iKeyword.Length());

    *(sp->iName) = aPD.iKeyword;

    sp->iComparator = aPD.iComparator;

    sp->iDataType = datatype;

    TBool retV = ParseScriptPartDataLC(*sp, aPD.iValue);

    CheckScriptPartValidityL(*sp);

    if (retV)

        {

        aSp.AddL(sp);

        CleanupStack::Pop(3); //ParseScriptPartDataLC:stä, sp->iName,sp;

        }

    else

        {

        CleanupStack::PopAndDestroy(2); //sp->iName, sp

        sp->iName = NULL;

        sp = NULL;

        }

    return retV;

    }

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

// TNSmlCGIScriptParser::ParseScriptPartDataLC

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

//

TBool TNSmlCGIScriptParser::ParseScriptPartDataLC(

    TNSmlCGIScriptPart& aSp, 

    const TPtrC& aValue)

    {

    TNSmlCGIScriptDataType datatype( (aValue == KNSmlCGIScriptNullValue) 

        ? ENSmlCGIScriptDataTypeNull : aSp.iDataType );

    TBool retV(ETrue);

    // in each case - sentence, either push something to cleanupstack, 

    // set retV to EFalse or leave

    switch (datatype)

        {

        case ENSmlCGIScriptDataTypeHBufC:

            {

            aSp.iData = EscapeUtils::EscapeDecodeL(aValue);

            CleanupStack::PushL(aSp.iData);

            }

            break;

        case ENSmlCGIScriptDataTypeDateTime:

        case ENSmlCGIScriptDataTypeDate:

            {

            TDateTime* dt = new (ELeave) TDateTime();

            CleanupStack::PushL(dt);

            TInt num = ParseDateTimeL(*dt, aValue);

            switch(num)

                {

                case KNSmlCGIParserDateTimeLen:

                    aSp.iDataType = ENSmlCGIScriptDataTypeDateTime;

                    break;

                case KNSmlCGIParserDateLen:

                    aSp.iDataType = ENSmlCGIScriptDataTypeDate;

                    break;

                default:

                    User::Leave(ENSmlCGIParserErrorConversion);

                    break;

                }

            aSp.iData = dt;

            }

            break;

        case ENSmlCGIScriptDataTypeNumber:

            {

            TInt* num = new (ELeave) TInt();

            CleanupStack::PushL(num);

            *num = ParseIntL(aValue, 0, aValue.Length());

            aSp.iData = num;

            }

            break;

        case ENSmlCGIScriptDataTypeBoolean:

            {

            TBool* bln = new (ELeave) TBool;

            CleanupStack::PushL(bln);

            *bln = ParseBoolL(aValue);

            aSp.iData = bln;

            }

            break;

        case ENSmlCGIScriptDataTypeNoValue:

        case ENSmlCGIScriptDataTypeNull:

            aSp.iData = NULL;

            CleanupStack::PushL(aSp.iData);

            break;

        default: // TNSmlCGIScriptDataTypeUnKnown

            User::Leave(ENSmlCGIParserErrorConversion);

            break;

        }

    return retV;

    }

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

// TNSmlCGIScriptParser::FindDataTypeL

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

//

TNSmlCGIScriptDataType TNSmlCGIScriptParser::FindDataTypeL(

    const CArrayPtr<TNSmlDataTypesForCGIScriptNames>& aDatatypes, 

    const TPtrC& aKeyword)

    {

    TNSmlCGIScriptDataType dt(FindDataType(aDatatypes, aKeyword));

    if (dt == ENSmlCGIScriptDataTypeUnKnown)

        {

        User::Leave(ENSmlCGIParserErrorDataTypeNotFound);

        }

    return dt;

    }

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

// TNSmlCGIScriptParser::FindDataType

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

//

TNSmlCGIScriptDataType TNSmlCGIScriptParser::FindDataType(

    const CArrayPtr<TNSmlDataTypesForCGIScriptNames>& aDatatypes, 

    const TPtrC& aKeyword)

    {

    TNSmlDataTypesForCGIScriptNames* tmp;

    for (TInt i = 0; i < aDatatypes.Count(); i++)

        {

        tmp = aDatatypes[i];

        if (*tmp->iKeywordOrProperty == aKeyword)

            {

            return tmp->iDataType;

            }

        }

    return ENSmlCGIScriptDataTypeUnKnown;

    }

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

// TNSmlCGIScriptParser::GenerateScriptPartL

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

//

HBufC* TNSmlCGIScriptParser::GenerateScriptPartL(

    const TNSmlCGIScriptPart& aSp) const

    {

    CheckScriptPartValidityL(aSp);

    TInt len(LogOpL(aSp.iComparator).Length() + aSp.iName->Length());

    TAny* value = NULL;

    TBool destroyValue(EFalse);

    TNSmlCGIScriptDataType dataType(aSp.iDataType);

    if (aSp.iData == NULL && dataType != ENSmlCGIScriptDataTypeNoValue)

        {

        dataType = ENSmlCGIScriptDataTypeNull;

        }

    if (dataType == ENSmlCGIScriptDataTypeHBufC)

        {

        HBufC* buf = EscapeUtils::EscapeEncodeL( 

            *reinterpret_cast<HBufC*>(aSp.iData), KNSmlCGIParserReservedChars );

        CleanupStack::PushL(buf);

        len += buf->Length();

        destroyValue = ETrue;

        value = buf;

        }

    else

        {

        len += 32;              //enough for datetime, number, boolean etc.

        value = reinterpret_cast<TAny*>(aSp.iData);

        }

    HBufC* bufTmp = HBufC::NewLC(len);

    TPtr ptr(bufTmp->Des());

    ptr.Append(*aSp.iName);

    ptr.Append( LogOpL(aSp.iComparator) );

    GenerateScriptPartValueL(dataType, value, ptr);

    CleanupStack::Pop(bufTmp);

    if (destroyValue)

        {

        CleanupStack::PopAndDestroy(value);

        }

    return bufTmp;

    }

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

// TNSmlCGIScriptParser::GenerateScriptPartValueL

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

//

void TNSmlCGIScriptParser::GenerateScriptPartValueL(

    TNSmlCGIScriptDataType aDataType, 

    const TAny *aValue,

    TPtr & aPtr)

    {

    switch (aDataType)

        {

        case ENSmlCGIScriptDataTypeHBufC:

            {

            aPtr.Append( *reinterpret_cast<const HBufC*>(aValue) );

            break;

            }

        case ENSmlCGIScriptDataTypeDate:

            {

            const TDateTime* dt = reinterpret_cast<const TDateTime*>(aValue);

            TBuf<KNSmlCGIParserDateLen> des;

            GenerateDateTimeValue(*dt, des, EFalse);

            aPtr.Append(des);

            }

            break;

        case ENSmlCGIScriptDataTypeDateTime:

            {

            const TDateTime* dt = reinterpret_cast<const TDateTime*>(aValue);

            TBuf<KNSmlCGIParserDateTimeLen> des;

            GenerateDateTimeValue(*dt, des, ETrue);

            aPtr.Append(des);

            }

            break;

        case ENSmlCGIScriptDataTypeNumber:

            {

            TBuf<32> des;

            const TInt* num = reinterpret_cast<const TInt*>(aValue);

            des.Num(*num);

            aPtr.Append(des);

            }

            break;

        case ENSmlCGIScriptDataTypeBoolean:

            {

            const TBool* bln = reinterpret_cast<const TBool*>(aValue);

            aPtr.Append(GenerateBoolValue(*bln));

            }

            break;

        case ENSmlCGIScriptDataTypeNull:

            aPtr.Append(KNSmlCGIScriptNullValue);

            break;

        case ENSmlCGIScriptDataTypeNoValue:

            //empty

            break;

        default: //TNSmlCGIScriptDataTypeUnKnown

            User::Leave(ENSmlCGIParserErrorConversion);

            break;

        }

    }

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

// TNSmlCGIScriptParser::SetCGIScriptL

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

//

void TNSmlCGIScriptParser::SetCGIScriptL(

    CNSmlCGIScript& aSp, 

    CArrayPtr<HBufC>& aBufParts ) const

    {

    TInt bufPartsCount(aBufParts.Count());

    TInt i(0);

    TInt scriptLen(0);

    if (bufPartsCount > 0)

        {

        //length of entire script

        for (i = 0; i < bufPartsCount; i++)

            {

            scriptLen += aBufParts.At(i)->Length();

            }

        //adds length of separator between two scriptparts

        if (bufPartsCount > 1)

            {

            scriptLen += (bufPartsCount - 1) * 

                LogSepL(aSp.LogicalOperator()).Length();

            }

        //reserves needed memory

        HBufC* bufTmp = HBufC::NewLC(scriptLen);

        TPtr ptr(bufTmp->Des());

        //appends all parts to a full script.

        for (i = 0; i < bufPartsCount;i++)