You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xalan.apache.org by db...@apache.org on 2001/09/27 23:09:30 UTC
cvs commit: xml-xalan/c/src/XPathCAPI XPathCAPI.cpp XPathCAPI.h
dbertoni 01/09/27 14:09:30
Added: c/src/XPathCAPI XPathCAPI.cpp XPathCAPI.h
Log:
Initial revision.
Revision Changes Path
1.1 xml-xalan/c/src/XPathCAPI/XPathCAPI.cpp
Index: XPathCAPI.cpp
===================================================================
/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
#include "XPathCAPI.h"
#include <util/PlatformUtils.hpp>
#include <framework/MemBufInputSource.hpp>
#include <Include/XalanAutoPtr.hpp>
#include <PlatformSupport/XalanTranscodingServices.hpp>
#include <XPath/XObjectFactory.hpp>
#include <XPath/XPathEvaluator.hpp>
#include <XPath/XPathExecutionContextDefault.hpp>
#include <XPath/XPathFactoryDefault.hpp>
#include <XalanSourceTree/XalanSourceTreeInit.hpp>
#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
class SAXException;
static bool fInitialized = false;
static bool fTerminated = false;
static XalanSourceTreeInit* theSourceTreeInit = 0;
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanXPathAPIInitialize()
{
if (fInitialized == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_CANNOT_REINITIALIZE;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
XMLPlatformUtils::Initialize();
try
{
XPathEvaluator::initialize();
try
{
theSourceTreeInit = new XalanSourceTreeInit;
}
catch(...)
{
XPathEvaluator::terminate();
throw;
}
}
catch(...)
{
XMLPlatformUtils::Terminate();
throw;
}
fInitialized = true;
}
catch(...)
{
fTerminated = true;
theResult = XALAN_XPATH_API_ERROR_INITIALIZATION_FAILED;
}
return theResult;
}
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanXPathAPITerminate()
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
delete theSourceTreeInit;
theSourceTreeInit = 0;
XPathEvaluator::terminate();
XMLPlatformUtils::Terminate();
fTerminated = true;
}
catch(...)
{
theResult = XALAN_XPATH_API_ERROR_TERMINATION_FAILED;
}
return theResult;
}
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanCreateXPathEvaluator(XalanXPathEvaluatorHandle* theHandle)
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else if (theHandle == 0)
{
return XALAN_XPATH_API_ERROR_INVALID_PARAMETER;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
*theHandle = new XPathEvaluator;
}
catch(...)
{
theResult = XALAN_XPATH_API_ERROR_UNKNOWN;
}
return theResult;
}
}
inline XPathEvaluator*
getEvaluator(XalanXPathEvaluatorHandle theHandle)
{
assert(theHandle != 0);
#if defined(XALAN_OLD_STYLE_CASTS)
return (XPathEvaluator*)theHandle;
#else
return static_cast<XPathEvaluator*>(theHandle);
#endif
}
inline XPath*
getXPath(XalanXPathHandle theHandle)
{
assert(theHandle != 0);
#if defined(XALAN_OLD_STYLE_CASTS)
return (XPath*)theHandle;
#else
return static_cast<XPath*>(theHandle);
#endif
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanDestroyXPathEvaluator(XalanXPathEvaluatorHandle theXalanHandle)
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else if (theXalanHandle == 0)
{
return XALAN_XPATH_API_ERROR_INVALID_PARAMETER;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
delete getEvaluator(theXalanHandle);
}
catch(...)
{
theResult = XALAN_XPATH_API_ERROR_UNKNOWN;
}
return theResult;
}
}
inline int
transcodeString(
XalanOutputTranscoder* theTranscoder,
const char* theString,
XalanDOMChar* theChars,
unsigned char* theCharsCount,
size_t theLength,
XalanDOMString& theResultString)
{
assert(theTranscoder != 0);
assert(theString != 0);
assert(theChars != 0);
assert(theCharsCount != 0);
unsigned int theSourceCharsTranscoded = 0;
unsigned int theTargetBytesUsed = 0;
const XalanTranscodingServices::eCode theCode = theTranscoder->transcode(
#if defined(XALAN_OLD_STYLE_CASTS)
(const XalanOutputTranscoder::XalanXMLByte*)theString,
#else
reinterpret_cast<const XalanOutputTranscoder::XalanXMLByte*>(theString),
#endif
theLength,
theChars,
theLength,
theSourceCharsTranscoded,
theTargetBytesUsed,
theCharsCount);
if (theCode != XalanTranscodingServices::OK)
{
return XALAN_XPATH_API_ERROR_TRANSCODING;
}
else
{
assign(theResultString, theChars, theTargetBytesUsed);
return XALAN_XPATH_API_SUCCESS;
}
}
inline int
transcodeString(
const char* theString,
const char* theStringEncoding,
XalanDOMString& theResultString)
{
assert(theString != 0);
int theResult = XALAN_XPATH_API_SUCCESS;
if (theStringEncoding == 0 || strlen(theStringEncoding) == 0)
{
theResultString = theString;
}
else
{
XalanTranscodingServices::eCode theCode = XalanTranscodingServices::OK;
XalanOutputTranscoder* const theTranscoder =
XalanTranscodingServices::makeNewTranscoder(
XalanDOMString(theStringEncoding),
theCode,
1024);
if (theCode == XalanTranscodingServices::UnsupportedEncoding)
{
theResult = XALAN_XPATH_API_ERROR_UNSUPPORTED_ENCODING;
}
else if (theCode != XalanTranscodingServices::OK)
{
theResult = XALAN_XPATH_API_ERROR_UNKNOWN;
}
else
{
assert(theTranscoder != 0);
// Since UTF-16 can represent any Unicode value in
// one 16-bit value, we'll use the length of the
// string as the maximum length of the resulting
// transcoded string. This doesn't account for
// surrogate pairs, but those are for private use
// only right now, so we don't really need to
// worry about them.
const size_t theLength = strlen(theString);
// Only use a dynamically-allocated array for very long
// XPath expressions.
const size_t maxStackArraySize = 100;
if (theLength >= maxStackArraySize)
{
XalanArrayAutoPtr<unsigned char> theCharsCount(new unsigned char[theLength + 1]);
XalanArrayAutoPtr<XalanDOMChar> theChars(new XalanDOMChar[theLength + 1]);
theResult = transcodeString(
theTranscoder,
theString,
theChars.get(),
theCharsCount.get(),
theLength,
theResultString);
}
else
{
unsigned char theCharsCount[maxStackArraySize];
XalanDOMChar theChars[maxStackArraySize];
theResult = transcodeString(
theTranscoder,
theString,
theChars,
theCharsCount,
theLength,
theResultString);
}
XalanTranscodingServices::destroyTranscoder(theTranscoder);
}
}
return theResult;
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanCreateXPath(
XalanXPathEvaluatorHandle theXalanHandle,
const char* theXPathExpression,
const char* theXPathExpressionEncoding,
XalanXPathHandle* theXPathHandle)
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else if (theXalanHandle == 0 || theXPathHandle == 0 || theXPathExpression == 0 || strlen(theXPathExpression) == 0)
{
return XALAN_XPATH_API_ERROR_INVALID_PARAMETER;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
XPathEvaluator* const theEvaluator = getEvaluator(theXalanHandle);
assert(theEvaluator != 0);
XalanDOMString theExpressionString;
theResult = transcodeString(
theXPathExpression,
theXPathExpressionEncoding,
theExpressionString);
if (theResult == XALAN_XPATH_API_SUCCESS)
{
const XalanDOMChar* const thePointer = theExpressionString.c_str();
if (length(thePointer) == 0)
{
theResult = XALAN_XPATH_API_ERROR_TRANSCODING;
}
else
{
*theXPathHandle = theEvaluator->createXPath(thePointer);
}
}
}
catch(...)
{
theResult = XALAN_XPATH_API_ERROR_INVALID_XPATH;
}
return theResult;
}
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanDestroyXPath(
XalanXPathEvaluatorHandle theXalanHandle,
XalanXPathHandle theXPathHandle)
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else if (theXalanHandle == 0 || theXPathHandle == 0)
{
return XALAN_XPATH_API_ERROR_INVALID_PARAMETER;
}
else
{
int theResult = XALAN_XPATH_API_SUCCESS;
try
{
XPathEvaluator* const theEvaluator = getEvaluator(theXalanHandle);
assert(theEvaluator != 0);
if (theEvaluator->destroyXPath(getXPath(theXPathHandle)) == false)
{
theResult = XALAN_XPATH_API_ERROR_INVALID_XPATH;
}
}
catch(...)
{
theResult = XALAN_XPATH_API_ERROR_UNKNOWN;
}
return theResult;
}
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanEvaluateXPathAsBoolean(
XalanXPathEvaluatorHandle theXalanHandle,
XalanXPathHandle theXPathHandle,
const char* theXML,
int* theResult)
{
if (fInitialized == false)
{
return XALAN_XPATH_API_ERROR_NOT_INITIALIZED;
}
else if (fTerminated == true)
{
return XALAN_XPATH_API_ERROR_ALREADY_TERMINATED;
}
else if (theXalanHandle == 0 || theXPathHandle == 0 || theXML == 0)
{
return XALAN_XPATH_API_ERROR_INVALID_PARAMETER;
}
else
{
int theError = XALAN_XPATH_API_SUCCESS;
try
{
XPathEvaluator* const theEvaluator = getEvaluator(theXalanHandle);
assert(theEvaluator != 0);
XPath* const theXPath = getXPath(theXPathHandle);
assert(theXPath != 0);
XalanSourceTreeDOMSupport theDOMSupport;
XalanSourceTreeParserLiaison theLiaison(theDOMSupport);
// Hook the two together...
theDOMSupport.setParserLiaison(&theLiaison);
// Create an input source...
const MemBufInputSource theInputSource(
#if defined(XALAN_OLD_STYLE_CASTS)
(const XMLByte*)theXML,
#else
reinterpret_cast<const XMLByte*>(theXML),
#endif
strlen(theXML),
"SourceXML",
false);
// Parse the document...
XalanDocument* const theDocument =
theLiaison.parseXMLStream(theInputSource);
assert(theDocument != 0);
if (theEvaluator->evaluate(theDOMSupport, theDocument, *theXPath)->boolean() == true)
{
*theResult = 1;
}
else
{
*theResult = 0;
}
}
catch(const SAXException&)
{
theError = XALAN_XPATH_API_ERROR_BAD_XML;
}
catch(...)
{
theError = XALAN_XPATH_API_ERROR_UNKNOWN;
}
return theError;
}
}
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanEvaluateXPathExpressionAsBoolean(
XalanXPathEvaluatorHandle theXalanHandle,
const char* theXPathExpression,
const char* theXPathExpressionEncoding,
const char* theXML,
int* theResult)
{
XalanXPathHandle theXPathHandle = 0;
int theError = XalanCreateXPath(
theXalanHandle,
theXPathExpression,
theXPathExpressionEncoding,
&theXPathHandle);
if (theError == XALAN_XPATH_API_SUCCESS)
{
assert(theXPathHandle != 0);
theError = XalanEvaluateXPathAsBoolean(theXalanHandle, theXPathHandle, theXML, theResult);
const int theDestroyResult =
XalanDestroyXPath(theXalanHandle, theXPathHandle);
if (theDestroyResult != XALAN_XPATH_API_SUCCESS)
{
theError = theDestroyResult;
}
}
return theError;
}
1.1 xml-xalan/c/src/XPathCAPI/XPathCAPI.h
Index: XPathCAPI.h
===================================================================
/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
#if !defined(XALAN_XPATHCAPI_HEADER_GUARD_1357924680)
#define XALAN_XPATHCAPI_HEADER_GUARD_1357924680
#if defined(_MSC_VER)
#if defined(XALAN_XPATHCAPI_BUILD_DLL)
#define XALAN_XPATHCAPI_EXPORT __declspec(dllexport)
#define XALAN_XPATHCAPI_EXPORT_FUNCTION(T) T __declspec(dllexport)
#else
#define XALAN_XPATHCAPI_EXPORT __declspec(dllimport)
#define XALAN_XPATHCAPI_EXPORT_FUNCTION(T) T __declspec(dllimport)
#endif
#else
#define XALAN_XPATHCAPI_EXPORT
#define XALAN_XPATHCAPI_EXPORT_FUNCTION(T) T
#endif
/**
* This is a simple C interface for the class XPathEvaluator. It's
* the user's responsibility to call XalanXPathAPIInitialize() before making
* any other API calls, and to call XalanXPathAPITerminate() when finished
* with the API.
*/
#if defined(__cplusplus)
extern "C"
{
#endif
#define XALAN_XPATH_API_SUCCESS 0
#define XALAN_XPATH_API_ERROR_ALREADY_INITIALIZED 1
#define XALAN_XPATH_API_ERROR_ALREADY_TERMINATED 2
#define XALAN_XPATH_API_ERROR_INITIALIZATION_FAILED 3
#define XALAN_XPATH_API_ERROR_TERMINATION_FAILED 4
#define XALAN_XPATH_API_ERROR_NOT_INITIALIZED 5
#define XALAN_XPATH_API_ERROR_CANNOT_REINITIALIZE 6
#define XALAN_XPATH_API_ERROR_INVALID_PARAMETER 7
#define XALAN_XPATH_API_ERROR_INVALID_EXPRESSION 8
#define XALAN_XPATH_API_ERROR_BAD_XML 9
#define XALAN_XPATH_API_ERROR_UNSUPPORTED_ENCODING 10
#define XALAN_XPATH_API_ERROR_TRANSCODING 11
#define XALAN_XPATH_API_ERROR_INVALID_XPATH 12
#define XALAN_XPATH_API_ERROR_UNKNOWN 13
/**
* Handle used to store the address of XalanTransformer instance.
*/
typedef void* XalanXPathEvaluatorHandle;
/**
* Handle used to store the address of compiled XPath instance.
*/
typedef void* XalanXPathHandle;
/**
* Initialize Xerces and the XPath API.
*
* Should be called only once per process before making
* any other API calls.
*
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanXPathAPIInitialize();
/**
* Terminate Xerces and the XPath API.
*
* Should be called only once per process after deleting all
* instances of XalanXPathEvaluator. Once a process has called
* this function, it cannot use the API for the remaining
* lifetime of the process.
*
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanXPathAPITerminate();
/**
* Create a XalanXPathEvaluator instance.
*
* @param theXalanHandle A pointer to the handle for the new instance.
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanCreateXPathEvaluator(XalanXPathEvaluatorHandle* theHandle);
/**
* Destroy a XalanXPathEvaluator instance.
*
* @param theXalanHandle The handle of the instance to destroy.
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanDestroyXPathEvaluator(XalanXPathEvaluatorHandle theXalanHandle);
/**
* Creates a compiled XPath instance.
*
* @param theXalanHandle The handle of XalanXPathEvaluatorHandle instance.
* @param theXPathExpression The expression to compile
* @param theXPathExpressionEncoding The encoding of the expression. If NULL or an empty string, the local code page is assumed.
* @param theXPathHandle A pointer to the handle for the new instance
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanCreateXPath(
XalanXPathEvaluatorHandle theXalanHandle,
const char* theXPathExpression,
const char* theXPathExpressionEncoding,
XalanXPathHandle* theXPathHandle);
/**
* Destroys a compiled XPath instance.
*
* @param theXalanHandle The handle of XalanXPathEvaluatorHandle instance.
* @param theXPathHandle The handle of XPath instance
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanDestroyXPath(
XalanXPathEvaluatorHandle theXalanHandle,
XalanXPathHandle theXPathHandle);
/**
* Evaluates a compiled XPath instance.
*
* @param theXalanHandle The handle of XalanXPathEvaluatorHandle instance.
* @param theXPathHandle The pointer to handle for instance
* @param theXML The XML document to use for evaluating the XPath expression
* @param theResult A pointer to an int to receive the result.
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanEvaluateXPathAsBoolean(
XalanXPathEvaluatorHandle theXalanHandle,
XalanXPathHandle theXPathHandle,
const char* theXML,
int* theResult);
/**
* Evaluates an XPath expression
*
* @param theXalanHandle The handle of XalanXPathEvaluatorHandle instance.
* @param theXPathExpression The expression to evaluate
* @param theXPathExpressionEncoding The encoding of the expression. If NULL or an empty string, the local code page is assumed.
* @param theXML The XML document to use for evaluating the XPath expression
* @param theResult A pointer to an int to receive the result.
* @return 0 for success, or a non-zero error code upon failure
*/
XALAN_XPATHCAPI_EXPORT_FUNCTION(int)
XalanEvaluateXPathExpressionAsBoolean(
XalanXPathEvaluatorHandle theXalanHandle,
const char* theXPathExpression,
const char* theXPathExpressionEncoding,
const char* theXML,
int* theResult);
#if defined(__cplusplus)
}
#endif
#endif // XALAN_XPATHCAPI_HEADER_GUARD_1357924680
---------------------------------------------------------------------
To unsubscribe, e-mail: xalan-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xalan-cvs-help@xml.apache.org