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

// XPath configuraion functions

//

#include "xmlengdomdefs.h"

#include <xml/dom/xmlengxpathconfiguration.h>

#include "xmlengxpathevaluationcontext_impl.h"

#include "libxml2_globals_private.h"

#include <xml/dom/xmlengxpatherrors.h>

#include <xml/utils/xmlengmem.h>

#include <xml/utils/xmlengxestrings.h>

const TInt KHashTableSize = 32;

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

// Common callback for all extension functions

//

// Prototyped by:

// typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);

//

// Non-natively implemented XPath extension function cannot be registered in libxml2 XPath module 

// directly without using libxml2 XPath API.Thus, native  implementation is impossible

// when libxml2's APIs are hidden.

//

// That is why this callback is used: it is a front-end for function calls.

// Function pointers are registered in a separate storage (xmlXPathIntermediaryExtensionFunctionsHash)

// and are dynamically discovered during function call by function name and namespace uri.

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

//

void XmlEngineXpathCommonExtensionCallback(xmlXPathParserContextPtr ctxt, int nargs)

    {

    // Select function to call

    const xmlChar* KFunc = ctxt->context->function;

    const xmlChar* KFuncNs = ctxt->context->functionURI;

    void* funcPtr = xmlHashLookup2(

                        xmlXPathIntermediaryExtensionFunctionsHash,

                        KFunc,

                        KFuncNs);

    if (!funcPtr)

        {

        XP_ERROR(XPATH_UNKNOWN_FUNC_ERROR);

        }

    MXmlEngXPathExtensionFunction* extFunc = reinterpret_cast<MXmlEngXPathExtensionFunction*>(funcPtr);

    // Check arity

    TInt maxArity = extFunc->MaxArity();

    if (nargs < ((TInt)extFunc->MinArity()) || 

        (maxArity >= 0  && nargs > maxArity))

        {

        XP_ERROR(XPATH_INVALID_ARITY);

        }

    // Wrap arguments

    TXmlEngXPathEvaluationContextImpl context(ctxt, nargs); 

    if (!context.Initialize())

        {

        SET_OOM_FLAG;

        XP_ERROR(XPATH_MEMORY_ERROR);

        }

    // Call function

    MXmlEngXPathExtensionFunction::TXmlEngEvaluationStatus status = extFunc->Evaluate(&context);

        RXmlEngXPathResult res = context.Result();

        if (status != MXmlEngXPathExtensionFunction::ESucceeded)

            {

	        xmlXPathFreeObject(INTERNAL_XPATHOBJPTR(res));

            XP_ERROR(XPATH_XE_EXTENSION_FUNC_ERROR);

            }

        // Remove arguments from the evaluation stack

        for (TInt i = 0; i < nargs; i++)

            {

            xmlXPathFreeObject(valuePop(ctxt));

            }

        // Push the result to the stack

        valuePush(ctxt, INTERNAL_XPATHOBJPTR(res)); // Note: no need to check OOM flag -- later...

    }

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

// Default constructor

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

//

EXPORT_C TXmlEngExtensionFunctionDescriptor::TXmlEngExtensionFunctionDescriptor()

	{

	iFunc = NULL;

    iName = NULL;

    iNamespaceUri = NULL;     

	iReserved = 0;

	}

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

// Switches On or Off support of XForms extensions by XML Engine:

//     - instance() function

//

// @param aEnable  ETrue/EFalse to Enable/Disable additional functions

//

// @note

//     Currently, XForms extensions are always ON and this method does nothing.

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

//

EXPORT_C void XmlEngXPathConfiguration::Unused_Func1(TBool /*aEnable*/)

    {

    }

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

// Disables support of any previously registered extension functions

// and switches to support of only XPath Function Library.

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

//

EXPORT_C void XmlEngXPathConfiguration::ResetExtensionFunctionsL()

    {

    // Set the hash tables free:   

    //      xmlXPathIntermediaryExtensionFunctionsHash  and

    //      xmlXPathDefaultFunctionsHash

    //

    xmlHashTablePtr& fExtHash = xmlXPathIntermediaryExtensionFunctionsHash;

    xmlHashFree(fExtHash, NULL);

    fExtHash = NULL;

    //

    xmlHashTablePtr& fHash = xmlXPathDefaultFunctionsHash;

    xmlHashFree(fHash, NULL);

    fHash = NULL;

    // Fill the hash table with standard functions

    //

    // This reinitializes hash tables of XPath functions

    xmlXPathContextPtr ctxt = xmlXPathNewContext(NULL);

    OOM_IF_NULL(ctxt);

    xmlXPathFreeContext(ctxt);

    }

EXPORT_C TBool XmlEngXPathConfiguration::IsFunctionSupportedL(

    const TDesC8& aFunc, 

    const TDesC8& aNsUri )

    {

    if(!xmlXPathDefaultFunctionsHash)

        {

        return FALSE;

        }

	// If the function hashes are not initialized -- we should do it!

    xmlChar* func = xmlCharFromDesC8L(aFunc);

    CleanupStack::PushL(func);

    xmlChar* ns = NULL;

    if(aNsUri.Length())

        ns =  xmlCharFromDesC8L(aNsUri);

    void* test = xmlHashLookup2(

                                xmlXPathDefaultFunctionsHash, 

                                func, 

                                ns);

    TBool res = (NULL != test);

    delete ns;

    CleanupStack::PopAndDestroy(func);

    return res;

    }

EXPORT_C void XmlEngXPathConfiguration::AddExtensionFunctionL(const TXmlEngExtensionFunctionDescriptor& aFuncDes )

    {

    xmlHashTablePtr fHash = xmlXPathIntermediaryExtensionFunctionsHash;

    // store new function to XPath Extensions storage

    if (!fHash)

        {

        xmlXPathIntermediaryExtensionFunctionsHash = fHash = xmlHashCreate(KHashTableSize);

        OOM_IF_NULL(fHash);

        }

    //     Note: it is not critical, since redefinitions of core XPath function won't be found

    TInt res = xmlHashUpdateEntry2(

                    fHash, 

                    (const xmlChar*)aFuncDes.iName, 

                    (const xmlChar*)aFuncDes.iNamespaceUri, 

                    aFuncDes.iFunc, 

                    NULL);

    if (res == -1)

        {

        TEST_OOM_FLAG;

		User::Leave(KXmlEngErrXPathResult);	

        }

    // Note: for now it is fixed that once defined, an extension is available in all

    //       evaluations of XPath in this thread.

    xmlXPathDefineExtensionFunctionsGlobally = 1;

    // register common callback in XPath engine with new function's name

    if (!xmlXPathDefaultFunctionsHash)

        {

        // It was not initialized yet

        // This is temporal solution to force initialization

        xmlXPathContextPtr tmpCtxt = xmlXPathNewContext(NULL);

        OOM_IF_NULL(tmpCtxt);

        xmlXPathFreeContext(tmpCtxt);

        }

    if ( !xmlXPathDefaultFunctionsHash )

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    res = xmlHashUpdateEntry2(

        xmlXPathDefaultFunctionsHash, 

        (const xmlChar*)aFuncDes.iName,

        (const xmlChar*)aFuncDes.iNamespaceUri,

        (void*)XmlEngineXpathCommonExtensionCallback,

        NULL);

    if (res == -1)

        {

        TEST_OOM_FLAG;

		User::Leave(KXmlEngErrXPathResult); 

        }

    // Now, XmlEngineXpathCommonExtensionCallback is called for registered function.

    // XmlEngineXpathCommonExtensionCallback performs lookup in 

    // xmlXPathIntermediaryExtensionFunctionsHash for a function pointer by function name

    // wraps XPath evaluation context (arguments) and calls Evaluate() method of

    // registered function

    }

EXPORT_C void XmlEngXPathConfiguration::AddExtensionFunctionVectorL (const RArray<TXmlEngExtensionFunctionDescriptor>& aFuncVector, TUint aSize)

    {

    for (TUint i = 0; i < aSize; i++)

        {

        AddExtensionFunctionL(aFuncVector[i]);

        }

    }

EXPORT_C void XmlEngXPathConfiguration::AddNativeExtensionFunctionL(const TXmlEngExtensionFunctionDescriptor& aNativeFuncDes )

    {

    if (!xmlXPathDefaultFunctionsHash)

        {

        // It was not initialized yet

        // This is temporal solution to force initialization

        xmlXPathContextPtr tmpCtxt = xmlXPathNewContext(NULL);

        OOM_IF_NULL(tmpCtxt);

        xmlXPathFreeContext(tmpCtxt);

        }

    if ( !xmlXPathDefaultFunctionsHash )

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    TInt res = xmlHashUpdateEntry2(

        xmlXPathDefaultFunctionsHash, 

        (const xmlChar*)aNativeFuncDes.iName,

        (const xmlChar*)aNativeFuncDes.iNamespaceUri,

        aNativeFuncDes.iFunc,

        NULL);

    if (res == -1)

        {

        TEST_OOM_FLAG;

		User::Leave(KXmlEngErrXPathResult); 

        }     

    }

EXPORT_C void XmlEngXPathConfiguration::AddNativeExtensionFunctionVectorL(const RArray<TXmlEngExtensionFunctionDescriptor>& aNativeFuncVector, TUint aSize)

    {

    for (TUint i = 0; i < aSize; i++)

        {

        AddNativeExtensionFunctionL(aNativeFuncVector[i]);

        }     

    }

EXPORT_C void XmlEngXPathConfiguration::RemoveExtensionFunction(const TXmlEngExtensionFunctionDescriptor& aFuncDes )

    {

    xmlHashRemoveEntry2(

        xmlXPathDefaultFunctionsHash, 

        (const xmlChar*)aFuncDes.iName,

        (const xmlChar*)aFuncDes.iNamespaceUri,

        NULL /* deallocator function */);

    }

EXPORT_C void XmlEngXPathConfiguration::RemoveExtensionFunctionVector(const RArray<TXmlEngExtensionFunctionDescriptor>& aFuncVector, TUint aSize )

    {

    for (TUint i = 0; i < aSize; i++)

        {

        RemoveExtensionFunction(aFuncVector[i]);

        }      

    }