main/xmlsecurity/source/xmlsec/saxhelper.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_xmlsecurity.hxx"

 #include <rtl/ustring.hxx>

 #include "saxhelper.hxx"
 #include "libxml/parserInternals.h"

 #ifndef XMLSEC_NO_XSLT
 #include "libxslt/xslt.h"
 #endif

 namespace cssu = com::sun::star::uno;
 namespace cssxs = com::sun::star::xml::sax;
 namespace cssxcsax = com::sun::star::xml::csax;

 /**
  * The return value is NULL terminated. The application has the responsibilty to
  * deallocte the return value.
  */
 xmlChar* ous_to_xmlstr( const rtl::OUString& oustr )
 {
 	rtl::OString ostr = rtl::OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
 	return xmlStrndup( ( xmlChar* )ostr.getStr(), ( int )ostr.getLength() ) ;
 }

 /**
  * The return value is NULL terminated. The application has the responsibilty to
  * deallocte the return value.
  */
 xmlChar* ous_to_nxmlstr( const rtl::OUString& oustr, int& length )
 {
 	rtl::OString ostr = rtl::OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
 	length = ostr.getLength();

 	return xmlStrndup( ( xmlChar* )ostr.getStr(), length ) ;
 }

 /**
  * The input parameter isn't necessaryly NULL terminated.
  */
 rtl::OUString xmlchar_to_ous( const xmlChar* pChar, int length )
 {
 	if( pChar != NULL )
 	{
 		return rtl::OUString( ( sal_Char* )pChar , length , RTL_TEXTENCODING_UTF8 ) ;
 	}
 	else
 	{
 		return rtl::OUString() ;
 	}
 }

 /**
  * The input parameter is NULL terminated
  */
 rtl::OUString xmlstr_to_ous( const xmlChar* pStr )
 {
 	if( pStr != NULL )
 	{
 		return xmlchar_to_ous( pStr , xmlStrlen( pStr ) ) ;
 	}
 	else
 	{
 		return rtl::OUString() ;
 	}
 }

 /**
  * The return value and the referenced value must be NULL terminated.
  * The application has the responsibilty to deallocte the return value.
  */
 const xmlChar** attrlist_to_nxmlstr( const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
 {
 	xmlChar* attname = NULL ;
 	xmlChar* attvalue = NULL ;
 	const xmlChar** attrs = NULL ;
 	rtl::OUString oustr ;

 	sal_Int32 nLength = aAttributes.getLength();;

 	if( nLength != 0 )
 	{
 		attrs = ( const xmlChar** )xmlMalloc( ( nLength * 2 + 2 ) * sizeof( xmlChar* ) ) ;
 	}
 	else
 	{
 		return NULL ;
 	}

 	for( int i = 0 , j = 0 ; j < nLength ; ++j )
 	{
 		attname = ous_to_xmlstr( aAttributes[j].sName ) ;
 		attvalue = ous_to_xmlstr( aAttributes[j].sValue ) ;

 		if( attname != NULL && attvalue != NULL )
 		{
 			attrs[i++] = attname ;
 			attrs[i++] = attvalue ;
 			attrs[i] = NULL ;
 			attrs[i+1] = NULL ;
 		}
 		else
 		{
 			if( attname != NULL )
 				xmlFree( attname ) ;
 			if( attvalue != NULL )
 				xmlFree( attvalue ) ;
 		}
 	}

 	return attrs ;
 }

 /**
  * Constructor
  *
  * In this constructor, a libxml sax parser context is initialized. a libxml
  * default sax handler is initialized with the context.
  */
 SAXHelper::SAXHelper( )
 	: m_pParserCtxt( NULL ),
 	  m_pSaxHandler( NULL )
 {
 	xmlInitParser() ;
 	LIBXML_TEST_VERSION ;

 	/*
 	 * compile error:
 	 * xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS ;
 	 */
 	xmlSubstituteEntitiesDefault( 1 ) ;

 #ifndef XMLSEC_NO_XSLT
 	xmlIndentTreeOutput = 1 ;
 #endif /* XMLSEC_NO_XSLT */

 	m_pParserCtxt = xmlNewParserCtxt() ;

 	/*
 	 * i41748
 	 *
 	 * mmi : re-initialize the SAX handler to version 1
 	 */

 	xmlSAXVersion(m_pParserCtxt->sax, 1);

 	/* end */

 	if( m_pParserCtxt->inputTab[0] != NULL )
 	{
 		m_pParserCtxt->inputTab[0] = NULL ;
 	}

 	if( m_pParserCtxt == NULL )
 	{
 #ifndef XMLSEC_NO_XSLT
 		xsltCleanupGlobals() ;
 #endif
 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 //		in other parts of the office.
 //		xmlCleanupParser() ;
 		throw cssu::RuntimeException() ;
 	}
 	else if( m_pParserCtxt->sax == NULL )
 	{
 		xmlFreeParserCtxt( m_pParserCtxt ) ;

 #ifndef XMLSEC_NO_XSLT
 		xsltCleanupGlobals() ;
 #endif
 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 //		in other parts of the office.
 //		xmlCleanupParser() ;
 		m_pParserCtxt = NULL ;
 		throw cssu::RuntimeException() ;
 	}
 	else
 	{
 		m_pSaxHandler = m_pParserCtxt->sax ;

 		//Adjust the context
 		m_pParserCtxt->recovery = 1 ;
 	}
 }

 /**
  * Destructor
  *
  * In this destructor, a libxml sax parser context is desturcted. The XML tree
  * in the context is not deallocated because the tree is bind with a document
  * model by the setTargetDocument method, which delegate the target document to
  * destruct the xml tree.
  */
 SAXHelper::~SAXHelper() {
 	if( m_pParserCtxt != NULL )
 	{
 		/*
 		 * In the situation that no object refer the Document, this destructor
 		 * must deallocate the Document memory
 		 */
 		if( m_pSaxHandler == m_pParserCtxt->sax )
 		{
 			m_pSaxHandler = NULL ;
 		}

 		xmlFreeParserCtxt( m_pParserCtxt ) ;
 		m_pParserCtxt = NULL ;
 	}

 	if( m_pSaxHandler != NULL )
 	{
 		xmlFree( m_pSaxHandler ) ;
 		m_pSaxHandler = NULL ;
 	}
 //      see issue i74334, we cannot call xmlCleanupParser when libxml is still used
 //		in other parts of the office.
 //	xmlCleanupParser() ;
 }

 xmlNodePtr SAXHelper::getCurrentNode()
 {
 	return m_pParserCtxt->node;
 }

 void SAXHelper::setCurrentNode(const xmlNodePtr pNode)
 {
 	/*
 	 * This is really a black trick.
 	 * When the current node is replaced, the nodeTab
 	 * stack's top has to been replaced with the same
 	 * node, in order to make compatibility.
 	 */
 	m_pParserCtxt->nodeTab[m_pParserCtxt->nodeNr - 1]
 		= m_pParserCtxt->node
 			= pNode;
 }

 xmlDocPtr SAXHelper::getDocument()
 {
 	return m_pParserCtxt->myDoc;
 }

 /**
  * XDocumentHandler -- start an xml document
  */
 void SAXHelper::startDocument( void )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	/*
 	 * Adjust inputTab
 	 */
 	xmlParserInputPtr pInput = xmlNewInputStream( m_pParserCtxt ) ;

 	if( m_pParserCtxt->inputTab != NULL && m_pParserCtxt->inputMax != 0 )
 	{
 		m_pParserCtxt->inputTab[0] = pInput ;
 		m_pParserCtxt->input = pInput ;
 	}

 	m_pSaxHandler->startDocument( m_pParserCtxt ) ;

 	if( m_pParserCtxt == NULL || m_pParserCtxt->myDoc == NULL )
 	{
 		throw cssu::RuntimeException() ;
 	}
 }

 /**
  * XDocumentHandler -- end an xml document
  */
 void SAXHelper::endDocument( void )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	m_pSaxHandler->endDocument( m_pParserCtxt ) ;
 }

 /**
  * XDocumentHandler -- start an xml element
  */
 void SAXHelper::startElement(
 	const rtl::OUString& aName,
 	const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	const xmlChar* fullName = NULL ;
 	const xmlChar** attrs = NULL ;

 	fullName = ous_to_xmlstr( aName ) ;
 	attrs = attrlist_to_nxmlstr( aAttributes ) ;

 	if( fullName != NULL || attrs != NULL )
 	{
 		m_pSaxHandler->startElement( m_pParserCtxt , fullName , attrs ) ;
 	}

 	if( fullName != NULL )
 	{
 		xmlFree( ( xmlChar* )fullName ) ;
 		fullName = NULL ;
 	}

 	if( attrs != NULL )
 	{
 		for( int i = 0 ; attrs[i] != NULL ; ++i )
 		{
 			xmlFree( ( xmlChar* )attrs[i] ) ;
 			attrs[i] = NULL ;
 		}

 		xmlFree( ( void* ) attrs ) ;
 		attrs = NULL ;
 	}
 }

 /**
  * XDocumentHandler -- end an xml element
  */
 void SAXHelper::endElement( const rtl::OUString& aName )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	xmlChar* fullname = NULL ;

 	fullname = ous_to_xmlstr( aName ) ;
 	m_pSaxHandler->endElement( m_pParserCtxt , fullname ) ;

 	if( fullname != NULL )
 	{
 		xmlFree( ( xmlChar* )fullname ) ;
 		fullname = NULL ;
 	}
 }

 /**
  * XDocumentHandler -- an xml element or cdata characters
  */
 void SAXHelper::characters( const rtl::OUString& aChars )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	const xmlChar* chars = NULL ;
 	int length = 0 ;

 	chars = ous_to_nxmlstr( aChars, length ) ;
 	m_pSaxHandler->characters( m_pParserCtxt , chars , length ) ;

 	if( chars != NULL )
 	{
 		xmlFree( ( xmlChar* )chars ) ;
 	}
 }

 /**
  * XDocumentHandler -- ignorable xml white space
  */
 void SAXHelper::ignorableWhitespace( const rtl::OUString& aWhitespaces )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	const xmlChar* chars = NULL ;
 	int length = 0 ;

 	chars = ous_to_nxmlstr( aWhitespaces, length ) ;
 	m_pSaxHandler->ignorableWhitespace( m_pParserCtxt , chars , length ) ;

 	if( chars != NULL )
 	{
 		xmlFree( ( xmlChar* )chars ) ;
 	}
 }

 /**
  * XDocumentHandler -- preaorocessing instruction
  */
 void SAXHelper::processingInstruction(
 	const rtl::OUString& aTarget,
 	const rtl::OUString& aData )
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	xmlChar* target = NULL ;
 	xmlChar* data = NULL ;

 	target = ous_to_xmlstr( aTarget ) ;
 	data = ous_to_xmlstr( aData ) ;

 	m_pSaxHandler->processingInstruction( m_pParserCtxt , target , data ) ;

 	if( target != NULL )
 	{
 		xmlFree( ( xmlChar* )target ) ;
 		target = NULL ;
 	}

 	if( data != NULL )
 	{
 		xmlFree( ( xmlChar* )data ) ;
 		data = NULL ;
 	}
 }

 /**
  * XDocumentHandler -- set document locator
  * In this case, locator is useless.
  */
 void SAXHelper::setDocumentLocator(
 	const cssu::Reference< cssxs::XLocator > &)
 	throw( cssxs::SAXException , cssu::RuntimeException )
 {
 	//--Pseudo code if necessary
 	//--m_pSaxLocator is a member defined as xmlSAXHabdlerPtr
 	//--m_pSaxLocatorHdl is a member defined as Sax_Locator

 	//if( m_pSaxLocator != NULL ) {
 	//	//Deallocate the memory
 	//}
 	//if( m_pSaxLocatorHdl != NULL ) {
 	//	//Deallocate the memory
 	//}

 	//m_pSaxLocatorHdl = new Sax_Locator( xLocator ) ;
 	//m_pSaxLocator = { m_pSaxLocatorHdl->getPublicId , m_pSaxLocatorHdl->getSystemId , m_pSaxLocatorHdl->getLineNumber , m_pSaxLocatorHdl->getColumnNumber } ;

 	//m_pSaxHandler->setDocumentLocator( m_pParserCtxt , m_pSaxLocator ) ;
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_xmlsecurity.hxx"

	#include <rtl/ustring.hxx>

	#include "saxhelper.hxx"
	#include "libxml/parserInternals.h"

	#ifndef XMLSEC_NO_XSLT
	#include "libxslt/xslt.h"
	#endif

	namespace cssu = com::sun::star::uno;
	namespace cssxs = com::sun::star::xml::sax;
	namespace cssxcsax = com::sun::star::xml::csax;

	/**
	* The return value is NULL terminated. The application has the responsibilty to
	* deallocte the return value.
	*/
	xmlChar* ous_to_xmlstr( const rtl::OUString& oustr )
	{
	rtl::OString ostr = rtl::OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
	return xmlStrndup( ( xmlChar* )ostr.getStr(), ( int )ostr.getLength() ) ;
	}

	/**
	* The return value is NULL terminated. The application has the responsibilty to
	* deallocte the return value.
	*/
	xmlChar* ous_to_nxmlstr( const rtl::OUString& oustr, int& length )
	{
	rtl::OString ostr = rtl::OUStringToOString( oustr , RTL_TEXTENCODING_UTF8 ) ;
	length = ostr.getLength();

	return xmlStrndup( ( xmlChar* )ostr.getStr(), length ) ;
	}

	/**
	* The input parameter isn't necessaryly NULL terminated.
	*/
	rtl::OUString xmlchar_to_ous( const xmlChar* pChar, int length )
	{
	if( pChar != NULL )
	{
	return rtl::OUString( ( sal_Char* )pChar , length , RTL_TEXTENCODING_UTF8 ) ;
	}
	else
	{
	return rtl::OUString() ;
	}
	}

	/**
	* The input parameter is NULL terminated
	*/
	rtl::OUString xmlstr_to_ous( const xmlChar* pStr )
	{
	if( pStr != NULL )
	{
	return xmlchar_to_ous( pStr , xmlStrlen( pStr ) ) ;
	}
	else
	{
	return rtl::OUString() ;
	}
	}

	/**
	* The return value and the referenced value must be NULL terminated.
	* The application has the responsibilty to deallocte the return value.
	*/
	const xmlChar** attrlist_to_nxmlstr( const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
	{
	xmlChar* attname = NULL ;
	xmlChar* attvalue = NULL ;
	const xmlChar** attrs = NULL ;
	rtl::OUString oustr ;

	sal_Int32 nLength = aAttributes.getLength();;

	if( nLength != 0 )
	{
	attrs = ( const xmlChar** )xmlMalloc( ( nLength * 2 + 2 ) * sizeof( xmlChar* ) ) ;
	}
	else
	{
	return NULL ;
	}

	for( int i = 0 , j = 0 ; j < nLength ; ++j )
	{
	attname = ous_to_xmlstr( aAttributes[j].sName ) ;
	attvalue = ous_to_xmlstr( aAttributes[j].sValue ) ;

	if( attname != NULL && attvalue != NULL )
	{
	attrs[i++] = attname ;
	attrs[i++] = attvalue ;
	attrs[i] = NULL ;
	attrs[i+1] = NULL ;
	}
	else
	{
	if( attname != NULL )
	xmlFree( attname ) ;
	if( attvalue != NULL )
	xmlFree( attvalue ) ;
	}
	}

	return attrs ;
	}

	/**
	* Constructor
	*
	* In this constructor, a libxml sax parser context is initialized. a libxml
	* default sax handler is initialized with the context.
	*/
	SAXHelper::SAXHelper( )
	: m_pParserCtxt( NULL ),
	m_pSaxHandler( NULL )
	{
	xmlInitParser() ;
	LIBXML_TEST_VERSION ;

	/*
	* compile error:
	* xmlLoadExtDtdDefaultValue = XML_DETECT_IDS \| XML_COMPLETE_ATTRS ;
	*/
	xmlSubstituteEntitiesDefault( 1 ) ;

	#ifndef XMLSEC_NO_XSLT
	xmlIndentTreeOutput = 1 ;
	#endif /* XMLSEC_NO_XSLT */

	m_pParserCtxt = xmlNewParserCtxt() ;

	/*
	* i41748
	*
	* mmi : re-initialize the SAX handler to version 1
	*/

	xmlSAXVersion(m_pParserCtxt->sax, 1);

	/* end */

	if( m_pParserCtxt->inputTab[0] != NULL )
	{
	m_pParserCtxt->inputTab[0] = NULL ;
	}

	if( m_pParserCtxt == NULL )
	{
	#ifndef XMLSEC_NO_XSLT
	xsltCleanupGlobals() ;
	#endif
	// see issue i74334, we cannot call xmlCleanupParser when libxml is still used
	// in other parts of the office.
	// xmlCleanupParser() ;
	throw cssu::RuntimeException() ;
	}
	else if( m_pParserCtxt->sax == NULL )
	{
	xmlFreeParserCtxt( m_pParserCtxt ) ;

	#ifndef XMLSEC_NO_XSLT
	xsltCleanupGlobals() ;
	#endif
	// see issue i74334, we cannot call xmlCleanupParser when libxml is still used
	// in other parts of the office.
	// xmlCleanupParser() ;
	m_pParserCtxt = NULL ;
	throw cssu::RuntimeException() ;
	}
	else
	{
	m_pSaxHandler = m_pParserCtxt->sax ;

	//Adjust the context
	m_pParserCtxt->recovery = 1 ;
	}
	}

	/**
	* Destructor
	*
	* In this destructor, a libxml sax parser context is desturcted. The XML tree
	* in the context is not deallocated because the tree is bind with a document
	* model by the setTargetDocument method, which delegate the target document to
	* destruct the xml tree.
	*/
	SAXHelper::~SAXHelper() {
	if( m_pParserCtxt != NULL )
	{
	/*
	* In the situation that no object refer the Document, this destructor
	* must deallocate the Document memory
	*/
	if( m_pSaxHandler == m_pParserCtxt->sax )
	{
	m_pSaxHandler = NULL ;
	}

	xmlFreeParserCtxt( m_pParserCtxt ) ;
	m_pParserCtxt = NULL ;
	}

	if( m_pSaxHandler != NULL )
	{
	xmlFree( m_pSaxHandler ) ;
	m_pSaxHandler = NULL ;
	}
	// see issue i74334, we cannot call xmlCleanupParser when libxml is still used
	// in other parts of the office.
	// xmlCleanupParser() ;
	}

	xmlNodePtr SAXHelper::getCurrentNode()
	{
	return m_pParserCtxt->node;
	}

	void SAXHelper::setCurrentNode(const xmlNodePtr pNode)
	{
	/*
	* This is really a black trick.
	* When the current node is replaced, the nodeTab
	* stack's top has to been replaced with the same
	* node, in order to make compatibility.
	*/
	m_pParserCtxt->nodeTab[m_pParserCtxt->nodeNr - 1]
	= m_pParserCtxt->node
	= pNode;
	}

	xmlDocPtr SAXHelper::getDocument()
	{
	return m_pParserCtxt->myDoc;
	}

	/**
	* XDocumentHandler -- start an xml document
	*/
	void SAXHelper::startDocument( void )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	/*
	* Adjust inputTab
	*/
	xmlParserInputPtr pInput = xmlNewInputStream( m_pParserCtxt ) ;

	if( m_pParserCtxt->inputTab != NULL && m_pParserCtxt->inputMax != 0 )
	{
	m_pParserCtxt->inputTab[0] = pInput ;
	m_pParserCtxt->input = pInput ;
	}

	m_pSaxHandler->startDocument( m_pParserCtxt ) ;

	if( m_pParserCtxt == NULL \|\| m_pParserCtxt->myDoc == NULL )
	{
	throw cssu::RuntimeException() ;
	}
	}

	/**
	* XDocumentHandler -- end an xml document
	*/
	void SAXHelper::endDocument( void )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	m_pSaxHandler->endDocument( m_pParserCtxt ) ;
	}

	/**
	* XDocumentHandler -- start an xml element
	*/
	void SAXHelper::startElement(
	const rtl::OUString& aName,
	const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	const xmlChar* fullName = NULL ;
	const xmlChar** attrs = NULL ;

	fullName = ous_to_xmlstr( aName ) ;
	attrs = attrlist_to_nxmlstr( aAttributes ) ;

	if( fullName != NULL \|\| attrs != NULL )
	{
	m_pSaxHandler->startElement( m_pParserCtxt , fullName , attrs ) ;
	}

	if( fullName != NULL )
	{
	xmlFree( ( xmlChar* )fullName ) ;
	fullName = NULL ;
	}

	if( attrs != NULL )
	{
	for( int i = 0 ; attrs[i] != NULL ; ++i )
	{
	xmlFree( ( xmlChar* )attrs[i] ) ;
	attrs[i] = NULL ;
	}

	xmlFree( ( void* ) attrs ) ;
	attrs = NULL ;
	}
	}

	/**
	* XDocumentHandler -- end an xml element
	*/
	void SAXHelper::endElement( const rtl::OUString& aName )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	xmlChar* fullname = NULL ;

	fullname = ous_to_xmlstr( aName ) ;
	m_pSaxHandler->endElement( m_pParserCtxt , fullname ) ;

	if( fullname != NULL )
	{
	xmlFree( ( xmlChar* )fullname ) ;
	fullname = NULL ;
	}
	}

	/**
	* XDocumentHandler -- an xml element or cdata characters
	*/
	void SAXHelper::characters( const rtl::OUString& aChars )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	const xmlChar* chars = NULL ;
	int length = 0 ;

	chars = ous_to_nxmlstr( aChars, length ) ;
	m_pSaxHandler->characters( m_pParserCtxt , chars , length ) ;

	if( chars != NULL )
	{
	xmlFree( ( xmlChar* )chars ) ;
	}
	}

	/**
	* XDocumentHandler -- ignorable xml white space
	*/
	void SAXHelper::ignorableWhitespace( const rtl::OUString& aWhitespaces )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	const xmlChar* chars = NULL ;
	int length = 0 ;

	chars = ous_to_nxmlstr( aWhitespaces, length ) ;
	m_pSaxHandler->ignorableWhitespace( m_pParserCtxt , chars , length ) ;

	if( chars != NULL )
	{
	xmlFree( ( xmlChar* )chars ) ;
	}
	}

	/**
	* XDocumentHandler -- preaorocessing instruction
	*/
	void SAXHelper::processingInstruction(
	const rtl::OUString& aTarget,
	const rtl::OUString& aData )
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	xmlChar* target = NULL ;
	xmlChar* data = NULL ;

	target = ous_to_xmlstr( aTarget ) ;
	data = ous_to_xmlstr( aData ) ;

	m_pSaxHandler->processingInstruction( m_pParserCtxt , target , data ) ;

	if( target != NULL )
	{
	xmlFree( ( xmlChar* )target ) ;
	target = NULL ;
	}

	if( data != NULL )
	{
	xmlFree( ( xmlChar* )data ) ;
	data = NULL ;
	}
	}

	/**
	* XDocumentHandler -- set document locator
	* In this case, locator is useless.
	*/
	void SAXHelper::setDocumentLocator(
	const cssu::Reference< cssxs::XLocator > &)
	throw( cssxs::SAXException , cssu::RuntimeException )
	{
	//--Pseudo code if necessary
	//--m_pSaxLocator is a member defined as xmlSAXHabdlerPtr
	//--m_pSaxLocatorHdl is a member defined as Sax_Locator

	//if( m_pSaxLocator != NULL ) {
	// //Deallocate the memory
	//}
	//if( m_pSaxLocatorHdl != NULL ) {
	// //Deallocate the memory
	//}

	//m_pSaxLocatorHdl = new Sax_Locator( xLocator ) ;
	//m_pSaxLocator = { m_pSaxLocatorHdl->getPublicId , m_pSaxLocatorHdl->getSystemId , m_pSaxLocatorHdl->getLineNumber , m_pSaxLocatorHdl->getColumnNumber } ;

	//m_pSaxHandler->setDocumentLocator( m_pParserCtxt , m_pSaxLocator ) ;
	}