Attachment #169168 for bug #242218




		// until we're done.
		AttributesVectorType		tempVector(getMemoryManager());

		const XalanSize_t	theLength = theRHS.getLength();

		if (theLength > 0)
		{

		// safe and don't need any try blocks.
		AttributesImpl	theTempList(getMemoryManager());

		const XalanSize_t	theLength = theRHS.getLength();

		theTempList.reserve(theLength);

		// Add each attribute.
		for(XalanSize_t i = 0; i < theLength; i++)
		{
			theTempList.addAttribute(
					theRHS.getURI(i),




XalanSize_t
AttributesImpl::getLength() const
{
	return unsigned(m_attributesVector.size());



const XMLCh*
AttributesImpl::getURI(const XalanSize_t    index) const
{
	assert(index < getLength());




const XMLCh*
AttributesImpl::getLocalName(const XalanSize_t  index) const
{
	assert(index < getLength());




const XMLCh*
AttributesImpl::getQName(const XalanSize_t  index) const
{
	assert(index < getLength());




const XMLCh*
AttributesImpl::getType(const XalanSize_t   index) const
{
	assert(index < getLength());




const XMLCh*
AttributesImpl::getValue(const XalanSize_t  index) const
{
	assert(index < getLength());





bool
AttributesImpl::getIndex(
            const XMLCh* const  uri,
            const XMLCh* const  localPart,
            XalanSize_t&        index) const
{
    const int   tempIndex =
        getIndex(uri, localPart);

    if (tempIndex == -1)
    {
        return false;
    }
    else
    {
        index = tempIndex;

        return true;
    }
}



int
AttributesImpl::getIndex(
			const XMLCh* const	uri,
			const XMLCh* const	localPart) const
{
	assert(uri != 0 && localPart != 0);

	const AttributesVectorType::const_iterator	i =
		XALAN_STD_QUALIFIER find_if(
			m_attributesVector.begin(),
			m_attributesVector.end(),
			URIAndLocalNameCompareFunctor(uri, localPart));

	if (i != m_attributesVector.end())
	{




bool
AttributesImpl::getIndex(
            const XMLCh* const  qName,
            XalanSize_t&        index) const
{
    const int   tempIndex =
        getIndex(qName);

    if (tempIndex == -1)
    {
        return false;
    }
    else
    {
        index = tempIndex;

        return true;
    }
}



int
AttributesImpl::getIndex(const XMLCh* const		qname) const
{







NamedNodeMapAttributeList::NamedNodeMapAttributeList(
            const XalanNamedNodeMap&    theMap,
            MemoryManagerType&          theManager) :
	ParentType(),
	m_nodeMap(theMap),
	m_lastIndex(theMap.getLength() - 1),
    m_memoryManager(theManager)
{
    assert(theMap.getLength() != 0);
}






XalanSize_t
NamedNodeMapAttributeList::getLength() const
{
	return m_nodeMap.getLength();



const XMLCh*
NamedNodeMapAttributeList::getName(const XalanSize_t    index) const
{
	const XalanNode* const	theAttribute = m_nodeMap.item(m_lastIndex - index);
	assert(theAttribute != 0);



const XMLCh*
NamedNodeMapAttributeList::getType(const XalanSize_t    /* index */) const
{
	assert(length(s_typeString) > 0);




const XMLCh*
NamedNodeMapAttributeList::getValue(const XalanSize_t   index) const
{
    assert(index <= m_lastIndex);

    const XalanNode* const	theAttribute = m_nodeMap.item(m_lastIndex - index);
	assert(theAttribute != 0);

	return c_wstr(theAttribute->getNodeValue());



const XMLCh*
NamedNodeMapAttributeList::getValue(const XMLCh* const  name) const
{
	const XalanNode*	theNode = m_nodeMap.getNamedItem(XalanDOMString(name, m_memoryManager));








XalanFilePos
StdBinInputStream::curPos() const
{
	return m_stream.tellg();




XalanSize_t
StdBinInputStream::readBytes(
			XMLByte* const      toFill,
			const XalanSize_t	maxToRead)
{
	assert(sizeof(XMLByte) == sizeof(char));





const XalanDOMChar*
StdBinInputStream::getContentType() const
{
    return 0;
}



XALAN_CPP_NAMESPACE_END




    }

	// These are inherited from AttributeList
    virtual XalanSize_t
	getLength() const;

    virtual const XMLCh*
	getName(const XalanSize_t index) const;

    virtual const XMLCh*
	getType(const XalanSize_t index) const;

    virtual const XMLCh*
	getValue(const XalanSize_t index) const;

    virtual const XMLCh*
	getType(const XMLCh* const name) const;

	 * @param theCount The number to reserve
	 */
	void
	reserve(XalanSize_t     theCount)
	{
		m_AttributeVector.reserve(theCount);
	}




{
public:

	typedef XalanLocator::size_type					size_type;

	/**
	 * Constructor
	 * 

	 * 
	 * @return the line number
	 */
	XalanFileLoc
	getLineNumber() const
	{
		return m_lineNumber;

	 * 
	 * @return the column number
	 */
	XalanFileLoc
	getColumnNumber() const
	{
		return m_columnNumber;
	}


    MemoryManagerType& 
    getMemoryManager()const
    {





    typedef Locator     ParentType;

    typedef XMLSSize_t  size_type;

    XalanLocator() {}

    virtual

    virtual const XMLCh*
    getSystemId() const = 0;

    virtual XalanFileLoc
    getLineNumber() const = 0;

    virtual XalanFileLoc
    getColumnNumber() const = 0;

    static XalanFileLoc
    getLineNumber(const ParentType*     theLocator)
    {
        return theLocator == 0 ? getUnknownValue() : theLocator->getLineNumber();
    }

    static XalanFileLoc
    getColumnNumber(const ParentType*   theLocator)
    {
        return theLocator == 0 ? getUnknownValue() : theLocator->getColumnNumber();
    }

    static XalanFileLoc
    getUnknownValue()
    {
        return XalanFileLoc(-1);
    }

private:

Lines 74-77 Link Here

(-)src/xalanc/PlatformSupport/XalanMemoryManagerDefault.cpp (+8 lines)
74		74
75		75
76		76
		77	MemoryManager*
		78	XalanMemoryManagerDefault::getExceptionMemoryManager()
		79	{
		80	return this;
		81	}
		82
		83
		84
77	XALAN_CPP_NAMESPACE_END	85	XALAN_CPP_NAMESPACE_END

Lines 66-72 Link Here

(-)src/xalanc/PlatformSupport/FormatterListener.hpp (-1 / +1 lines)
66	typedef XERCES_CPP_NAMESPACE_QUALIFIER DocumentHandler ParentType;	66	typedef XERCES_CPP_NAMESPACE_QUALIFIER DocumentHandler ParentType;
67		67
68	// A handy typedef... Must match DocumentHandler's type for characters(), etc...	68	// A handy typedef... Must match DocumentHandler's type for characters(), etc...
69	typedef unsigned int size_type;	69	typedef XalanSize_t size_type;
70		70
71	enum eFormat	71	enum eFormat
72	{	72	{

Lines 705-711 Link Here

(-)src/xalanc/PlatformSupport/DOMStringHelper.hpp (-1 / +1 lines)
705	{	705	{
706	public:	706	public:
707		707
708	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const unsigned int);	708	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const FormatterListener::size_type);
709		709
710	static void	710	static void
711	DoubleToCharacters(	711	DoubleToCharacters(




	typedef XERCES_CPP_NAMESPACE_QUALIFIER AttributeList	ParentType;

	explicit
	NamedNodeMapAttributeList(
                const XalanNamedNodeMap&	theMap,
                MemoryManagerType&          theManager);

	virtual
	~NamedNodeMapAttributeList();

	// These are inherited from AttributeList
    virtual XalanSize_t
	getLength() const;

    virtual const XalanDOMChar*
	getName(const XalanSize_t   index) const;

    virtual const XalanDOMChar*
	getType(const XalanSize_t   index) const;

    virtual const XalanDOMChar*
	getValue(const XalanSize_t  index) const;

    virtual const XalanDOMChar*
	getType(const XalanDOMChar* const name) const;

	// Data members...
	const XalanNamedNodeMap&	m_nodeMap;

	const XalanSize_t			m_lastIndex;

    MemoryManagerType&          m_memoryManager;

	static const XalanDOMChar	s_typeString[];

    	MemoryManagerType&  m_memoryManager;
};






	AttributesImpl&
	operator=(const AttributesType&		theRHS);

	// These are inherited from Attributes
    virtual XalanSize_t
	getLength() const;

	virtual const XMLCh*
	getURI(const XalanSize_t    index) const;

	virtual const XMLCh*
	getLocalName(const XalanSize_t  index) const;

    virtual const XMLCh*
	getQName(const XalanSize_t  index) const;

    virtual const XMLCh*
	getType(const XalanSize_t   index) const;

    virtual const XMLCh*
	getValue(const XalanSize_t  index) const;

    virtual bool
    getIndex(
            const XMLCh* const  uri,
            const XMLCh* const  localPart,
            XalanSize_t&        index) const;

    virtual int
	getIndex(
			const XMLCh* const	uri,
			const XMLCh* const	localPart) const;

    virtual bool
    getIndex(
            const XMLCh* const  qName,
            XalanSize_t&        index) const;

    virtual int
	getIndex(const XMLCh* const		qname) const;

    virtual const XMLCh*

	 * @param theCount The number to reserve
	 */
	void
	reserve(XalanSize_t     theCount)
	{
		m_attributesVector.reserve(theCount);
	}




		// until we're done.
		AttributeVectorType		tempVector(getMemoryManager());

		const XalanSize_t	theLength = theRHS.getLength();

		if (theLength > 0)
		{

		// safe and don't need any try blocks.
		AttributeListImpl	theTempList(getMemoryManager());

		const XalanSize_t	theLength = theRHS.getLength();

		theTempList.reserve(theLength);

		// Add each attribute.
		for(XalanSize_t i = 0; i < theLength; i++)
		{
			theTempList.addAttribute(
					theRHS.getName(i),




XalanSize_t
AttributeListImpl::getLength() const
{
	// Make sure the mismatch between Xerces and vector<> doesn't cause a problem...



const XMLCh*
AttributeListImpl::getName(const XalanSize_t    index) const
{
	assert(index < getLength());




const XMLCh*
AttributeListImpl::getType(const XalanSize_t    index) const
{
	assert(index < getLength());




const XMLCh*
AttributeListImpl::getValue(const XalanSize_t   index) const
{
	assert(index < getLength());





	virtual
	~StdBinInputStream();

	virtual XalanFilePos
	curPos() const;

	virtual XalanSize_t
	readBytes(
			XMLByte* const      toFill,
			const XalanSize_t   maxToRead);

    virtual const XalanDOMChar*
    getContentType() const;

private:

	// Unimplemented...

Lines 52-57 Link Here

(-)src/xalanc/PlatformSupport/XalanMemoryManagerDefault.hpp (+3 lines)
52	virtual void	52	virtual void
53	deallocate(void* pointer);	53	deallocate(void* pointer);
54		54
		55	virtual MemoryManager*
		56	getExceptionMemoryManager();
		57
55	private:	58	private:
56		59
57	// These are not implemented.	60	// These are not implemented.

Lines 56-63 Link Here

(-)src/xalanc/PlatformSupport/XalanTranscodingServices.hpp (-2 / +2 lines)
56	static void	56	static void
57	terminate();	57	terminate();
58		58
59	typedef unsigned char XalanXMLByte;	59	typedef unsigned char XalanXMLByte;
60	typedef unsigned int size_type;	60	typedef XalanSize_t size_type;
61	typedef unsigned int UnicodeCharType;	61	typedef unsigned int UnicodeCharType;
62		62
63	static size_type	63	static size_type

Lines 40-46 Link Here

(-)src/xalanc/PlatformSupport/XalanMemoryManagement.cpp (-3 / +8 lines)
40		40
41	return 0;	41	return 0;
42	}	42	}
43	virtual void	43
		44	virtual void
44	deallocate( void* /* pDataPointer */ )	45	deallocate( void* /* pDataPointer */ )
45	{	46	{
46	XALAN_USING_STD(bad_alloc)	47	XALAN_USING_STD(bad_alloc)
Lines 48-55 Link Here
48	throw bad_alloc();	49	throw bad_alloc();
49		50
50	}	51	}
51		52
52		53	MemoryManager*
		54	getExceptionMemoryManager()
		55	{
		56	return this;
		57	}
53	};	58	};
54		59
55		60

Lines 17-23 Link Here

(-)src/xalanc/Include/VCPPDefinitions.hpp (-1 / +1 lines)
17	#define VCPPDEFINITIONS_HEADER_GUARD_1357924680	17	#define VCPPDEFINITIONS_HEADER_GUARD_1357924680
18		18
19		19
20	#pragma warning(disable: 4127 4251 4511 4512 4514 4702 4710 4711 4786 4097 4503 4786; error: 4150 4172 4238 4239 4715)	20	#pragma warning(disable: 4127 4251 4345 4351 4511 4512 4514 4521 4702 4710 4711 4786 4097 4503 4786; error: 4150 4172 4238 4239 4715)
21		21
22		22
23	// ---------------------------------------------------------------------------	23	// ---------------------------------------------------------------------------




typedef unsigned short	XalanDOMChar;
#endif

#if XERCES_VERSION_MAJOR < 3
typedef unsigned int    XalanSize_t;
typedef unsigned int    XalanFilePos;
typedef unsigned int    XalanFileLoc;
#else
typedef XMLSize_t       XalanSize_t;
typedef XMLFilePos      XalanFilePos;
typedef XMLFileLoc      XalanFileLoc;
#endif

template<bool value>
struct XalanCompileErrorBoolean
{

Lines 70-75 Link Here

(-)src/xalanc/XPath/XPathProcessorImpl.hpp (-4 / +6 lines)
70		70
71	typedef XalanVector<bool> BoolVectorType;	71	typedef XalanVector<bool> BoolVectorType;
72		72
		73	typedef XalanDOMString::size_type t_size_type;
		74
73	XPathProcessorImpl(MemoryManagerType& theManager XALAN_DEFAULT_MEMMGR);	75	XPathProcessorImpl(MemoryManagerType& theManager XALAN_DEFAULT_MEMMGR);
74		76
75	virtual	77	virtual
Lines 121-132 Link Here
121	* When a separator token is found, see if there's a element name or the	123	* When a separator token is found, see if there's a element name or the
122	* like to map.	124	* like to map.
123	*/	125	*/
124	int	126	t_size_type
125	mapNSTokens(	127	mapNSTokens(
126	const XalanDOMString& pat,	128	const XalanDOMString& pat,
127	int startSubstring,	129	t_size_type startSubstring,
128	int posOfNSSep,	130	t_size_type posOfNSSep,
129	int posOfScan);	131	t_size_type posOfScan);
130		132
131	/**	133	/**
132	* Check if m_token==s. If m_token is null, this won't throw	134	* Check if m_token==s. If m_token is null, this won't throw




{
    assert(m_xpathEnvSupport != 0);

    XalanFileLoc     lineNumber = XalanLocator::getUnknownValue();
    XalanFileLoc     columnNumber = XalanLocator::getUnknownValue();

    MemoryManagerType& theManager =  const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();


{
    assert(m_xpathEnvSupport != 0);

    XalanFileLoc    lineNumber = XalanLocator::getUnknownValue();
    XalanFileLoc    columnNumber = XalanLocator::getUnknownValue();

    MemoryManagerType& theManager =  const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();


{
    assert(m_xpathEnvSupport != 0);

    XalanFileLoc    lineNumber = XalanLocator::getUnknownValue();
    XalanFileLoc    columnNumber = XalanLocator::getUnknownValue();

   MemoryManagerType& theManager =  const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();


Lines 32-40 Link Here

(-)src/xalanc/XPath/XPathExecutionContextDefault.hpp (-4 / +5 lines)
32		32
33		33
34		34
35	/**
36	* @author <a href="mailto:david_n_bertoni@lotus.com">David N. Bertoni</a>
37	*/
38	// Base class include file.	35	// Base class include file.
39	#include <xalanc/XPath/XPathExecutionContext.hpp>	36	#include <xalanc/XPath/XPathExecutionContext.hpp>
40		37
Lines 346-352 Link Here
346		343
347	protected:	344	protected:
348		345
349	typedef XalanObjectCache<MutableNodeRefList, DefaultCacheCreateFunctorMemMgr<MutableNodeRefList>, DeleteFunctor<MutableNodeRefList>, ClearCacheResetFunctor<MutableNodeRefList> > NodeListCacheType;	346	typedef XalanObjectCache<
		347	MutableNodeRefList,
		348	DefaultCacheCreateFunctorMemMgr<MutableNodeRefList>,
		349	DeleteFunctor<MutableNodeRefList>,
		350	ClearCacheResetFunctor<MutableNodeRefList> > NodeListCacheType;
350		351
351	enum { eNodeListCacheListSize = 50 };	352	enum { eNodeListCacheListSize = 50 };
352		353





void
FormatterStringLengthCounter::characters(
			const XMLCh* const  /* chars */,
			const size_type     length)
{
	m_count += length;
}


void
FormatterStringLengthCounter::charactersRaw(
		const XMLCh* const  /* chars */,
		const size_type	    /*length */)
{
}



void
FormatterStringLengthCounter::ignorableWhitespace(
			const XMLCh* const  /* chars */,
			const size_type	    /* length */)
{
}



void
FormatterStringLengthCounter::cdata(
			const XMLCh* const  /* ch */,
			const size_type     /* length */)
{
}





        {
        }

        // Note non-const copy semantics...
        GetAndReleaseCachedString(GetAndReleaseCachedString&    theSource) :
            m_constructionContext(theSource.m_constructionContext),
            m_string(theSource.m_string)
        {
            theSource.m_string = 0;
        }

        ~GetAndReleaseCachedString()
        {
            assert(m_string != 0);

            m_constructionContext->releaseCachedString(*m_string);
            }
        }

        XalanDOMString&

        XPathConstructionContext&
        getConstructionContext() const
        {
            assert(m_constructionContext != 0);

            return *m_constructionContext;
        }


    private:

        // Not implemented...
        GetAndReleaseCachedString();

        GetAndReleaseCachedString(const GetAndReleaseCachedString&);

        GetAndReleaseCachedString&
        operator=(const GetAndReleaseCachedString&);


Lines 35-43 Link Here

(-)src/xalanc/XPath/XPathExecutionContext.hpp (-3 / +4 lines)
35		35
36		36
37		37
38	/**
39	* @author <a href="mailto:david_n_bertoni@lotus.com">David N. Bertoni</a>
40	*/
41	// Base class header file...	38	// Base class header file...
42	#include <xalanc/PlatformSupport/ExecutionContext.hpp>	39	#include <xalanc/PlatformSupport/ExecutionContext.hpp>
43		40
Lines 470-475 Link Here
470	private:	467	private:
471		468
472	// Not implemented...	469	// Not implemented...
		470	GetAndReleaseCachedString();
		471
		472	GetAndReleaseCachedString(const GetAndReleaseCachedString&);
		473
473	GetAndReleaseCachedString&	474	GetAndReleaseCachedString&
474	operator=(const GetAndReleaseCachedString&);	475	operator=(const GetAndReleaseCachedString&);
475		476

Lines 141-147 Link Here

(-)src/xalanc/XPath/XObject.hpp (-1 / +1 lines)
141	virtual const XalanDOMString&	141	virtual const XalanDOMString&
142	str() const;	142	str() const;
143		143
144	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const unsigned int);	144	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const FormatterListener::size_type);
145		145
146	/**	146	/**
147	* Send the string value to a FormatterListener instance.	147	* Send the string value to a FormatterListener instance.




{
public:

	typedef unsigned long	size_type;

	/**
	 * FormatterStringLengthCounter instance constructor.
	 */

    virtual void
	characters(
			const XMLCh* const	chars,
			const size_type	    length);

    virtual void
	charactersRaw(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	entityReference(const XMLCh* const	name);

	virtual void
	ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	processingInstruction(

	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type     length);

private:






    m_expression->setCurrentPattern(m_constructionContext->getPooledString(pat));

    const t_size_type   nChars = length(pat);

    t_size_type     startSubstring = XalanDOMString::npos;
    t_size_type     posOfNSSep = XalanDOMString::npos;

    const XPathConstructionContext::GetAndReleaseCachedString   theGuard(*m_constructionContext);

    XalanDOMString&     theToken = theGuard.get();

    for(t_size_type i = 0; i < nChars; i++)
    {
        XalanDOMChar    c = charAt(pat, i);


        {
        case XalanUnicode::charQuoteMark: 
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {      
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }


                    addToTokenQueue(theToken);

                    startSubstring = XalanDOMString::npos;
                }
                else
                {


        case XalanUnicode::charApostrophe:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }


                    addToTokenQueue(theToken);

                    startSubstring = XalanDOMString::npos;
                }
                else
                {

        case XalanUnicode::charSpace:
        case XalanUnicode::charHTab:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }

                        addToTokenQueue(theToken);
                    }

                    startSubstring = XalanDOMString::npos;
                }
            }
            break;
        
        case XalanUnicode::charHyphenMinus:
            {
                if(!(startSubstring == XalanDOMString::npos))
                {
                    break;
                }

        case XalanUnicode::charLessThanSign:
        case XalanUnicode::charGreaterThanSign:
            {
                if(startSubstring != XalanDOMString::npos)
                {
                    if(XalanDOMString::npos != posOfNSSep)
                    {    
                        posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
                    }

                        addToTokenQueue(theToken);
                    }

                    startSubstring = XalanDOMString::npos;
                }

                substring(pat, theToken, i, i + 1);

            {
                if(posOfNSSep == i - 1 && i > 0)
                { 
                    if(startSubstring != XalanDOMString::npos)
                    {
                        if (startSubstring < i - 1)
                        {

                        }
                    }

                    startSubstring = XalanDOMString::npos;
                    posOfNSSep = XalanDOMString::npos;

                    substring(pat, theToken, i - 1, i + 1);


        
        default:
            {
                if(XalanDOMString::npos == startSubstring)
                {
                    startSubstring = i;



                        addToTokenQueue(theToken);

                        startSubstring = XalanDOMString::npos;
                    }
                }
            }
        }
    }

    if(startSubstring != XalanDOMString::npos)
    {
        if(XalanDOMString::npos != posOfNSSep)
        {    
            posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, nChars);
        }




XPathProcessorImpl::t_size_type
XPathProcessorImpl::mapNSTokens(
            const XalanDOMString&   pat,
            t_size_type             startSubstring,
            t_size_type             posOfNSSep,
            t_size_type             posOfScan)
{
    assert(m_prefixResolver != 0);


        }
    }

    return XalanDOMString::npos;
}



bool
XPathProcessorImpl::isCurrentLiteral() const
{
    const t_size_type   theLength = m_token.length();

    if (theLength <= 1)
    {
        return false;
    }
    else
    {
        const t_size_type   last = theLength - 1;

        const XalanDOMChar  c0 = m_tokenChar;
        const XalanDOMChar  cX = charAt(m_token, last);


Lines 241-247 Link Here

(-)src/xalanc/XPath/XPath.hpp (-1 / +1 lines)
241	XPathExecutionContext& executionContext,	241	XPathExecutionContext& executionContext,
242	XalanDOMString& result) const;	242	XalanDOMString& result) const;
243		243
244	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const unsigned int);	244	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const FormatterListener::size_type);
245		245
246	/**	246	/**
247	* Execute the XPath from the provided context.	247	* Execute the XPath from the provided context.

Lines 83-88 Link Here

(-)src/xalanc/XercesParserLiaison/XercesDOMWrapperException.hpp (+6 lines)
83		83
84	static ExceptionCode	84	static ExceptionCode
85	translateErrorCode(DOMExceptionType::ExceptionCode theCode);	85	translateErrorCode(DOMExceptionType::ExceptionCode theCode);
		86
		87	static ExceptionCode
		88	translateErrorCode(short theCode)
		89	{
		90	return translateErrorCode(static_cast<DOMExceptionType::ExceptionCode>(theCode));
		91	}
86	};	92	};
87		93
88		94

Lines 741-747 Link Here

(-)src/xalanc/XercesParserLiaison/XercesParserLiaison.cpp (+9 lines)
741	DOMParserType* const theParser =	741	DOMParserType* const theParser =
742	new (&theMemoryManager) DOMParserType(0, &theMemoryManager);	742	new (&theMemoryManager) DOMParserType(0, &theMemoryManager);
743		743
		744	#if XERCES_VERSION_MAJOR < 3
744	theParser->setExpandEntityReferences(true);	745	theParser->setExpandEntityReferences(true);
		746	#else
		747	theParser->setCreateEntityReferenceNodes(false);
		748	#endif
		749
745	theParser->setDoNamespaces(m_doNamespaces);	750	theParser->setDoNamespaces(m_doNamespaces);
746	theParser->setEntityResolver(m_entityResolver);	751	theParser->setEntityResolver(m_entityResolver);
747		752
Lines 759-765 Link Here
759	SAXParserType* const theParser =	764	SAXParserType* const theParser =
760	new (&theMemoryManager) SAXParserType(0, &theMemoryManager);	765	new (&theMemoryManager) SAXParserType(0, &theMemoryManager);
761		766
		767	#if XERCES_VERSION_MAJOR < 3
762	theParser->setDoValidation(false);	768	theParser->setDoValidation(false);
		769	#else
		770	theParser->setValidationScheme(SAXParserType::Val_Never);
		771	#endif
763		772
764	theParser->setDoNamespaces(false);	773	theParser->setDoNamespaces(false);
765		774




	~XercesNamedNodeMapAttributeList();

	// These are inherited from AttributeList
    virtual XalanSize_t
	getLength() const;

    virtual const XMLCh*
	getName(const XalanSize_t   index) const;

    virtual const XMLCh*
	getType(const XalanSize_t   index) const;

    virtual const XMLCh*
	getValue(const XalanSize_t  index) const;

    virtual const XMLCh*
	getType(const XMLCh* const name) const;

	// Data members...
	const DOMNamedNodeMapType* const	m_nodeMap;

	const XalanSize_t					m_lastIndex;

	static const XMLCh	s_typeString[];
};




void
FormatterToXercesDOM::characters(
			const XMLCh* const	chars,
			const size_type	    length)
{
	m_textBuffer.append(chars, length);
}

void
FormatterToXercesDOM::charactersRaw(
		const XMLCh* const	chars,
		const size_type	    length)
{
	try
	{

void
FormatterToXercesDOM::ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length)
{
	try
	{

void
FormatterToXercesDOM::cdata(
			const XMLCh* const	ch,
			const size_type	    length)
{
	try
	{




	m_nodeMap(theMap),
	m_lastIndex(theMap->getLength() - 1)
{
    assert(theMap->getLength() != 0);
}






XalanSize_t
XercesNamedNodeMapAttributeList::getLength() const
{
	return m_lastIndex + 1;



const XMLCh*
XercesNamedNodeMapAttributeList::getName(const XalanSize_t  index) const
{
	const DOMNodeType* const	theAttribute = m_nodeMap->item(m_lastIndex - index);
	assert(theAttribute != 0);



const XMLCh*
XercesNamedNodeMapAttributeList::getType(const XalanSize_t  /* index */) const
{
	assert(length(s_typeString) > 0);




const XMLCh*
XercesNamedNodeMapAttributeList::getValue(const XalanSize_t     index) const
{
	const DOMNodeType* const	theAttribute = m_nodeMap->item(m_lastIndex - index);
	assert(theAttribute != 0);

const XMLCh* 
XercesNamedNodeMapAttributeList::getValue(const char* const /*name*/) const
{
    assert(false);

    return 0;
}




	~FormatterToXercesDOM();


	// These methods are inherited from FormatterListener...

	virtual void
	charactersRaw(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	comment(const XMLCh* const	data);

	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type 	length);

	virtual void
	entityReference(const XMLCh* const	name);

	virtual void
	characters(
				const XMLCh* const	chars,
				const size_type	    length);

	virtual void
	ignorableWhitespace(
				const XMLCh* const	chars,
				const size_type	    length);

	virtual void
	processingInstruction(

Lines 80-86 Link Here

(-)src/xalanc/XSLT/XSLTProcessor.hpp (-1 / +1 lines)
80	{	80	{
81	public:	81	public:
82		82
83	typedef size_t size_type;	83	typedef XalanSize_t size_type;
84		84
85	XSLTProcessor();	85	XSLTProcessor();
86		86




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,

{
    bool    isSelectCurrentNode = false;

    const XalanSize_t   nAttrs = atts.getLength();
    
    for (XalanSize_t i = 0; i < nAttrs; ++i)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_SELECT))
        {
            const XalanDOMChar* const   avalue = atts.getValue(i);
            assert(avalue != 0);

                m_selectPattern = constructionContext.createXPath(getLocator(), avalue, *this);
            }
        }
        else if (isAttrOK(
                    aname,
                    atts,
                    i,


    if (m_selectPattern == 0)
    {
        if (0 != executionContext.getTraceListeners())
        {
            StylesheetExecutionContext::BorrowReturnMutableNodeRefList  theNodeList(executionContext);


        const XObjectPtr    value(m_selectPattern->execute(*this, executionContext));
        assert(value.null() == false);

        if (0 != executionContext.getTraceListeners())
        {
            executionContext.fireSelectEvent(
                SelectionEvent(


    if (m_selectPattern == 0)
    {
        if (0 != executionContext.getTraceListeners())
        {
            StylesheetExecutionContext::BorrowReturnMutableNodeRefList  theNodeList(executionContext);


        const XObjectPtr    value(m_selectPattern->execute(*this, executionContext));
        assert(value.null() == false);

        if (0 != executionContext.getTraceListeners())
        {
            executionContext.fireSelectEvent(
                SelectionEvent(



const XPath*
ElemCopyOf::getXPath(XalanSize_t    index) const
{
    return index == 0 ? m_selectPattern : 0;
}

Lines 23-29 Link Here

(-)src/xalanc/XSLT/XalanElemAttributeSetAllocator.cpp (-3 / +5 lines)
23		23
24		24
25		25
26	XalanElemAttributeSetAllocator::XalanElemAttributeSetAllocator(MemoryManagerType& theManager, size_type theBlockCount) :	26	XalanElemAttributeSetAllocator::XalanElemAttributeSetAllocator(
		27	MemoryManagerType& theManager,
		28	size_type theBlockCount) :
27	m_allocator(theManager, theBlockCount)	29	m_allocator(theManager, theBlockCount)
28	{	30	{
29	}	31	}
Lines 41-48 Link Here
41	StylesheetConstructionContext& constructionContext,	43	StylesheetConstructionContext& constructionContext,
42	Stylesheet& stylesheetTree,	44	Stylesheet& stylesheetTree,
43	const AttributeListType& atts,	45	const AttributeListType& atts,
44	int lineNumber,	46	XalanFileLoc lineNumber,
45	int columnNumber)	47	XalanFileLoc columnNumber)
46	{	48	{
47	data_type* const theBlock = m_allocator.allocateBlock();	49	data_type* const theBlock = m_allocator.allocateBlock();
48	assert(theBlock != 0);	50	assert(theBlock != 0);

Lines 52-59 Link Here

(-)src/xalanc/XSLT/ElemAttribute.hpp (-2 / +2 lines)
52	StylesheetConstructionContext& constructionContext,	52	StylesheetConstructionContext& constructionContext,
53	Stylesheet& stylesheetTree,	53	Stylesheet& stylesheetTree,
54	const AttributeListType& atts,	54	const AttributeListType& atts,
55	int lineNumber,	55	XalanFileLoc lineNumber,
56	int columnNumber);	56	XalanFileLoc columnNumber);
57		57
58	virtual	58	virtual
59	~ElemAttribute();	59	~ElemAttribute();

Lines 57-63 Link Here

(-)src/xalanc/XSLT/XalanElemElementAllocator.hpp (-3 / +5 lines)
57	*	57	*
58	* @param theBlockSize The block size.	58	* @param theBlockSize The block size.
59	*/	59	*/
60	XalanElemElementAllocator(MemoryManagerType& theManager, size_type theBlockCount);	60	XalanElemElementAllocator(
		61	MemoryManagerType& theManager,
		62	size_type theBlockCount);
61		63
62	~XalanElemElementAllocator();	64	~XalanElemElementAllocator();
63		65
Lines 77-84 Link Here
77	StylesheetConstructionContext& constructionContext,	79	StylesheetConstructionContext& constructionContext,
78	Stylesheet& stylesheetTree,	80	Stylesheet& stylesheetTree,
79	const AttributeListType& atts,	81	const AttributeListType& atts,
80	int lineNumber,	82	XalanFileLoc lineNumber,
81	int columnNumber);	83	XalanFileLoc columnNumber);
82		84
83	/**	85	/**
84	* Determine if an object is owned by the allocator...	86	* Determine if an object is owned by the allocator...

Lines 57-63 Link Here

(-)src/xalanc/XSLT/XalanElemAttributeAllocator.hpp (-3 / +5 lines)
57	*	57	*
58	* @param theBlockSize The block size.	58	* @param theBlockSize The block size.
59	*/	59	*/
60	XalanElemAttributeAllocator(MemoryManagerType& theManager, size_type theBlockCount);	60	XalanElemAttributeAllocator(
		61	MemoryManagerType& theManager,
		62	size_type theBlockCount);
61		63
62	~XalanElemAttributeAllocator();	64	~XalanElemAttributeAllocator();
63		65
Lines 77-84 Link Here
77	StylesheetConstructionContext& constructionContext,	79	StylesheetConstructionContext& constructionContext,
78	Stylesheet& stylesheetTree,	80	Stylesheet& stylesheetTree,
79	const AttributeListType& atts,	81	const AttributeListType& atts,
80	int lineNumber,	82	XalanFileLoc lineNumber,
81	int columnNumber);	83	XalanFileLoc columnNumber);
82		84
83	/**	85	/**
84	* Determine if an object is owned by the allocator...	86	* Determine if an object is owned by the allocator...

Lines 631-638 Link Here

(-)src/xalanc/XSLT/StylesheetConstructionContextDefault.cpp (-17 / +17 lines)
631	StylesheetConstructionContext& constructionContext,	631	StylesheetConstructionContext& constructionContext,
632	Stylesheet& stylesheetTree,	632	Stylesheet& stylesheetTree,
633	const AttributeListType& atts,	633	const AttributeListType& atts,
634	int lineNumber,	634	XalanFileLoc lineNumber,
635	int columnNumber)	635	XalanFileLoc columnNumber)
636	{	636	{
637	Type* theResult;	637	Type* theResult;
638		638
Lines 656-664 Link Here
656	const AttributeListType& atts,	656	const AttributeListType& atts,
657	const LocatorType* locator)	657	const LocatorType* locator)
658	{	658	{
659	const XalanLocator::size_type lineNumber = XalanLocator::getLineNumber(locator);	659	const XalanFileLoc lineNumber =
660	const XalanLocator::size_type columnNumber = XalanLocator::getColumnNumber(locator);	660	XalanLocator::getLineNumber(locator);
661		661
		662	const XalanFileLoc columnNumber =
		663	XalanLocator::getColumnNumber(locator);
		664
662	ElemTemplateElement* theElement = 0;	665	ElemTemplateElement* theElement = 0;
663		666
664	switch(token)	667	switch(token)
Lines 975-983 Link Here
975	const AttributeListType& atts,	978	const AttributeListType& atts,
976	const LocatorType* locator)	979	const LocatorType* locator)
977	{	980	{
978	const XalanLocator::size_type lineNumber = XalanLocator::getLineNumber(locator);	981	const XalanFileLoc lineNumber =
979	const XalanLocator::size_type columnNumber = XalanLocator::getColumnNumber(locator);	982	XalanLocator::getLineNumber(locator);
980		983
		984	const XalanFileLoc columnNumber =
		985	XalanLocator::getColumnNumber(locator);
		986
981	ElemTemplateElement* theElement = 0;	987	ElemTemplateElement* theElement = 0;
982		988
983	if (token == ELEMNAME_LITERAL_RESULT)	989	if (token == ELEMNAME_LITERAL_RESULT)
Lines 1032-1040 Link Here
1032	ExtensionNSHandler& handler,	1038	ExtensionNSHandler& handler,
1033	const LocatorType* locator)	1039	const LocatorType* locator)
1034	{	1040	{
1035	const XalanLocator::size_type lineNumber = XalanLocator::getLineNumber(locator);
1036	const XalanLocator::size_type columnNumber = XalanLocator::getColumnNumber(locator);
1037
1038	m_allocatedElements.push_back(0);	1041	m_allocatedElements.push_back(0);
1039		1042
1040	m_allocatedElements.back() = ElemExtensionCall::create(	1043	m_allocatedElements.back() = ElemExtensionCall::create(
Lines 1043-1050 Link Here
1043	stylesheetTree,	1046	stylesheetTree,
1044	name,	1047	name,
1045	atts,	1048	atts,
1046	lineNumber,	1049	XalanLocator::getLineNumber(locator),
1047	columnNumber,	1050	XalanLocator::getColumnNumber(locator),
1048	handler);	1051	handler);
1049		1052
1050	return m_allocatedElements.back();	1053	return m_allocatedElements.back();
Lines 1061-1074 Link Here
1061	bool disableOutputEscaping,	1064	bool disableOutputEscaping,
1062	const LocatorType* locator)	1065	const LocatorType* locator)
1063	{	1066	{
1064	const XalanLocator::size_type lineNumber = XalanLocator::getLineNumber(locator);
1065	const XalanLocator::size_type columnNumber = XalanLocator::getColumnNumber(locator);
1066
1067	return m_elemTextLiteralAllocator.create(	1067	return m_elemTextLiteralAllocator.create(
1068	*this,	1068	*this,
1069	stylesheetTree,	1069	stylesheetTree,
1070	lineNumber,	1070	XalanLocator::getLineNumber(locator),
1071	columnNumber,	1071	XalanLocator::getColumnNumber(locator),
1072	chars,	1072	chars,
1073	0,	1073	0,
1074	length,	1074	length,
Lines 1992-1998 Link Here
1992	}	1992	}
1993	};	1993	};
1994		1994
1995	const unsigned int StylesheetConstructionContextDefault::s_elementTokenTableSize =	1995	const XalanSize_t StylesheetConstructionContextDefault::s_elementTokenTableSize =
1996	sizeof(s_elementTokenTable) / sizeof(s_elementTokenTable[0]);	1996	sizeof(s_elementTokenTable) / sizeof(s_elementTokenTable[0]);
1997		1997
1998	const StylesheetConstructionContextDefault::ElementTokenTableEntry& StylesheetConstructionContextDefault::s_elementTokenTableLast =	1998	const StylesheetConstructionContextDefault::ElementTokenTableEntry& StylesheetConstructionContextDefault::s_elementTokenTableLast =





	typedef XalanQName::NamespacesStackType		NamespacesStackType;

#if defined(XALAN_STRICT_ANSI_HEADERS)
	typedef std::size_t		size_type;
#else
	typedef size_t			size_type;
#endif

	/**
	 * IDs for XSL element types. These are the values
	 * that must be returned by getElementToken().

Lines 57-64 Link Here

(-)src/xalanc/XSLT/ElemDecimalFormat.hpp (-3 / +3 lines)
57	StylesheetConstructionContext& constructionContext,	57	StylesheetConstructionContext& constructionContext,
58	Stylesheet& stylesheetTree,	58	Stylesheet& stylesheetTree,
59	const AttributeListType& atts,	59	const AttributeListType& atts,
60	int lineNumber,	60	XalanFileLoc lineNumber,
61	int columnNumber);	61	XalanFileLoc columnNumber);
62		62
63		63
64	~ElemDecimalFormat();	64	~ElemDecimalFormat();
Lines 83-89 Link Here
83	}	83	}
84		84
85	virtual const XPath*	85	virtual const XPath*
86	getXPath(unsigned int index = 0) const;	86	getXPath(XalanSize_t index) const;
87		87
88	private:	88	private:
89		89

Lines 49-56 Link Here

(-)src/xalanc/XSLT/ElemAttributeSet.hpp (-2 / +2 lines)
49	StylesheetConstructionContext& constructionContext,	49	StylesheetConstructionContext& constructionContext,
50	Stylesheet& stylesheetTree,	50	Stylesheet& stylesheetTree,
51	const AttributeListType& atts,	51	const AttributeListType& atts,
52	int lineNumber,	52	XalanFileLoc lineNumber,
53	int columnNumber);	53	XalanFileLoc columnNumber);
54		54
55	virtual	55	virtual
56	~ElemAttributeSet();	56	~ElemAttributeSet();





void
StylesheetExecutionContextDefault::characters(
            const XalanDOMChar*     ch,
            fl_size_type            start,
            fl_size_type            length)
{
    assert(m_xsltProcessor != 0);



void
StylesheetExecutionContextDefault::charactersRaw(
            const XalanDOMChar*     ch,
            fl_size_type            start,
            fl_size_type            length)
{
    assert(m_xsltProcessor != 0);





            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,

    m_orderAVT(0),
    m_caseOrderAVT(0)
{
    const XalanSize_t nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_SELECT))
        {
            m_selectPattern 
                = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
        }
        else if (equals(aname, Constants::ATTRNAME_LANG))
        {           
            m_langAVT =
                    constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
        }
        else if (equals(aname, Constants::ATTRNAME_DATATYPE))
        {
            m_dataTypeAVT =
                    constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
        }
        else if (equals(aname, Constants::ATTRNAME_ORDER))
        {
            m_orderAVT =
                    constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
        }
        else if (equals(aname, Constants::ATTRNAME_CASEORDER))
        {
            m_caseOrderAVT =
                    constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
        }
        else if (isAttrOK(
                    aname,
                    atts,
                    i,

            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber)
{
    typedef ElemSort ThisType;




const XPath*
ElemSort::getXPath(XalanSize_t  index) const
{
    return index == 0 ? m_selectPattern : 0;
}

Lines 60-67 Link Here

(-)src/xalanc/XSLT/ElemElement.hpp (-2 / +2 lines)
60	StylesheetConstructionContext& constructionContext,	60	StylesheetConstructionContext& constructionContext,
61	Stylesheet& stylesheetTree,	61	Stylesheet& stylesheetTree,
62	const AttributeListType& atts,	62	const AttributeListType& atts,
63	int lineNumber,	63	XalanFileLoc lineNumber,
64	int columnNumber);	64	XalanFileLoc columnNumber);
65		65
66	virtual	66	virtual
67	~ElemElement();	67	~ElemElement();

Lines 57-63 Link Here

(-)src/xalanc/XSLT/XalanElemApplyTemplatesAllocator.hpp (-3 / +5 lines)
57	*	57	*
58	* @param theBlockSize The block size.	58	* @param theBlockSize The block size.
59	*/	59	*/
60	XalanElemApplyTemplatesAllocator(MemoryManagerType& theManager, size_type theBlockCount);	60	XalanElemApplyTemplatesAllocator(
		61	MemoryManagerType& theManager,
		62	size_type theBlockCount);
61		63
62	~XalanElemApplyTemplatesAllocator();	64	~XalanElemApplyTemplatesAllocator();
63		65
Lines 77-84 Link Here
77	StylesheetConstructionContext& constructionContext,	79	StylesheetConstructionContext& constructionContext,
78	Stylesheet& stylesheetTree,	80	Stylesheet& stylesheetTree,
79	const AttributeListType& atts,	81	const AttributeListType& atts,
80	int lineNumber,	82	XalanFileLoc lineNumber,
81	int columnNumber);	83	XalanFileLoc columnNumber);
82		84
83	/**	85	/**
84	* Determine if an object is owned by the allocator...	86	* Determine if an object is owned by the allocator...

Lines 57-64 Link Here

(-)src/xalanc/XSLT/ElemCopyOf.hpp (-3 / +3 lines)
57	StylesheetConstructionContext& constructionContext,	57	StylesheetConstructionContext& constructionContext,
58	Stylesheet& stylesheetTree,	58	Stylesheet& stylesheetTree,
59	const AttributeListType& atts,	59	const AttributeListType& atts,
60	int lineNumber,	60	XalanFileLoc lineNumber,
61	int columnNumber);	61	XalanFileLoc columnNumber);
62		62
63		63
64		64
Lines 76-82 Link Here
76	execute(StylesheetExecutionContext& executionContext) const;	76	execute(StylesheetExecutionContext& executionContext) const;
77	#endif	77	#endif
78	virtual const XPath*	78	virtual const XPath*
79	getXPath(unsigned int index = 0) const;	79	getXPath(XalanSize_t index) const;
80		80
81	private:	81	private:
82		82




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ParentType(
        constructionContext,
        stylesheetTree,

        StylesheetConstructionContext::ELEMNAME_APPLY_TEMPLATES),
    m_mode(0)
{
    const XalanSize_t  nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);


Lines 57-63 Link Here

(-)src/xalanc/XSLT/XalanElemAttributeSetAllocator.hpp (-3 / +5 lines)
57	*	57	*
58	* @param theBlockSize The block size.	58	* @param theBlockSize The block size.
59	*/	59	*/
60	XalanElemAttributeSetAllocator(MemoryManagerType& theManager, size_type theBlockCount);	60	XalanElemAttributeSetAllocator(
		61	MemoryManagerType& theManager,
		62	size_type theBlockCount);
61		63
62	~XalanElemAttributeSetAllocator();	64	~XalanElemAttributeSetAllocator();
63		65
Lines 77-84 Link Here
77	StylesheetConstructionContext& constructionContext,	79	StylesheetConstructionContext& constructionContext,
78	Stylesheet& stylesheetTree,	80	Stylesheet& stylesheetTree,
79	const AttributeListType& atts,	81	const AttributeListType& atts,
80	int lineNumber,	82	XalanFileLoc lineNumber,
81	int columnNumber);	83	XalanFileLoc columnNumber);
82		84
83	/**	85	/**
84	* Determine if an object is owned by the allocator...	86	* Determine if an object is owned by the allocator...

Lines 56-61 Link Here

(-)src/xalanc/XSLT/StylesheetExecutionContext.hpp (-11 / +10 lines)
56		56
57		57
58	#include <xalanc/PlatformSupport/AttributeListImpl.hpp>	58	#include <xalanc/PlatformSupport/AttributeListImpl.hpp>
		59	#include <xalanc/PlatformSupport/FormatterListener.hpp>
59	#include <xalanc/PlatformSupport/XalanCollationServices.hpp>	60	#include <xalanc/PlatformSupport/XalanCollationServices.hpp>
60		61
61		62
Lines 105-116 Link Here
105	{	106	{
106	public:	107	public:
107		108
108	#if defined(XALAN_STRICT_ANSI_HEADERS)	109	typedef XalanSize_t tl_size_type;
109	typedef std::size_t tl_size_type;
110	#else
111	typedef size_t tl_size_type;
112	#endif
113		110
		111	typedef FormatterListener::size_type fl_size_type;
		112
114	#if defined(XALAN_NO_STD_NAMESPACE)	113	#if defined(XALAN_NO_STD_NAMESPACE)
115	typedef ostream StreamType;	114	typedef ostream StreamType;
116	#else	115	#else
Lines 1069-1077 Link Here
1069	*/	1068	*/
1070	virtual void	1069	virtual void
1071	characters(	1070	characters(
1072	const XalanDOMChar* ch,	1071	const XalanDOMChar* ch,
1073	XalanDOMString::size_type start,	1072	fl_size_type start,
1074	XalanDOMString::size_type length) = 0;	1073	fl_size_type length) = 0;
1075		1074
1076	/**	1075	/**
1077	* Receive notification of character data. If available, when the	1076	* Receive notification of character data. If available, when the
Lines 1084-1092 Link Here
1084	*/	1083	*/
1085	virtual void	1084	virtual void
1086	charactersRaw(	1085	charactersRaw(
1087	const XalanDOMChar* ch,	1086	const XalanDOMChar* ch,
1088	XalanDOMString::size_type start,	1087	fl_size_type start,
1089	XalanDOMString::size_type length) = 0;	1088	fl_size_type length) = 0;
1090		1089
1091	/**	1090	/**
1092	* Called when a Comment is to be constructed.	1091	* Called when a Comment is to be constructed.




ElemTemplateElement::ElemTemplateElement(
            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber,
            int                             xslToken) :
    PrefixResolver(),
    m_stylesheet(stylesheetTree),

            Stylesheet&                     stylesheetTree,
            int                             xslToken,
            const XalanDOMString&           baseURI,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    PrefixResolver(),
    m_stylesheet(stylesheetTree),
    m_namespacesHandler(constructionContext.getMemoryManager()),

ElemTemplateElement::isAttrOK(
            const XalanDOMChar*             attrName,
            const AttributeListType&        atts,
            XalanSize_t                     which,
            StylesheetConstructionContext&  constructionContext) const
{
    return m_stylesheet.isAttrOK(attrName, atts, which, constructionContext);

            const XalanDOMChar*             elementName, 
            const XalanDOMChar*             aname, 
            const AttributeListType&        atts,
            XalanSize_t                     which,
            StylesheetConstructionContext&  constructionContext)
{
    if(constructionContext.isXMLSpaceAttribute(



const XPath*
ElemTemplateElement::getXPath(XalanSize_t   /* index */) const
{
    return 0;
}



#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
const ElemTemplateElement*
ElemTemplateElement::findTemplateToTransformChild(



ElemTemplateElement::LocatorProxy::LocatorProxy(
            XMLFileLoc              theLineNumber,
            XMLFileLoc              theColumnNumber,
            const XalanDOMString&   theURI) :
    m_lineNumber(theLineNumber),
    m_columnNumber(theColumnNumber),




XMLFileLoc
ElemTemplateElement::LocatorProxy::getLineNumber() const
{
    return m_lineNumber;




XMLFileLoc
ElemTemplateElement::LocatorProxy::getColumnNumber() const
{
    return m_columnNumber;




    XPath*                  matchAttr = 0;
    XPath*                  useAttr = 0;
 
    const XalanSize_t   nAttrs = atts.getLength();

    for(XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);


        }
    }

    if (0 == theQName)
    {
        const GetAndReleaseCachedString     theGuard(constructionContext);


            locator);
    }

    if (0 == matchAttr)
    {
        const GetAndReleaseCachedString     theGuard(constructionContext);


            locator);
    }

    if (0 == useAttr)
    {
        const GetAndReleaseCachedString     theGuard(constructionContext);


void
Stylesheet::pushNamespaces(const AttributeListType&     atts)
{
    const XalanSize_t       nAttrs = atts.getLength();

    NamespaceVectorType     namespaces(getMemoryManager());

    XalanDOMString          prefix(getMemoryManager());

    for(XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);
        const XalanDOMChar* const   value = atts.getValue(i);

            Stylesheet::PatternTableVectorType&     theList,
            const XalanMatchPatternData*            thePattern)
{

    typedef Stylesheet::size_type   size_type;
    assert(thePattern != 0);

    const double        thePatternPriority = thePattern->getPriorityOrDefault();
    const XalanSize_t   thePatternPosition = thePattern->getPosition();

    typedef Stylesheet::PatternTableVectorType  PatternTableListType;
    typedef PatternTableListType::iterator      iterator;


    const iterator  theEnd = theList.end();

    while (theCurrent != theEnd)
    {
        const double    theCurrentPriority = (*theCurrent)->getPriorityOrDefault();


Stylesheet::isAttrOK(
            const XalanDOMChar*             attrName,
            const AttributeListType&        /* atts */,
            XalanSize_t                     /* which */,
            StylesheetConstructionContext&  constructionContext) const
{
    // Namespace declarations are OK by definition

            const AttributeListType&        atts,
            StylesheetConstructionContext&  constructionContext)
{
    const XalanSize_t       nAttrs = atts.getLength();

    const XalanDOMString*   stylesheetNamespace = 0;
    const XalanDOMString*   resultNamespace = 0;

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_STYLESHEET_PREFIX) == true)
        {
            const XalanDOMChar* const   value = atts.getValue(i);


                stylesheetNamespace = getNamespaceForPrefix(value, constructionContext);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_RESULT_PREFIX))
        {
            const XalanDOMChar* const   value = atts.getValue(i);


                resultNamespace = getNamespaceForPrefix(value, constructionContext);
            }
        }
        else if (!isAttrOK(aname, atts, i, constructionContext))
        {
            const GetAndReleaseCachedString     theGuard(constructionContext);


            const AttributeListType&        atts,
            const LocatorType*              locator)
{
    const XalanFileLoc  lineNumber =
        XalanLocator::getLineNumber(locator);

    const XalanFileLoc  columnNumber =
        XalanLocator::getColumnNumber(locator);

    m_elemDecimalFormats.reserve(m_elemDecimalFormats.size() + 1);

Lines 48-55 Link Here

(-)src/xalanc/XSLT/ElemUse.cpp (-3 / +3 lines)
48	ElemUse::ElemUse(	48	ElemUse::ElemUse(
49	StylesheetConstructionContext& constructionContext,	49	StylesheetConstructionContext& constructionContext,
50	Stylesheet& stylesheetTree,	50	Stylesheet& stylesheetTree,
51	int lineNumber,	51	XalanFileLoc lineNumber,
52	int columnNumber,	52	XalanFileLoc columnNumber,
53	int xslToken) :	53	int xslToken) :
54	ElemTemplateElement(constructionContext,	54	ElemTemplateElement(constructionContext,
55	stylesheetTree,	55	stylesheetTree,
Lines 268-274 Link Here
268	StylesheetConstructionContext& constructionContext,	268	StylesheetConstructionContext& constructionContext,
269	const XalanDOMChar* attrName,	269	const XalanDOMChar* attrName,
270	const AttributeListType& atts,	270	const AttributeListType& atts,
271	int which)	271	XalanSize_t which)
272	{	272	{
273	bool isUAS = false;	273	bool isUAS = false;
274		274




    void
    characters(
                const XMLCh* const  chars,
                const size_type     length)
    {
        m_executionContext.characters(chars, 0, length);
    }

    void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length)
    {
        m_executionContext.charactersRaw(chars, 0, length);
    }

    void
    ignorableWhitespace(
                const XMLCh* const  /* chars */,
                const size_type     /* length */)
    {
    }


    void
    cdata(
                const XMLCh* const  /* ch */,
                const size_type     /* length */)
    {
    }





            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemUse(constructionContext,
            stylesheetTree,
            lineNumber,
            columnNumber,
            StylesheetConstructionContext::ELEMNAME_COPY)
{
    const XalanSize_t   nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (processUseAttributeSets(
                constructionContext,
                aname,
                atts,
                i) == false &&
            processSpaceAttr(
                Constants::ELEMNAME_COPY_WITH_PREFIX_STRING.c_str(),
                aname,
                atts,
                i,
                constructionContext) == false &&
            isAttrOK(
                aname,
                atts,
                i,

}



#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
const ElemTemplateElement*
ElemCopy::startElement(StylesheetExecutionContext&  executionContext) const

            executionContext.copyNamespaceAttributes(*sourceNode);

            return beginExecuteChildren(executionContext);

        }
        else
        {




	getURLFromString(const XalanDOMString&	urlString);

	virtual XalanDOMString&
	getURLStringFromString(
            const XalanDOMString&	urlString,
            XalanDOMString&         theResult);

	virtual URLAutoPtrType
	getURLFromString(


	static const ElementTokenTableEntry		s_elementTokenTable[];

	static const XalanSize_t				s_elementTokenTableSize;

	static const ElementTokenTableEntry&	s_elementTokenTableLast;






    virtual void
    characters(
            const XalanDOMChar*     ch,
            fl_size_type            start,
            fl_size_type            length);

    virtual void
    charactersRaw(
            const XalanDOMChar*     ch,
            fl_size_type            start,
            fl_size_type            length);

    virtual void
    comment(const XalanDOMChar*     data);

    endCreateXResultTreeFrag();

    virtual void
    beginFormatToText(XalanDOMString&   theResult);
            XalanDOMString&             theResult);

    virtual void
    endFormatToText();




			StylesheetConstructionContext&	constructionContext,
			Stylesheet&						stylesheetTree,
			const AttributeListType&		atts,
			XalanFileLoc					lineNumber,
			XalanFileLoc					columnNumber);

    static ElemSort*
	create(

			StylesheetConstructionContext&	constructionContext,
			Stylesheet&						stylesheetTree,
			const AttributeListType&		atts,
			XalanFileLoc					lineNumber,
			XalanFileLoc					columnNumber);

	~ElemSort();


	getElementName() const;

	virtual	const XPath*
	getXPath(XalanSize_t	index = 0) const;

private:


Lines 692-698 Link Here

(-)src/xalanc/XSLT/XSLTEngineImpl.cpp (-40 / +43 lines)
692	#if defined(XALAN_OLD_STYLE_CASTS)	692	#if defined(XALAN_OLD_STYLE_CASTS)
693	nsNode = (const XalanElement*)&fragBase;	693	nsNode = (const XalanElement*)&fragBase;
694	#else	694	#else
695	nsNode = static_cast<XalanElement*>(node);	695	nsNode = static_cast<const XalanElement*>(node);
696	#endif	696	#endif
697	}	697	}
698	else	698	else
Lines 1064-1072 Link Here
1064		1064
1065	XalanDOMString uri( theManager );	1065	XalanDOMString uri( theManager );
1066		1066
1067	int lineNumber = XalanLocator::getUnknownValue();	1067	XalanFileLoc lineNumber =
1068	int columnNumber = XalanLocator::getUnknownValue();	1068	XalanLocator::getUnknownValue();
1069		1069
		1070	XalanFileLoc columnNumber =
		1071	XalanLocator::getUnknownValue();
		1072
1070	const LocatorType* locator = getLocatorFromStack();	1073	const LocatorType* locator = getLocatorFromStack();
1071		1074
1072	if (locator == 0 && styleNode != 0)	1075	if (locator == 0 && styleNode != 0)
Lines 1136-1143 Link Here
1136	id = &theDummy;	1139	id = &theDummy;
1137	}	1140	}
1138		1141
1139	const XalanLocator::size_type lineNumber = locator.getLineNumber();	1142	XalanFileLoc lineNumber = locator.getLineNumber();
1140	const XalanLocator::size_type columnNumber = locator.getColumnNumber();	1143	XalanFileLoc columnNumber = locator.getColumnNumber();
1141		1144
1142	if (m_problemListener != 0)	1145	if (m_problemListener != 0)
1143	{	1146	{
Lines 1364-1375 Link Here
1364		1367
1365	void	1368	void
1366	XSLTEngineImpl::addResultAttribute(	1369	XSLTEngineImpl::addResultAttribute(
1367	AttributeListImpl& attList,	1370	AttributeListImpl& attList,
1368	const XalanDOMString& aname,	1371	const XalanDOMString& aname,
1369	const XalanDOMChar* value,	1372	const XalanDOMChar* value,
1370	XalanDOMString::size_type theLength,	1373	size_type theLength,
1371	bool fromCopy,	1374	bool fromCopy,
1372	const LocatorType* locator)	1375	const LocatorType* locator)
1373	{	1376	{
1374	assert(value != 0);	1377	assert(value != 0);
1375		1378
Lines 1517-1529 Link Here
1517	const AttributeListImpl& thePendingAttributes =	1520	const AttributeListImpl& thePendingAttributes =
1518	(const AttributeListImpl&)getPendingAttributes();	1521	(const AttributeListImpl&)getPendingAttributes();
1519		1522
1520	const unsigned int n = thePendingAttributes.getLength();	1523	const XalanSize_t n = thePendingAttributes.getLength();
1521		1524
1522	for(unsigned int i = 0; i < n; i++)	1525	for (XalanSize_t i = 0; i < n; i++)
1523	{	1526	{
1524	if(equals(	1527	if (equals(
1525	thePendingAttributes.getName(i),	1528	thePendingAttributes.getName(i),
1526	DOMServices::s_XMLNamespace) == true)	1529	DOMServices::s_XMLNamespace) == true)
1527	{	1530	{
1528	return true;	1531	return true;
1529	}	1532	}
Lines 1650-1656 Link Here
1650		1653
1651	flushPending();	1654	flushPending();
1652		1655
1653	const unsigned int nAtts = atts.getLength();	1656	const XalanSize_t nAtts = atts.getLength();
1654		1657
1655	assert(m_outputContextStack.empty() == false);	1658	assert(m_outputContextStack.empty() == false);
1656		1659
Lines 1659-1665 Link Here
1659		1662
1660	thePendingAttributes.clear();	1663	thePendingAttributes.clear();
1661		1664
1662	for(unsigned int i = 0; i < nAtts; i++)	1665	for (XalanSize_t i = 0; i < nAtts; i++)
1663	{	1666	{
1664	thePendingAttributes.addAttribute(	1667	thePendingAttributes.addAttribute(
1665	atts.getName(i),	1668	atts.getName(i),
Lines 1708-1715 Link Here
1708		1711
1709	void	1712	void
1710	XSLTEngineImpl::characters(	1713	XSLTEngineImpl::characters(
1711	const XalanDOMChar* ch,	1714	const XalanDOMChar* ch,
1712	XalanDOMString::size_type length)	1715	size_type length)
1713	{	1716	{
1714	characters(	1717	characters(
1715	ch,	1718	ch,
Lines 1721-1729 Link Here
1721		1724
1722	void	1725	void
1723	XSLTEngineImpl::characters(	1726	XSLTEngineImpl::characters(
1724	const XalanDOMChar* ch,	1727	const XalanDOMChar* ch,
1725	XalanDOMString::size_type start,	1728	size_type start,
1726	XalanDOMString::size_type length)	1729	size_type length)
1727	{	1730	{
1728	assert(getFormatterListenerImpl() != 0);	1731	assert(getFormatterListenerImpl() != 0);
1729	assert(ch != 0);	1732	assert(ch != 0);
Lines 1732-1742 Link Here
1732		1735
1733	doFlushPending();	1736	doFlushPending();
1734		1737
1735	if(generateCDATASection() == true)	1738	if (generateCDATASection() == true)
1736	{	1739	{
1737	getFormatterListenerImpl()->cdata(ch + start, length);	1740	getFormatterListenerImpl()->cdata(ch + start, length);
1738		1741
1739	if(getTraceListeners() > 0)	1742	if (getTraceListeners() > 0)
1740	{	1743	{
1741	fireCharacterGenerateEvent(ch, start, length, true);	1744	fireCharacterGenerateEvent(ch, start, length, true);
1742	}	1745	}
Lines 1745-1751 Link Here
1745	{	1748	{
1746	getFormatterListenerImpl()->characters(ch + start, length);	1749	getFormatterListenerImpl()->characters(ch + start, length);
1747		1750
1748	if(getTraceListeners() > 0)	1751	if (getTraceListeners() > 0)
1749	{	1752	{
1750	fireCharacterGenerateEvent(ch, start, length, false);	1753	fireCharacterGenerateEvent(ch, start, length, false);
1751	}	1754	}
Lines 1817-1825 Link Here
1817		1820
1818	void	1821	void
1819	XSLTEngineImpl::charactersRaw(	1822	XSLTEngineImpl::charactersRaw(
1820	const XalanDOMChar* ch,	1823	const XalanDOMChar* ch,
1821	XalanDOMString::size_type start,	1824	size_type start,
1822	XalanDOMString::size_type length)	1825	size_type length)
1823	{	1826	{
1824	assert(ch != 0);	1827	assert(ch != 0);
1825	assert(length != 0);	1828	assert(length != 0);
Lines 1880-1887 Link Here
1880		1883
1881	void	1884	void
1882	XSLTEngineImpl::ignorableWhitespace(	1885	XSLTEngineImpl::ignorableWhitespace(
1883	const XalanDOMChar* ch,	1886	const XalanDOMChar* ch,
1884	XalanDOMString::size_type length)	1887	size_type length)
1885	{	1888	{
1886	assert(getFormatterListenerImpl() != 0);	1889	assert(getFormatterListenerImpl() != 0);
1887	assert(ch != 0);	1890	assert(ch != 0);
Lines 1973-1981 Link Here
1973		1976
1974	void	1977	void
1975	XSLTEngineImpl::cdata(	1978	XSLTEngineImpl::cdata(
1976	const XalanDOMChar* ch,	1979	const XalanDOMChar* ch,
1977	XalanDOMString::size_type start,	1980	size_type start,
1978	XalanDOMString::size_type length)	1981	size_type length)
1979	{	1982	{
1980	assert(getFormatterListenerImpl() != 0);	1983	assert(getFormatterListenerImpl() != 0);
1981	assert(ch != 0);	1984	assert(ch != 0);
Lines 2716-2722 Link Here
2716	const XalanDOMString& thePrefix,	2719	const XalanDOMString& thePrefix,
2717	XalanDOMString::size_type thePrefixLength)	2720	XalanDOMString::size_type thePrefixLength)
2718	{	2721	{
2719	const unsigned int thePendingAttributesCount =	2722	const XalanSize_t thePendingAttributesCount =
2720	thePendingAttributes.getLength();	2723	thePendingAttributes.getLength();
2721		2724
2722	if (thePendingAttributesCount == 0)	2725	if (thePendingAttributesCount == 0)
Lines 2729-2735 Link Here
2729	bool fResult = false;	2732	bool fResult = false;
2730		2733
2731	// Check each attribute...	2734	// Check each attribute...
2732	for (unsigned int i = 0; i < thePendingAttributesCount; ++i)	2735	for (XalanSize_t i = 0; i < thePendingAttributesCount; ++i)
2733	{	2736	{
2734	const XalanDOMChar* const thePendingAttributeName =	2737	const XalanDOMChar* const thePendingAttributeName =
2735	thePendingAttributes.getName(i);	2738	thePendingAttributes.getName(i);
Lines 3141-3150 Link Here
3141		3144
3142	void	3145	void
3143	XSLTEngineImpl::fireCharacterGenerateEvent(	3146	XSLTEngineImpl::fireCharacterGenerateEvent(
3144	const XalanDOMChar* ch,	3147	const XalanDOMChar* ch,
3145	XalanDOMString::size_type start,	3148	size_type start,
3146	XalanDOMString::size_type length,	3149	size_type length,
3147	bool isCDATA)	3150	bool isCDATA)
3148	{	3151	{
3149	const GenerateEvent ge(	3152	const GenerateEvent ge(
3150	isCDATA == true ? GenerateEvent::EVENTTYPE_CDATA : GenerateEvent::EVENTTYPE_CHARACTERS,	3153	isCDATA == true ? GenerateEvent::EVENTTYPE_CDATA : GenerateEvent::EVENTTYPE_CHARACTERS,

Lines 38-44 Link Here

(-)src/xalanc/XSLT/DecimalToRoman.hpp (-1 / +1 lines)
38	{	38	{
39	enum { eMaxLetter = 2 };	39	enum { eMaxLetter = 2 };
40		40
41	typedef unsigned long ValueType;	41	typedef XalanSize_t ValueType;
42		42
43	ValueType m_postValue;	43	ValueType m_postValue;
44		44




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,

    m_sortElems(constructionContext.getMemoryManager()),
    m_sortElemsCount(0)
{
    const XalanSize_t  nAttrs = atts.getLength();
        
    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_SELECT))
        {
            m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
        }
        else if (isAttrOK(
                    aname,
                    atts,
                    i,

        }
    }

    if (0 == m_selectPattern)
    {
        error(
            constructionContext,

ElemForEach::ElemForEach(
            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber,
            int                             xslToken) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,

            const AttributeListType&        atts,
            const LocatorType*              locator)
{
    const XalanFileLoc  lineNumber = XalanLocator::getLineNumber(locator);
    const XalanFileLoc  columnNumber = XalanLocator::getColumnNumber(locator);

    m_sortElems.reserve(m_sortElems.size() + 1);




const XPath*
ElemForEach::getXPath(XalanSize_t   index) const
{
    return index == 0 ? m_selectPattern : 0;
}

Lines 50-60 Link Here

(-)src/xalanc/XSLT/ElemApplyTemplates.hpp (-5 / +5 lines)
50	* @param columnNumber column number in document	50	* @param columnNumber column number in document
51	*/	51	*/
52	ElemApplyTemplates(	52	ElemApplyTemplates(
53	StylesheetConstructionContext& constructionContext,	53	StylesheetConstructionContext& constructionContext,
54	Stylesheet& stylesheetTree,	54	Stylesheet& stylesheetTree,
55	const AttributeListType& atts,	55	const AttributeListType& atts,
56	int lineNumber,	56	XalanFileLoc lineNumber,
57	int columnNumber);	57	XalanFileLoc columnNumber);
58		58
59	virtual	59	virtual
60	~ElemApplyTemplates();	60	~ElemApplyTemplates();




void
StylesheetHandler::characters(
            const XMLCh* const  chars,
            const size_type     length)
{
    if (m_inTemplate == false &&
        inExtensionElement() == false &&

void
StylesheetHandler::cdata(
            const XMLCh* const  chars,
            const size_type     length)
{
    accumulateText(chars, length);


void
StylesheetHandler::ignorableWhitespace(
            const XMLCh* const  /*chars*/,
            const size_type     /*length*/)
{
    // Ignore!
    m_lastPopped = 0;

void
StylesheetHandler::charactersRaw(
            const XMLCh* const  /* chars */,
            const size_type     /* length */)
{
}



void
StylesheetHandler::processText(
            const XMLCh*    chars,
            size_type       length)
{
    if(m_inTemplate)
    {


void
StylesheetHandler::accumulateText(
            const XMLCh*    chars,
            size_type       length)
{   
    if(m_inTemplate)
    {




    ElemTemplateElement(
            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber,
            int                             xslToken);

    /**

            Stylesheet&                     stylesheetTree,
            int                             xslToken,
            const XalanDOMString&           baseURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            XalanFileLoc                    lineNumber = XalanLocator::getUnknownValue(),
            XalanFileLoc                    columnNumber = XalanLocator::getUnknownValue());

    virtual
    ~ElemTemplateElement();

    isAttrOK(
            const XalanDOMChar*             attrName,
            const AttributeListType&        atts,
            XalanSize_t                     which,
            StylesheetConstructionContext&  constructionContext) const;

    /** 

            const XalanDOMChar*             elementName,
            const XalanDOMChar*             aname,
            const AttributeListType&        atts,
            XalanSize_t                     which,
            StylesheetConstructionContext&  constructionContext);

    /** 

     * @return pointer or null 
     */
    virtual const XPath*
    getXPath(XalanSize_t    index) const;

    // These interfaces are inherited from PrefixResolver...


    public:

        LocatorProxy(
                    XMLFileLoc              theLineNumber,
                    XMLFileLoc              theColumnNumber,
                    const XalanDOMString&   theURI);

        virtual

        virtual const XMLCh*
        getSystemId() const;

        virtual XMLFileLoc
        getLineNumber() const;

        virtual XMLFileLoc
        getColumnNumber() const;

        const XalanDOMString&

        operator==(const LocatorProxy&) const;

        // data members...
        const XMLFileLoc        m_lineNumber;

        const XMLFileLoc        m_columnNumber;

        const XalanDOMString&   m_uri;
    };


    XMLFileLoc
    getLineNumber() const
    {
        return m_locatorProxy.getLineNumber();
    }

    XMLFileLoc
    getColumnNumber() const
    {
        return m_locatorProxy.getColumnNumber();





public:

    typedef StylesheetConstructionContext::size_type        size_type;
	typedef StylesheetExecutionContext::ParamVectorType		ParamVectorType;
	typedef XalanQName::NamespaceVectorType					NamespaceVectorType;
	typedef XalanQName::NamespacesStackType					NamespacesStackType;

	isAttrOK(
			const XalanDOMChar*				attrName,
			const AttributeListType&		atts,
			XalanSize_t						which,
			StylesheetConstructionContext&	constructionContext) const;

	/**

	 * @return namespace string for node, or null if not found.
	 */
	const XalanDOMString*
    getNamespaceFromStack(
                const XalanDOMString&   nodeName,
                XalanDOMString&         theBuffer) const
	{
		return getNamespaceFromStack(c_wstr(nodeName), theBuffer);
	}

	 * @return namespace string for node, or null if not found.
	 */
	const XalanDOMString*
    getNamespaceFromStack(
                const XalanDOMChar*     nodeName,
                XalanDOMString&         theBuffer) const;

	/**
	 * Get the namespace from a prefix by searching the stack of namespace

Lines 56-63 Link Here

(-)src/xalanc/XSLT/ElemUse.hpp (-3 / +3 lines)
56	ElemUse(	56	ElemUse(
57	StylesheetConstructionContext& constructionContext,	57	StylesheetConstructionContext& constructionContext,
58	Stylesheet& stylesheetTree,	58	Stylesheet& stylesheetTree,
59	int lineNumber,	59	XalanFileLoc lineNumber,
60	int columnNumber,	60	XalanFileLoc columnNumber,
61	int xslToken);	61	int xslToken);
62		62
63	virtual	63	virtual
Lines 77-83 Link Here
77	StylesheetConstructionContext& constructionContext,	77	StylesheetConstructionContext& constructionContext,
78	const XalanDOMChar* attrName,	78	const XalanDOMChar* attrName,
79	const AttributeListType& atts,	79	const AttributeListType& atts,
80	int which);	80	XalanSize_t which);
81		81
82	// These methods are inherited from ElemTemplateElement ...	82	// These methods are inherited from ElemTemplateElement ...
83		83




    m_templateName(0),
    m_template(0)
{
    const XalanSize_t  nAttrs = atts.getLength();

    for(XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_NAME))
        {
            m_templateName = constructionContext.createXalanQName(
                    atts.getValue(i),

                    atts.getValue(i));
            }
        }
        else if (isAttrOK(
                    aname,
                    atts,
                    i,

Lines 55-61 Link Here

(-)src/xalanc/XSLT/CountersTable.hpp (-1 / +1 lines)
55	*/	55	*/
56	struct Counter	56	struct Counter
57	{	57	{
58	typedef unsigned long CountType;	58	typedef XalanSize_t CountType;
59		59
60	typedef XalanVector<XalanNode*> NodeVectorType;	60	typedef XalanVector<XalanNode*> NodeVectorType;
61		61

Lines 49-56 Link Here

(-)src/xalanc/XSLT/ElemCopy.hpp (-2 / +2 lines)
49	StylesheetConstructionContext& constructionContext,	49	StylesheetConstructionContext& constructionContext,
50	Stylesheet& stylesheetTree,	50	Stylesheet& stylesheetTree,
51	const AttributeListType& atts,	51	const AttributeListType& atts,
52	int lineNumber,	52	XalanFileLoc lineNumber,
53	int columnNumber);	53	XalanFileLoc columnNumber);
54		54
55	// These methods are inherited from ElemTemplateElement ...	55	// These methods are inherited from ElemTemplateElement ...
56		56




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,
                        columnNumber,
                        StylesheetConstructionContext::ELEMNAME_CHOOSE)
{
    const XalanSize_t   nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (isAttrOK(
                aname,
                atts,
                i,
                constructionContext) == false &&
            processSpaceAttr(
                Constants::ELEMNAME_CHOOSE_WITH_PREFIX_STRING.c_str(),
                aname,
                atts,

    {
        const int   type = node->getXSLToken();

        if (StylesheetConstructionContext::ELEMNAME_WHEN == type)
        {

            const XPath* const      theXPath = node->getXPath(0);
            assert(theXPath != 0);

            bool    test;

            theXPath->execute(*this, executionContext, test);

            if (0 != executionContext.getTraceListeners())
            {
                executionContext.fireSelectEvent(
                    SelectionEvent(executionContext,

        if(StylesheetConstructionContext::ELEMNAME_WHEN == type)
        {

            const XPath* const      theXPath = node->getXPath(0);
            assert(theXPath != 0);

            bool    test;




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber, 
            XalanFileLoc                    columnNumber) :
        ElemTemplateElement(constructionContext,
                            stylesheetTree,
                            lineNumber,
                            columnNumber,
                            StylesheetConstructionContext::ELEMNAME_APPLY_IMPORTS)
{
    const XalanSize_t  nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (isAttrOK(
                aname,
                atts,
                i,




			const XPath&				matchPattern,
			const XPath&				use,
			const XalanDOMString&		uri,
			XMLFileLoc		            lineNumber,
			XMLFileLoc		            columnNumber) :
		m_qname(&qname),
		m_match(&matchPattern),
		m_use(&use),

	 *
	 * @return The line number
	 */
	XMLFileLoc
	getLineNumber() const
	{
		return m_lineNumber;

	 *
	 * @return The column number
	 */
	XMLFileLoc
	getColumnNumber() const
	{
		return m_columnNumber;


	const XalanDOMString*		m_uri;

	XMLFileLoc		            m_lineNumber;

	XMLFileLoc                  m_columnNumber;
};






            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,

    m_nameAVT(0),   
    m_namespaceAVT(0)
{
    const XalanSize_t   nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);


    }

    executionContext.getAndPopCachedString();

    return 0;
}





	addResultNamespaceDecl(
			const XalanDOMString&		prefix, 
			const XalanDOMChar*			namespaceVal,
			size_type					len)
	{
		m_resultNamespacesStack.addDeclaration(
			prefix,

     * @param theLength The length of the value
     * @param fromCopy true if the attribute is being copied from the source tree
     * @param locator The Locator for reporting errors.
     */
    void
    addResultAttribute(
            AttributeListImpl&      attList,
            const XalanDOMString&   aname,
            const XalanDOMChar*     value,
            size_type               theLength,
            bool                    fromCopy = false,
            const LocatorType*      locator = 0);

	/**
	 * Add attribute to pending attributes list, and if it is a namespace, add

	void
	endElement(const XalanDOMChar*	name);

    void
    characters (
            const XalanDOMChar*     ch,
            size_type               length);

    void
    ignorableWhitespace(
            const XalanDOMChar*     ch,
            size_type               length);

	void
	processingInstruction(

	void
	resetDocument();

    /**
     * Receive notification of character data.
     *
     * @param ch     pointer to characters from the XML document
     * @param start  startng offset in 'ch' array
     * @param length number of characters to read from the array 
     */
    void
    characters(
            const XalanDOMChar*     ch,
            size_type               start,
            size_type               length);

	/**
	 * Send character data from the node to the result tree.

	void
	startElement(const XalanDOMChar*	name);

    /**
     * Receive notification of character data. If available, when the
     * disable-output-escaping attribute is used, output raw text without
     * escaping.
     *
     * @param ch pointer to characters from the XML document
     * @param start start position in the array
     * @param length number of characters to read from the array
     */
    void
    charactersRaw(
            const XalanDOMChar*     ch,
            size_type               start,
            size_type               length);

	/**
	 * Send raw character data from the node to the result tree.

	void
	entityReference(const XalanDOMChar*		data);

    /**
     * Receive notification of cdata.
     *
     * @param ch     pointer to characters from the XML document
     * @param start  start position in the array
     * @param length number of characters to read from the array
     */
    void
    cdata(
            const XalanDOMChar*     ch,
            size_type               start,
            size_type               length);

	/**
	 * Clone a node to the result tree

			const XalanDOMString&	theString,
			bool					isCDATA);

    void
    fireCharacterGenerateEvent(
            const XalanDOMChar*     ch,
            size_type               start,
            size_type               length,
            bool                    isCDATA);

	void
	checkDefaultNamespace(




	 * @param columnNumber			column number in document
	 */
	ElemForEach(
			StylesheetConstructionContext&  constructionContext,
			Stylesheet&                     stylesheetTree,
			const AttributeListType&        atts,
			XalanFileLoc                    lineNumber,
			XalanFileLoc                    columnNumber);

	virtual
	~ElemForEach();

#endif
	
	virtual	const XPath*
	getXPath(XalanSize_t    index) const;

protected:


	 * @param xslToken             an integer representing the type of instance.
	 */
	ElemForEach(
			StylesheetConstructionContext&  constructionContext,
			Stylesheet&                     stylesheetTree,
			XalanFileLoc                    lineNumber,
			XalanFileLoc                    columnNumber,
			int                             xslToken);

#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)


Lines 23-29 Link Here

(-)src/xalanc/XSLT/XalanElemElementAllocator.cpp (-3 / +5 lines)
23		23
24		24
25		25
26	XalanElemElementAllocator::XalanElemElementAllocator(MemoryManagerType& theManager, size_type theBlockCount) :	26	XalanElemElementAllocator::XalanElemElementAllocator(
		27	MemoryManagerType& theManager,
		28	size_type theBlockCount) :
27	m_allocator(theManager, theBlockCount)	29	m_allocator(theManager, theBlockCount)
28	{	30	{
29	}	31	}
Lines 41-48 Link Here
41	StylesheetConstructionContext& constructionContext,	43	StylesheetConstructionContext& constructionContext,
42	Stylesheet& stylesheetTree,	44	Stylesheet& stylesheetTree,
43	const AttributeListType& atts,	45	const AttributeListType& atts,
44	int lineNumber,	46	XalanFileLoc lineNumber,
45	int columnNumber)	47	XalanFileLoc columnNumber)
46	{	48	{
47	data_type* const theBlock = m_allocator.allocateBlock();	49	data_type* const theBlock = m_allocator.allocateBlock();
48	assert(theBlock != 0);	50	assert(theBlock != 0);

Lines 23-29 Link Here

(-)src/xalanc/XSLT/XalanElemAttributeAllocator.cpp (-3 / +5 lines)
23		23
24		24
25		25
26	XalanElemAttributeAllocator::XalanElemAttributeAllocator(MemoryManagerType& theManager, size_type theBlockCount) :	26	XalanElemAttributeAllocator::XalanElemAttributeAllocator(
		27	MemoryManagerType& theManager,
		28	size_type theBlockCount) :
27	m_allocator(theManager, theBlockCount)	29	m_allocator(theManager, theBlockCount)
28	{	30	{
29	}	31	}
Lines 41-48 Link Here
41	StylesheetConstructionContext& constructionContext,	43	StylesheetConstructionContext& constructionContext,
42	Stylesheet& stylesheetTree,	44	Stylesheet& stylesheetTree,
43	const AttributeListType& atts,	45	const AttributeListType& atts,
44	int lineNumber,	46	XalanFileLoc lineNumber,
45	int columnNumber)	47	XalanFileLoc columnNumber)
46	{	48	{
47	data_type* const theBlock = m_allocator.allocateBlock();	49	data_type* const theBlock = m_allocator.allocateBlock();
48	assert(theBlock != 0);	50	assert(theBlock != 0);

Lines 129-135 Link Here

(-)src/xalanc/XSLT/StylesheetHandler.hpp (-8 / +20 lines)
129	* @see #ignorableWhitespace	129	* @see #ignorableWhitespace
130	* @see org.xml.sax.Locator	130	* @see org.xml.sax.Locator
131	*/	131	*/
132	virtual void characters (const XMLCh* const chars, const unsigned int length);	132	virtual void
		133	characters(
		134	const XMLCh* const chars,
		135	const size_type length);
133		136
134	/**	137	/**
135	* Receive notification of character data. If available, when the	138	* Receive notification of character data. If available, when the
Lines 141-147 Link Here
141	* @param length number of characters to read from the array	144	* @param length number of characters to read from the array
142	* @exception SAXException	145	* @exception SAXException
143	*/	146	*/
144	virtual void charactersRaw(const XMLCh* const chars, const unsigned int length);	147	virtual void
		148	charactersRaw(
		149	const XMLCh* const chars,
		150	const size_type length);
145		151
146	/**	152	/**
147	* Receive notification of cdata.	153	* Receive notification of cdata.
Lines 166-172 Link Here
166	* @exception SAXException	172	* @exception SAXException
167	* @see #ignorableWhitespace	173	* @see #ignorableWhitespace
168	*/	174	*/
169	virtual void cdata(const XMLCh* const ch, const unsigned int length);	175	virtual void
		176	cdata(
		177	const XMLCh* const ch,
		178	const size_type length);
170		179
171	/**	180	/**
172	* Receive notification of ignorable whitespace in element content.	181	* Receive notification of ignorable whitespace in element content.
Lines 191-197 Link Here
191	* @exception SAXException	200	* @exception SAXException
192	* @see #characters	201	* @see #characters
193	*/	202	*/
194	virtual void ignorableWhitespace (const XMLCh* const chars, const unsigned int length);	203	virtual void
		204	ignorableWhitespace(
		205	const XMLCh* const chars,
		206	const size_type length);
195		207
196	/**	208	/**
197	* Receive notification of a processing instruction.	209	* Receive notification of a processing instruction.
Lines 467-479 Link Here
467		479
468	void	480	void
469	processText(	481	processText(
470	const XMLCh* chars,	482	const XMLCh* chars,
471	XalanDOMString::size_type length);	483	size_type length);
472		484
473	void	485	void
474	accumulateText(	486	accumulateText(
475	const XMLCh* chars,	487	const XMLCh* chars,
476	XalanDOMString::size_type length);	488	size_type length);
477		489
478	void	490	void
479	processAccumulatedText();	491	processAccumulatedText();




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemTemplateElement(constructionContext,
                        stylesheetTree,
                        lineNumber,

    m_decimalFormatSymbols.setInfinity(XalanDOMString(constructionContext.getMemoryManager()));
    m_decimalFormatSymbols.setNaN(XalanDOMString(constructionContext.getMemoryManager()));

    const XalanSize_t  nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const       aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_NAME))
        {
            assert(atts.getValue(i) != 0);


                    atts.getValue(i));
            }
        }
        else if (equals(aname, Constants::ATTRNAME_DECIMALSEPARATOR))
        {
            const XalanDOMChar* const   decimalSepValue = atts.getValue(i);
            assert(decimalSepValue != 0);

                    decimalSepValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_GROUPINGSEPARATOR))
        {
            const XalanDOMChar* const   sepValue = atts.getValue(i);
            assert(sepValue!= 0);

                    sepValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_INFINITY))
        {
            assert(atts.getValue(i) != 0);

            m_decimalFormatSymbols.setInfinity(atts.getValue(i));
        }
        else if (equals(aname, Constants::ATTRNAME_MINUSSIGN))
        {
            const XalanDOMChar* const   minusValue = atts.getValue(i);
            assert(minusValue != 0);

                    minusValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_NAN))
        {
            assert(atts.getValue(i) != 0);

            m_decimalFormatSymbols.setNaN(atts.getValue(i));
        }
        else if (equals(aname, Constants::ATTRNAME_PERCENT))
        {
            const XalanDOMChar* const   percentValue = atts.getValue(i);
            assert(percentValue != 0);

                    percentValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_PERMILLE))
        {
            const XalanDOMChar* const   permilleValue = atts.getValue(i);
            assert(permilleValue != 0);

                    permilleValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_ZERODIGIT))
        {
            const XalanDOMChar* const   zeroDigitValue = atts.getValue(i);
            assert(zeroDigitValue != 0);

                    zeroDigitValue);
            }
        }
        else if (equals(aname, Constants::ATTRNAME_DIGIT))
        {
            const XalanDOMChar* const   digitValue = atts.getValue(i);
            assert(digitValue != 0);



const XPath*
ElemDecimalFormat::getXPath(XalanSize_t index) const
{
    const XPath*    result = 0;





            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemUse(constructionContext,
            stylesheetTree,
            lineNumber,

            StylesheetConstructionContext::ELEMNAME_ATTRIBUTE_SET),
    m_qname(0)
{
    const XalanSize_t   nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);

        if (equals(aname, Constants::ATTRNAME_NAME))
        {
            m_qname = constructionContext.createXalanQName(
                atts.getValue(i),

                    atts.getValue(i));
            }
        }
        else if (processUseAttributeSets(
                    constructionContext,
                    aname,
                    atts,
                    i) == false &&
                 isAttrOK(
                    aname,
                    atts,
                    i,

        }
    }

    if (m_qname == 0)
    {
        error(
            constructionContext,

Lines 49-56 Link Here

(-)src/xalanc/XSLT/ElemChoose.hpp (-2 / +2 lines)
49	StylesheetConstructionContext& constructionContext,	49	StylesheetConstructionContext& constructionContext,
50	Stylesheet& stylesheetTree,	50	Stylesheet& stylesheetTree,
51	const AttributeListType& atts,	51	const AttributeListType& atts,
52	int lineNumber,	52	XalanFileLoc lineNumber,
53	int columnNumber);	53	XalanFileLoc columnNumber);
54		54
55		55
56	// These methods are inherited from ElemTemplateElement ...	56	// These methods are inherited from ElemTemplateElement ...

Lines 50-57 Link Here

(-)src/xalanc/XSLT/ElemApplyImport.hpp (-3 / +2 lines)
50	StylesheetConstructionContext& constructionContext,	50	StylesheetConstructionContext& constructionContext,
51	Stylesheet& stylesheetTree,	51	Stylesheet& stylesheetTree,
52	const AttributeListType& atts,	52	const AttributeListType& atts,
53	int lineNumber,	53	XalanFileLoc lineNumber,
54	int columnNumber);	54	XalanFileLoc columnNumber);
55		55
56		56
57	// These methods are inherited from ElemTemplateElement ...	57	// These methods are inherited from ElemTemplateElement ...
Lines 77-83 Link Here
77	virtual ElemTemplateElement*	77	virtual ElemTemplateElement*
78	appendChildElem(ElemTemplateElement* newChild);	78	appendChildElem(ElemTemplateElement* newChild);
79		79
80
81	private:	80	private:
82	};	81	};
83		82




            StylesheetConstructionContext&  constructionContext,
            Stylesheet&                     stylesheetTree,
            const AttributeListType&        atts,
            XalanFileLoc                    lineNumber,
            XalanFileLoc                    columnNumber) :
    ElemUse(constructionContext,
            stylesheetTree,
            lineNumber,

    // turn them off...
//  m_namespacesHandler.setProcessNamespaceAliaises(false);

    const XalanSize_t  nAttrs = atts.getLength();

    for (XalanSize_t i = 0; i < nAttrs; i++)
    {
        const XalanDOMChar* const   aname = atts.getName(i);


}



#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
const ElemTemplateElement*
ElemElement::startElement(StylesheetExecutionContext&       executionContext) const

Lines 23-29 Link Here

(-)src/xalanc/XSLT/XalanElemApplyTemplatesAllocator.cpp (-3 / +5 lines)
23		23
24		24
25		25
26	XalanElemApplyTemplatesAllocator::XalanElemApplyTemplatesAllocator(MemoryManagerType& theManager, size_type theBlockCount) :	26	XalanElemApplyTemplatesAllocator::XalanElemApplyTemplatesAllocator(
		27	MemoryManagerType& theManager,
		28	size_type theBlockCount) :
27	m_allocator(theManager, theBlockCount)	29	m_allocator(theManager, theBlockCount)
28	{	30	{
29	}	31	}
Lines 41-48 Link Here
41	StylesheetConstructionContext& constructionContext,	43	StylesheetConstructionContext& constructionContext,
42	Stylesheet& stylesheetTree,	44	Stylesheet& stylesheetTree,
43	const AttributeListType& atts,	45	const AttributeListType& atts,
44	int lineNumber,	46	XalanFileLoc lineNumber,
45	int columnNumber)	47	XalanFileLoc columnNumber)
46	{	48	{
47	data_type* const theBlock = m_allocator.allocateBlock();	49	data_type* const theBlock = m_allocator.allocateBlock();
48	assert(theBlock != 0);	50	assert(theBlock != 0);





#include <xalanc/Include/XalanVector.hpp>

#include <xalanc/PlatformSupport/FormatterListener.hpp>
#include <xalanc/PlatformSupport/Writer.hpp>


XALAN_CPP_NAMESPACE_BEGIN


template<
    class WhiteSpaceWriter,
    class NewLineWriter>
class XalanIndentWriter
{
public:
 
    typedef FormatterListener::size_type    size_type;
    typedef XalanVector<bool>               BoolStackType;
    typedef typename WhiteSpaceWriter::writer_type   writer_type;





    /**
     * Writes name chars , if not presentable, throws 
     */
    void
    writeNameChar(
            const XalanDOMChar*      data,
            size_type                theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes name chars, if not representable, throws 
     */
    void
    writePIChars(
            const XalanDOMChar*     data,
            size_type               theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes name chars, if not representable, throws 
     */
    void
    writeCommentChars(
            const XalanDOMChar*      data,
            size_type                theLength)
    {
        write(data, theLength);
    }

    void
    safeWriteContent(
            const XalanDOMChar*     theChars,
            size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        { 


    void
    write(
            const value_type*   theChars,
            size_type           theLength)
    {
    #if defined(NDEBUG)
        if (theLength > sizeof(m_buffer))

            m_bufferRemaining -= theLength;
        }
    #else
        for(size_type i = 0; i < theLength; ++i)
        {
            write(theChars[i]);
        }


    void
    write(
            const XalanDOMChar*     theChars,
            size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        {


    size_type
    write(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        XalanDOMChar ch = chars[start];

        if (isUTF16HighSurrogate(ch) == false)
        {
            write((unsigned int)ch);
        }

        {
            if (start + 1 >= length)
            {
                throwInvalidUTF16SurrogateException(
                    ch, 
                    0,
                    getMemoryManager());

            else 
            {
                write(
                    decodeUTF16SurrogatePair(
                        ch,
                        chars[++start],
                        getMemoryManager()));


    void
    writeSafe(
        const XalanDOMChar*     theChars,
        size_type               theLength)
    {
        XalanDOMChar ch = 0;


        {
            ch = theChars[i];

            if (isUTF16HighSurrogate(ch) == true)
            {
                if (i + 1 >= theLength)
                {
                    throwInvalidUTF16SurrogateException(ch, 0,  getMemoryManager());
                }
                else 
                {
                    write(decodeUTF16SurrogatePair(ch, theChars[i + 1],  getMemoryManager()));

                    ++i;
                }

        }
        else
        {
            throwInvalidCharacterException(theChar, getMemoryManager());
        }
    }




    // Data members...
    value_type      m_buffer[kBufferSize];

    value_type*     m_bufferPosition;

    size_type       m_bufferRemaining;
};



Lines 24-29 Link Here

(-)src/xalanc/XMLSupport/XalanFormatterWriter.hpp (-6 / +7 lines)
24	#include <xercesc/sax/SAXException.hpp>	24	#include <xercesc/sax/SAXException.hpp>
25		25
26	#include <xalanc/PlatformSupport/DOMStringHelper.hpp>	26	#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
		27	#include <xalanc/PlatformSupport/FormatterListener.hpp>
27	#include <xalanc/PlatformSupport/Writer.hpp>	28	#include <xalanc/PlatformSupport/Writer.hpp>
28	#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>	29	#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
29	#include <xalanc/PlatformSupport/XalanOutputStream.hpp>	30	#include <xalanc/PlatformSupport/XalanOutputStream.hpp>
Lines 42-47 Link Here
42	{	43	{
43	public:	44	public:
44		45
		46	typedef FormatterListener::size_type size_type;
		47
		48
45	template <class WriterType>	49	template <class WriterType>
46	class NewLineWriterFunctor	50	class NewLineWriterFunctor
47	{	51	{
Lines 90-103 Link Here
90	/**	94	/**
91	* The length of the the string of characters that represents the newline	95	* The length of the the string of characters that represents the newline
92	*/	96	*/
93	XalanDOMString::size_type m_newlineStringLength;	97	size_type m_newlineStringLength;
94	};	98	};
95		99
96	template<class WriterType>	100	template<class WriterType>
97	class WhiteSpaceWriterFunctor	101	class WhiteSpaceWriterFunctor
98	{	102	{
99	typedef XalanDOMString::size_type size_type;
100	typedef typename WriterType::value_type value_type;	103	typedef typename WriterType::value_type value_type;
		104
101	public:	105	public:
102	typedef WriterType writer_type;	106	typedef WriterType writer_type;
103		107
Lines 150-158 Link Here
150		154
151	public:	155	public:
152		156
153	typedef XalanDOMString::size_type size_type;
154
155
156	XalanFormatterWriter(	157	XalanFormatterWriter(
157	Writer& theWriter,	158	Writer& theWriter,
158	MemoryManager& theMemoryManager) :	159	MemoryManager& theMemoryManager) :
Lines 313-319 Link Here
313	/**	314	/**
314	* The length of the the string of characters that represents the newline	315	* The length of the the string of characters that represents the newline
315	*/	316	*/
316	XalanDOMString::size_type m_newlineStringLength;	317	size_type m_newlineStringLength;
317		318
318	/**	319	/**
319	* Format a code point as a numeric character reference.	320	* Format a code point as a numeric character reference.




	m_attrCharsMap[XalanUnicode::charLessThanSign] = 0;
	m_attrCharsMap[XalanUnicode::charGreaterThanSign] = 0;

	for(size_type i = 160; i < SPECIALSSIZE; i++)
	{
		m_attrCharsMap[i] = 'S';
	}

void
FormatterToHTML::characters(
			const XMLCh* const	chars,
			const size_type 	length)
{
	if(length != 0)
	{

void
FormatterToHTML::cdata(
			const XMLCh* const	ch,
			const size_type 	length)
{
	if(m_isScriptOrStyleElem == true)
	{

		const XMLCh* const	data)

{
	const size_type		dataLength = length(data);

	// Use a fairly nasty hack to tell if the next node is supposed to be 
	// unescaped text.


void
FormatterToHTML::writeCharacters(
			const XalanDOMChar*		theString,
			size_type	            theLength)
{
	assert(theString != 0);

	size_type	i = 0;
	size_type	firstIndex = 0;

    while(i < theLength)
	{


void
FormatterToHTML::writeAttrString(
			const XalanDOMChar*		theString,
			size_type	            theStringLength)
{
	assert(theString != 0);

	size_type	i = 0;
	size_type	firstIndex = 0;

    while(i < theStringLength)
    {


void
FormatterToHTML::copyEntityIntoBuffer(
			const XalanDOMChar*		s,
			size_type	            theLength)
{
	assert(s != 0);


			const XalanDOMChar*										value,
			const XalanHTMLElementsProperties::ElementProperties&	elemProperties)
{
	const size_type		nameLength = length(name);

	accumContent(XalanUnicode::charSpace);

	const size_type     valueLength = length(value);

	if((valueLength == 0 || equalsIgnoreCaseASCII(name, nameLength, value, valueLength)) &&
	   elemProperties.isAttribute(name, XalanHTMLElementsProperties::ATTREMPTY) == true)


void
FormatterToHTML::writeAttrURI(
			const XalanDOMChar*		theString,
			size_type	            theStringLength)
{
	assert(theString != 0);


	// causing damage.	If the URL is already properly escaped, in theory, this 
	// function should not change the string value.

    for (size_type i = 0; i < theStringLength; ++i)
    {
		const XalanDOMChar	ch = theString[i];



	if (m_prefixResolver != 0)
	{
		const size_type		theLength = length(theElementName);
		const size_type		theColonIndex = indexOf(theElementName, XalanUnicode::charColon);

		const XalanDOMString*	thePrefix = &s_emptyString;





    virtual void
	characters(
			const XMLCh* const	chars,
			const size_type 	length);

	// These methods are inherited from FormatterToXML...


	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type 	length);

	virtual void
	processingInstruction(

	{
		enum { eMaxLength = 8 };

		XalanDOMChar	m_char;

		size_type	    m_length;

		XalanDOMChar	m_string[eMaxLength + 1];
	};

protected:

	virtual void
	writeAttrString(
			const XalanDOMChar*		theString,
			size_type	            theStringLength);

	virtual void
	accumCommentData(const XalanDOMChar*	data);


	void
	writeCharacters(
			const XalanDOMChar*		theString,
			size_type	            theLength);

private:

	typedef XalanDOMString::size_type	size_type;

	/**
	 * The string "<!DOCTYPE  HTML".
	 */


	void
	copyEntityIntoBuffer(
			const XalanDOMChar*		s,
			size_type	            theLength);

	void
	copyEntityIntoBuffer(const XalanDOMString&	s);

	 */
	void
	writeAttrURI(
			const XalanDOMChar*		theString,
			size_type	            theStringLength);

	/**
	 * Accumulate the specified character by converting its numeric value to




void
FormatterToNull::characters(
			const XMLCh* const	/* chars */,
			const size_type	    /* length */)
{
}


void
FormatterToNull::charactersRaw(
		const XMLCh* const	/* chars */,
		const size_type	    /*length */)
{
}


void
FormatterToNull::ignorableWhitespace(
			const XMLCh* const	/* chars */,
			const size_type	    /* length */)
{
}



void
FormatterToNull::cdata(
			const XMLCh* const  /* ch */,
			const size_type	    /* length */)
{
}





    virtual void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length)
    {
        writeParentTagEnd();
    

        m_writer.write(value_type(XalanUnicode::charQuestionMark));
        writeName(target);

        const size_type     len = length(data);

        // We need to make sure there is a least one whitespace character
        // between the target and the data.

    void
    writeCharacters(
            const XMLCh*    chars,
            size_type       length)
    {
        assert(length != 0);



        m_indentHandler.setPreserve(true);

        size_type   i = 0;
        size_type   firstIndex = 0;

        while(i < length) 
        {

    void
    writeCDATA(
            const XMLCh*    chars,
            size_type       length)
    {
        assert(length != 0);
    

    * @param start the start offset into the string.
    * @param length the length of the string.
    */
    size_type
    writeNormalizedChar(
        XalanDOMChar        ch,
        const XalanDOMChar  chars[],
        size_type           start,
        size_type           length)
    {
        if (XalanUnicode::charLF == ch)
        {

        m_writer.write(value_type(XalanUnicode::charSemicolon));
    }

    size_type
    writeNormalizedCharBig(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        assert( start < length);


     */
    void
    writeCDATAChars(
            const XalanDOMChar  chars[],
            size_type           length,
            bool&               outsideCDATA)
    {
        size_type   i = 0;

        while(i < length)
        {

     */
    void
    writeAttrString(
            const XalanDOMChar*     theString,
            size_type               theStringLength)
    {
        assert(theString != 0);

        size_type   i = 0;
        size_type   firstIndex = 0;

        while(i < theStringLength)
        {

     */
    void
    writeNormalizedData(
            const XalanDOMChar*     theData,
            size_type               theLength)
    {
        for (size_type i = 0; i < theLength; ++i)
        {
            const XalanDOMChar  theChar = theData[i];



    void
    safeWriteContent(
                const XalanDOMChar*     theChars,
                size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        {




    virtual void
	characters(
			const XMLCh* const	chars,
			const size_type     length);

    virtual void
	charactersRaw(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	entityReference(const XMLCh* const	name);

	virtual void
	ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	processingInstruction(

	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type 	length);

private:





void
XalanXMLSerializerBase::characters(
            const XMLCh* const  chars,
            const size_type     length)
{
    if(length != 0)
    {

void
XalanXMLSerializerBase::cdata(
            const XMLCh* const  ch,
            const size_type     length)
{
    if (length != 0)
    {

void
XalanXMLSerializerBase::ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length)
{
    if (length > 0)
    {

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::s_xhtmlDocTypeStringLength =
        FXML_SIZE(s_xhtmlDocTypeString);



    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_doctypeHeaderStartStringLength =
        FXML_SIZE(s_doctypeHeaderStartString);

const char  XalanXMLSerializerBase::UTF8::s_doctypeHeaderPublicString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_doctypeHeaderPublicStringLength =
        FXML_SIZE(s_doctypeHeaderPublicString);

const char  XalanXMLSerializerBase::UTF8::s_doctypeHeaderSystemString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_doctypeHeaderSystemStringLength =
        FXML_SIZE(s_doctypeHeaderSystemString);

const char  XalanXMLSerializerBase::UTF8::s_xmlHeaderStartString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_xmlHeaderStartStringLength =
        FXML_SIZE(s_xmlHeaderStartString);

const char  XalanXMLSerializerBase::UTF8::s_xmlHeaderEncodingString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_xmlHeaderEncodingStringLength =
        FXML_SIZE(s_xmlHeaderEncodingString);

const char  XalanXMLSerializerBase::UTF8::s_xmlHeaderStandaloneString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_xmlHeaderStandaloneStringLength =
        FXML_SIZE(s_xmlHeaderStandaloneString);

const char  XalanXMLSerializerBase::UTF8::s_xmlHeaderEndString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_xmlHeaderEndStringLength =
        FXML_SIZE(s_xmlHeaderEndString);

const char  XalanXMLSerializerBase::UTF8::s_defaultVersionString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_defaultVersionStringLength =
        FXML_SIZE(s_defaultVersionString);

const char  XalanXMLSerializerBase::UTF8::s_cdataOpenString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_cdataOpenStringLength =
        FXML_SIZE(s_cdataOpenString);

const char  XalanXMLSerializerBase::UTF8::s_cdataCloseString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_cdataCloseStringLength =
        FXML_SIZE(s_cdataCloseString);



    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_xhtmlDocTypeStringLength =
        FXML_SIZE(s_xhtmlDocTypeString);

const char  XalanXMLSerializerBase::UTF8::s_lessThanEntityString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_lessThanEntityStringLength =
        FXML_SIZE(s_lessThanEntityString);

const char  XalanXMLSerializerBase::UTF8::s_greaterThanEntityString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_greaterThanEntityStringLength =
        FXML_SIZE(s_greaterThanEntityString);

const char  XalanXMLSerializerBase::UTF8::s_ampersandEntityString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_ampersandEntityStringLength =
        FXML_SIZE(s_ampersandEntityString);

const char  XalanXMLSerializerBase::UTF8::s_quoteEntityString[] =

    char(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF8::s_quoteEntityStringLength =
        FXML_SIZE(s_quoteEntityString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_doctypeHeaderStartString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_doctypeHeaderStartStringLength =
        FXML_SIZE(s_doctypeHeaderStartString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_doctypeHeaderPublicString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_doctypeHeaderPublicStringLength =
        FXML_SIZE(s_doctypeHeaderPublicString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_doctypeHeaderSystemString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_doctypeHeaderSystemStringLength =
        FXML_SIZE(s_doctypeHeaderSystemString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_xmlHeaderStartString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_xmlHeaderStartStringLength =
        FXML_SIZE(s_xmlHeaderStartString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_xmlHeaderEncodingString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_xmlHeaderEncodingStringLength =
        FXML_SIZE(s_xmlHeaderEncodingString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_xmlHeaderStandaloneString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_xmlHeaderStandaloneStringLength =
        FXML_SIZE(s_xmlHeaderStandaloneString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_xmlHeaderEndString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_xmlHeaderEndStringLength =
        FXML_SIZE(s_xmlHeaderEndString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_defaultVersionString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_defaultVersionStringLength =
        FXML_SIZE(s_defaultVersionString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_cdataOpenString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_cdataOpenStringLength =
        FXML_SIZE(s_cdataOpenString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_cdataCloseString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_cdataCloseStringLength =
        FXML_SIZE(s_cdataCloseString);



    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_xhtmlDocTypeStringLength =
        FXML_SIZE(s_xhtmlDocTypeString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_lessThanEntityString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_lessThanEntityStringLength =
        FXML_SIZE(s_lessThanEntityString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_greaterThanEntityString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_greaterThanEntityStringLength =
        FXML_SIZE(s_greaterThanEntityString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_ampersandEntityString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_ampersandEntityStringLength =
        FXML_SIZE(s_ampersandEntityString);

const XalanDOMChar  XalanXMLSerializerBase::UTF16::s_quoteEntityString[] =

    XalanDOMChar(0)
};

const XalanXMLSerializerBase::size_type     XalanXMLSerializerBase::UTF16::s_quoteEntityStringLength =
        FXML_SIZE(s_quoteEntityString);






void
FormatterToText::characters(
			const XMLCh* const	chars,
			const size_type	    length)
{
	assert(m_writer != 0);


void
FormatterToText::charactersRaw(
		const XMLCh* const	chars,
		const size_type	    length)
{
	characters(chars, length);
}

void
FormatterToText::ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length)
{
	if (m_handleIgnorableWhitespace == true)
	{

void
FormatterToText::cdata(
			const XMLCh* const	ch,
			const size_type 	length)
{
	characters(ch, length);
}




    virtual void
    characters(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length) = 0;

    virtual void
    entityReference(const XMLCh* const  name) = 0;

    virtual void
    ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    processingInstruction(

    virtual void
    cdata(
            const XMLCh* const  ch,
            const size_type     length);

    virtual const XalanDOMString&
    getDoctypeSystem() const;

        /**
         * The string "<!DOCTYPE ".
         */
        static const char           s_doctypeHeaderStartString[];

        static const size_type      s_doctypeHeaderStartStringLength;

        /**
         * The string " PUBLIC \"".
         */
        static const char       s_doctypeHeaderPublicString[];

        static const size_type  s_doctypeHeaderPublicStringLength;

        /**
         * The string " SYSTEM \"".
         */
        static const char       s_doctypeHeaderSystemString[];

        static const size_type  s_doctypeHeaderSystemStringLength;

        /**
         * The string "<?xml version=\"".
         */
        static const char       s_xmlHeaderStartString[];

        static const size_type  s_xmlHeaderStartStringLength;

        /**
         * The string "\" encoding=\"".
         */
        static const char       s_xmlHeaderEncodingString[];

        static const size_type  s_xmlHeaderEncodingStringLength;

        /**
         * The string "\" standalone=\"".
         */
        static const char       s_xmlHeaderStandaloneString[];

        static const size_type  s_xmlHeaderStandaloneStringLength;

        /**
         * The string "\"?>".
         */
        static const char       s_xmlHeaderEndString[];

        static const size_type  s_xmlHeaderEndStringLength;

        /**
         * The string "1.0".
         */
        static const char       s_defaultVersionString[];

        static const size_type  s_defaultVersionStringLength;

        /**
         * The string "-//W3C//DTD XHTML".
         */
        static const XalanDOMChar   s_xhtmlDocTypeString[];

        static const size_type      s_xhtmlDocTypeStringLength;

        /**
         * The string "<![CDATA[".
         */
        static const char       s_cdataOpenString[];

        static const size_type  s_cdataOpenStringLength;

        /**
         * The string "]]>".
         */
        static const char       s_cdataCloseString[];

        static const size_type  s_cdataCloseStringLength;

        /**
         * The string "&lt;".
         */
        static const char       s_lessThanEntityString[];

        static const size_type  s_lessThanEntityStringLength;

        /**
         * The string "&gt;".
         */
        static const char       s_greaterThanEntityString[];

        static const size_type  s_greaterThanEntityStringLength;

        /**
         * The string "&amp;".
         */
        static const char       s_ampersandEntityString[];

        static const size_type  s_ampersandEntityStringLength;

        /**
         * The string "&quot;".
         */
        static const char       s_quoteEntityString[];

        static const size_type  s_quoteEntityStringLength;
    };

    class XALAN_XMLSUPPORT_EXPORT UTF16

        /**
         * The string "<!DOCTYPE ".
         */
        static const XalanDOMChar   s_doctypeHeaderStartString[];

        static const size_type      s_doctypeHeaderStartStringLength;

        /**
         * The string " PUBLIC \"".
         */
        static const XalanDOMChar   s_doctypeHeaderPublicString[];

        static const size_type      s_doctypeHeaderPublicStringLength;

        /**
         * The string " SYSTEM \"".
         */
        static const XalanDOMChar   s_doctypeHeaderSystemString[];

        static const size_type      s_doctypeHeaderSystemStringLength;

        /**
         * The string "<?xml version=\"".
         */
        static const XalanDOMChar   s_xmlHeaderStartString[];

        static const size_type      s_xmlHeaderStartStringLength;

        /**
         * The string "\" encoding=\"".
         */
        static const XalanDOMChar   s_xmlHeaderEncodingString[];

        static const size_type      s_xmlHeaderEncodingStringLength;

        /**
         * The string "\" standalone=\"".
         */
        static const XalanDOMChar   s_xmlHeaderStandaloneString[];

        static const size_type      s_xmlHeaderStandaloneStringLength;

        /**
         * The string "\"?>".
         */
        static const XalanDOMChar   s_xmlHeaderEndString[];

        static const size_type      s_xmlHeaderEndStringLength;

        /**
         * The string "1.0".
         */
        static const XalanDOMChar   s_defaultVersionString[];

        static const size_type      s_defaultVersionStringLength;

        /**
         * The string "-//W3C//DTD XHTML".
         */
        static const XalanDOMChar   s_xhtmlDocTypeString[];

        static const size_type      s_xhtmlDocTypeStringLength;

        /**
         * The string "<![CDATA[".
         */
        static const XalanDOMChar   s_cdataOpenString[];

        static const size_type      s_cdataOpenStringLength;

        /**
         * The string "]]>".
         */
        static const XalanDOMChar   s_cdataCloseString[];

        static const size_type      s_cdataCloseStringLength;

        /**
         * The string "&lt;".
         */
        static const XalanDOMChar   s_lessThanEntityString[];

        static const size_type      s_lessThanEntityStringLength;

        /**
         * The string "&gt;".
         */
        static const XalanDOMChar   s_greaterThanEntityString[];

        static const size_type      s_greaterThanEntityStringLength;

        /**
         * The string "&amp;".
         */
        static const XalanDOMChar   s_ampersandEntityString[];

        static const size_type      s_ampersandEntityStringLength;

        /**
         * The string "&quot;".
         */
        static const XalanDOMChar   s_quoteEntityString[];

        static const size_type      s_quoteEntityStringLength;
    };

    enum

    virtual void
    writeCharacters(
            const XMLCh*    chars,
            size_type       length) = 0;

    virtual void
    writeCDATA(
            const XMLCh*    chars,
            size_type       length) = 0;

    virtual void
    outputNewline() = 0;

     */
    const XalanDOMString    m_standalone;

    const XalanDOMString    m_encoding;

    static bool
    isUTF16HighSurrogate(XalanDOMChar   theChar)

    /**
     * The string "-//W3C//DTD XHTML".
     */
    static const XalanDOMChar   s_xhtmlDocTypeString[];

    static const size_type      s_xhtmlDocTypeStringLength;
};






    virtual void
	characters(
			const XMLCh* const	chars,
			const size_type	    length);

    virtual void
	charactersRaw(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	entityReference(const XMLCh* const	name);

	virtual void
	ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	processingInstruction(

	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type 	length);

private:






void
FormatterToXML::accumNameArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
{
    const size_type     n = start + length;

    for(size_type i = start; i < n; ++i)
    {
        accumName(chars[i]);
    }


void
FormatterToXML::accumContentArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
{
    const size_type     n = start + length;

    for(size_type i = start; i < n; ++i)
    {
        accumContent(chars[i]);
    }


void
FormatterToXML::accumArrayUTF(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
{
    const size_type     n = start + length;

    for(size_type i = start; i < n; ++i)
    {
        accumCharUTF(chars[i]);
    }


void
FormatterToXML::accumArrayUTFDirect(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
{
    assert(m_maxCharacter >= 65535);
    assert(m_stream != 0);




FormatterToXML::size_type
FormatterToXML::accumDefaultEscape(
            XalanDOMChar        ch,
            size_type           i,
            const XalanDOMChar  chars[],
            size_type           len,
            bool                escLF)
{
    if(!accumDefaultEntity(ch, escLF))
    {

void
FormatterToXML::characters(
            const XMLCh* const  chars,
            const size_type     length)
{
    if(length != 0)
    {


            m_ispreserve = true;

            size_type    i = 0;
            size_type   firstIndex = 0;

            while(i < length) 
            {

void
FormatterToXML::charactersRaw(
        const XMLCh* const  chars,
        const size_type     length)
{
    writeParentTagEnd();



void
FormatterToXML::writeAttrString(
            const XalanDOMChar*     theString,
            size_type               theStringLength)
{
    assert(theString != 0);

    size_type   i = 0;
    size_type   firstIndex = 0;

    while(i < theStringLength)
    {


void
FormatterToXML::writeNormalizedChars(
            const XalanDOMChar  ch[],
            size_type           start,
            size_type           length,
            bool                isCData)
{
    size_type   end = start + length;

    for(size_type i = start; i < end; ++i)
    {
        const XalanDOMChar  c = ch[i];


void
FormatterToXML::ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length)
{
#if 1
    // We need to do normalization, which is slower,

void
FormatterToXML::cdata(
            const XMLCh* const  ch,
            const size_type     length)
{
    if(m_nextIsRaw == true)
    {


void
FormatterToXML::accumNormalizedPIData(
            const XalanDOMChar*     theData,
            size_type               theLength)
{
    for (size_type i = 0; i < theLength; ++i)
    {
        accumContent(theData[i]);
    }





    size_type
    writeCDATAChar(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           /*length*/,
            bool&               /* outsideCDATA */)
    {
        assert( chars != 0 );


    }

    /**
     * Writes name chars, if not representable, throws 
     */
    void
    writeNameChar(
            const XalanDOMChar*     data,
            size_type               theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes name chars, if not representable, throws 
     */
    void
    writePIChars(
            const XalanDOMChar*     data,
            size_type               theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes name chars, if not representable, throws 
     */
    void
    writeCommentChars(
            const XalanDOMChar*      data,
            size_type                theLength)
    {
        write(data, theLength);
    }




    virtual void
    characters(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    entityReference(const XMLCh* const  name);

    virtual void
    ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    processingInstruction(

    virtual void
    cdata(
            const XMLCh* const  ch,
            const size_type     length);

    virtual Writer*
    getWriter() const;


    typedef void (FormatterToXML::*AccumArrayFunctionType)(
                        const XalanDOMChar[],
                        size_type,
                        size_type);

    typedef void (FormatterToXML::*FlushFunctionType)();


     */
    void
    accumName(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        assert(m_accumNameArrayFunction != 0);


     */
    void
    accumContent(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        assert(m_accumContentArrayFunction != 0);


    /**
     * Escape and accum a character.
     */
    size_type
    accumDefaultEscape(
            XalanDOMChar        ch,
            size_type           i,
            const XalanDOMChar  chars[],
            size_type           len,
            bool                escLF);

    /**
     * Handle one of the default entities, return false if it 

     */
    virtual void
    writeNormalizedChars(
            const XalanDOMChar  ch[],
            size_type           start,
            size_type           length,
            bool                isCData);

    /**
     * Write a number into the buffer as an entity

     */
    virtual void
    writeAttrString(
            const XalanDOMChar*     theString,
            size_type               theStringLength);

    /**
     * Write the data for a comment

     */
    void
    accumNameArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);

    /**
     * Append an array of wide character to the buffer.

     */
    void
    accumContentArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);

    /**
     * Append an array of wide character to the buffer.

     */
    void
    accumArrayUTF(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);

    /**
     * Append an array of wide character to the output.

     */
    void
    accumArrayUTFDirect(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);

    /**
     * Append a string to the buffer.

     */
    void
    accumNormalizedPIData(
            const XalanDOMChar*     theData,
            size_type               theLength);


    // Data members...

     */
    const XalanDOMString    m_attrSpecialChars;

    //typedef XalanDOMString::size_type   size_type;

    /**
     * The string "<!DOCTYPE ".

Lines 20-27 Link Here

(-)src/xalanc/Utils/MsgCreator/NLSHandler.hpp (-1 / +10 lines)
20	#include "ICUResHandler.hpp"	20	#include "ICUResHandler.hpp"
21		21
22		22
		23
		24	XALAN_CPP_NAMESPACE_BEGIN
		25
		26
		27
23	XERCES_CPP_NAMESPACE_USE	28	XERCES_CPP_NAMESPACE_USE
24		29
		30
		31
25	class NLSHandler : public ICUResHandler	32	class NLSHandler : public ICUResHandler
26	{	33	{
27	public:	34	public:
Lines 72-77 Link Here
72		79
73		80
74		81
75	#endif //NLSHANDLER_MSGCREATOR_1357924680	82	XALAN_CPP_NAMESPACE_END
76		83
77		84
		85
		86	#endif //NLSHANDLER_MSGCREATOR_1357924680

Lines 26-31 Link Here

(-)src/xalanc/Utils/MsgCreator/InMemHandler.cpp (-7 / +16 lines)
26	#include "InMemData.hpp"	26	#include "InMemData.hpp"
27		27
28		28
		29
		30	XALAN_CPP_NAMESPACE_BEGIN
		31
		32
		33
29	// -----------------------------------------------------------------------	34	// -----------------------------------------------------------------------
30	// Constructors	35	// Constructors
31	// -----------------------------------------------------------------------	36	// -----------------------------------------------------------------------
Lines 68-74 Link Here
68		73
69		74
70	void InMemHandler::characters( const XMLCh* const chars	75	void InMemHandler::characters( const XMLCh* const chars
71	, const unsigned int length)	76	, const XalanSize_t length)
72	{	77	{
73		78
74	if ( m_startCollectingCharacters == true )	79	if ( m_startCollectingCharacters == true )
Lines 99-113 Link Here
99		104
100	}	105	}
101		106
102	void InMemHandler::endElement(const XMLCh* const ,	107	void InMemHandler::endElement(const XMLCh* const /* uri */,
103	const XMLCh* const localname,	108	const XMLCh* const /* localname */,
104	const XMLCh* const )	109	const XMLCh* const qname)
105	{	110	{
106	if ( m_startCollectingCharacters == false)	111	if ( m_startCollectingCharacters == false)
107	return;	112	return;
108		113
109		114
110	if(!XMLString::compareString(localname,s_targetXMLCh))	115	if(!XMLString::compareString(qname,s_targetXMLCh))
111	{	116	{
112	m_startCollectingCharacters = false;	117	m_startCollectingCharacters = false;
113		118
Lines 121-133 Link Here
121	const Attributes& attributes)	126	const Attributes& attributes)
122	{	127	{
123		128
124	if(!XMLString::compareString(localname,s_transUnitXMLCh))	129	if(!XMLString::compareString(qname,s_transUnitXMLCh))
125	{	130	{
126	// this is an elemente, SAX2Handler class is responsible to handle:	131	// this is an elemente, SAX2Handler class is responsible to handle:
127	// creating Index file, commom for all localization styles	132	// creating Index file, commom for all localization styles
128	SAX2Handler::startElement(uri, localname, qname, attributes);	133	SAX2Handler::startElement(uri, localname, qname, attributes);
129	}	134	}
130	else if(!XMLString::compareString(localname,s_targetXMLCh))	135	else if(!XMLString::compareString(qname,s_targetXMLCh))
131	{	136	{
132		137
133		138
Lines 203-205 Link Here
203	printToDataFile( szEndDataFile );	208	printToDataFile( szEndDataFile );
204		209
205	}	210	}
		211
		212
		213
		214	XALAN_CPP_NAMESPACE_END

Lines 263-269 Link Here

(-)src/xalanc/Utils/MsgCreator/MsgCreator.cpp (-1 / +3 lines)
263	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);	263	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
264	_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);	264	_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
265	#endif	265	#endif
266		266
		267	XALAN_CPP_NAMESPACE_USE
		268
267	CmdLineParams theParams;	269	CmdLineParams theParams;
268		270
269	int iReturnValue = 0;	271	int iReturnValue = 0;

Lines 20-27 Link Here

(-)src/xalanc/Utils/MsgCreator/InMemHandler.hpp (-1 / +13 lines)
20	#include "SAX2Handler.hpp"	20	#include "SAX2Handler.hpp"
21		21
22		22
		23
		24	XALAN_CPP_NAMESPACE_BEGIN
		25
		26
		27
23	XERCES_CPP_NAMESPACE_USE	28	XERCES_CPP_NAMESPACE_USE
24		29
		30
25	class InMemHandler : public SAX2Handler	31	class InMemHandler : public SAX2Handler
26	{	32	{
27	public:	33	public:
Lines 54-60 Link Here
54		60
55	virtual void	61	virtual void
56	characters( const XMLCh* const chars	62	characters( const XMLCh* const chars
57	, const unsigned int length);	63	, const XalanSize_t length);
58		64
59		65
60		66
Lines 96-99 Link Here
96		102
97	};	103	};
98		104
		105
		106
		107	XALAN_CPP_NAMESPACE_END
		108
		109
		110
99	#endif /// INMEMHANDLER_MSGCREATOR_1357924680	111	#endif /// INMEMHANDLER_MSGCREATOR_1357924680




#include "MsgCreator.hpp"


XALAN_CPP_NAMESPACE_BEGIN


static const char* INDEX_FILE_NAME="LocalMsgIndex.hpp";



// ---------------------------------------------------------------------------
//  SAX2Handler: Constructors and Destructor
// ---------------------------------------------------------------------------




void SAX2Handler::startElement(const   XMLCh* const    /* uri */,
									const   XMLCh* const    /* localname */,
									const   XMLCh* const    qname,
                                    const   Attributes&		attributes)
{
	if(!XMLString::compareString(qname,s_transUnitXMLCh))
	{
		unsigned int len = attributes.getLength();
		

}



XALAN_CPP_NAMESPACE_END

Lines 23-28 Link Here

(-)src/xalanc/Utils/MsgCreator/SAX2Handler.hpp (-1 / +8 lines)
23	#include <xercesc/util/XMLUniDefs.hpp>	23	#include <xercesc/util/XMLUniDefs.hpp>
24		24
25		25
		26	XALAN_CPP_NAMESPACE_BEGIN
		27
		28
		29
26	XERCES_CPP_NAMESPACE_USE	30	XERCES_CPP_NAMESPACE_USE
27		31
28		32
Lines 210-215 Link Here
210	};	214	};
211		215
212		216
213	#endif //SAX2HANDLER_MSGCREATOR_1357924680
214		217
		218	XALAN_CPP_NAMESPACE_END
215		219
		220
		221
		222	#endif //SAX2HANDLER_MSGCREATOR_1357924680

Lines 24-29 Link Here

(-)src/xalanc/Utils/MsgCreator/MsgFileOutputStream.cpp (-5 / +12 lines)
24	#include <cstdio>	24	#include <cstdio>
25		25
26		26
		27	XALAN_CPP_NAMESPACE_BEGIN
		28
		29
27	static XalanFileOutputStream::HandleType	30	static XalanFileOutputStream::HandleType
28	openFile(const char* theFileName)	31	openFile(const char* theFileName)
29	{	32	{
Lines 105-111 Link Here
105	void	108	void
106	XalanFileOutputStream::writeData(	109	XalanFileOutputStream::writeData(
107	const char* theBuffer,	110	const char* theBuffer,
108	unsigned int theBufferLength)	111	XalanSize_t theBufferLength)
109	{	112	{
110	#if defined(WIN32)	113	#if defined(WIN32)
111	DWORD theBytesWritten;	114	DWORD theBytesWritten;
Lines 204-216 Link Here
204	}	207	}
205		208
206		209
207	void XalanFileOutputStream::write(const UTF16Ch* theString, unsigned int theLength)	210	void XalanFileOutputStream::write(const UTF16Ch* theString, XalanSize_t theLength)
208	{	211	{
209	assert ( theString != 0 );	212	assert ( theString != 0 );
210	writeData((const char)theString,theLength sizeof(UTF16Ch) );	213	writeData((const char)theString,theLength sizeof(UTF16Ch) );
211	}	214	}
212		215
213	void XalanFileOutputStream::write(const char* theString, unsigned int theLength)	216	void XalanFileOutputStream::write(const char* theString, XalanSize_t theLength)
214	{	217	{
215	assert ( theString != 0 );	218	assert ( theString != 0 );
216		219
Lines 221-227 Link Here
221	XMLString::release(&theUTFString);	224	XMLString::release(&theUTFString);
222	}	225	}
223		226
224	void XalanFileOutputStream::writeAsASCII(const UTF16Ch* theString, unsigned int theLengts)	227	void XalanFileOutputStream::writeAsASCII(const UTF16Ch* theString, XalanSize_t theLengts)
225	{	228	{
226	char* szString = XMLString::transcode(theString);	229	char* szString = XMLString::transcode(theString);
227	writeData( szString, theLengts );	230	writeData( szString, theLengts );
Lines 229-235 Link Here
229		232
230	}	233	}
231		234
232	void XalanFileOutputStream::writeAsASCII(const char* theString, unsigned int theLengts)	235	void XalanFileOutputStream::writeAsASCII(const char* theString, XalanSize_t theLengts)
233	{	236	{
234	writeData( theString, theLengts );	237	writeData( theString, theLengts );
235	}	238	}
Lines 244-246 Link Here
244	{	247	{
245	write(s_UTF16ByteOrderMark,1);	248	write(s_UTF16ByteOrderMark,1);
246	}	249	}
		250
		251
		252
		253	XALAN_CPP_NAMESPACE_END




#define XALANOUTPUTFILE_1357924680

#include <xercesc/util/XMLUniDefs.hpp>
#include "xalanc/Include/PlatformDefinitions.hpp"


#if defined(WIN32)




XALAN_CPP_NAMESPACE_BEGIN



XERCES_CPP_NAMESPACE_USE

// Class responcible for printing into file with UTF16




	void 
	write(const UTF16Ch*	theString, XalanSize_t		theLength);
	void 
	write(const char*	theString, XalanSize_t		theLength);

	void 
	writeAsASCII(const char*	theString, XalanSize_t		theLengts);

	void
	writeAsASCII(const UTF16Ch*	theString, XalanSize_t		theLengts);
	void
	writeUTFprefix();
protected:

	void
	writeData(
			const char*		theBuffer,
			XalanSize_t	theBufferLength);

	void
	doFlush();

};


XALAN_CPP_NAMESPACE_END


#endif //XALANOUTPUTFILE_1357924680

Lines 28-34 Link Here

(-)src/xalanc/Utils/MsgCreator/ICUResHandler.cpp (-8 / +11 lines)
28		28
29		29
30		30
		31	XALAN_CPP_NAMESPACE_BEGIN
31		32
		33
		34
32	// -----------------------------------------------------------------------	35	// -----------------------------------------------------------------------
33	// Constructors	36	// Constructors
34	// -----------------------------------------------------------------------	37	// -----------------------------------------------------------------------
Lines 58-64 Link Here
58	// change tham with \", \{ and \}	61	// change tham with \", \{ and \}
59		62
60	void ICUResHandler::characters( const XMLCh* const chars	63	void ICUResHandler::characters( const XMLCh* const chars
61	, const unsigned int length)	64	, const XalanSize_t length)
62	{	65	{
63		66
64	if ( m_startCollectingCharacters == true )	67	if ( m_startCollectingCharacters == true )
Lines 100-114 Link Here
100		103
101	}	104	}
102		105
103	void ICUResHandler::endElement(const XMLCh* const ,	106	void ICUResHandler::endElement(const XMLCh* const /* uri */,
104	const XMLCh* const localname,	107	const XMLCh* const /* localname */,
105	const XMLCh* const )	108	const XMLCh* const qname)
106	{	109	{
107	if ( m_startCollectingCharacters == false)	110	if ( m_startCollectingCharacters == false)
108	return;	111	return;
109		112
110		113
111	if(!XMLString::compareString(localname,s_targetXMLCh))	114	if(!XMLString::compareString(qname,s_targetXMLCh))
112	{	115	{
113	m_startCollectingCharacters = false;	116	m_startCollectingCharacters = false;
114		117
Lines 122-134 Link Here
122	const Attributes& attributes)	125	const Attributes& attributes)
123	{	126	{
124		127
125	if(!XMLString::compareString(localname,s_transUnitXMLCh))	128	if(!XMLString::compareString(qname,s_transUnitXMLCh))
126	{	129	{
127	// this is an elemente, SAX2Handler class is responsible to handle:	130	// this is an elemente, SAX2Handler class is responsible to handle:
128	// creating Index file, commom for all localization styles	131	// creating Index file, commom for all localization styles
129	SAX2Handler::startElement(uri, localname, qname, attributes);	132	SAX2Handler::startElement(uri, localname, qname, attributes);
130	}	133	}
131	else if(!XMLString::compareString(localname,s_targetXMLCh))	134	else if(!XMLString::compareString(qname,s_targetXMLCh))
132	{	135	{
133	if ( m_locale != 0 )	136	if ( m_locale != 0 )
134	{	137	{
Lines 196-199 Link Here
196	}	199	}
197		200
198		201
199		202	XALAN_CPP_NAMESPACE_END

Lines 22-27 Link Here

(-)src/xalanc/Utils/MsgCreator/NLSHandler.cpp (-1 / +10 lines)
22		22
23	#include <cstdio>	23	#include <cstdio>
24		24
		25
		26	XALAN_CPP_NAMESPACE_BEGIN
		27
		28
		29
25	// -----------------------------------------------------------------------	30	// -----------------------------------------------------------------------
26	// Constructors	31	// Constructors
27	// -----------------------------------------------------------------------	32	// -----------------------------------------------------------------------
Lines 48-54 Link Here
48	}	53	}
49		54
50	void NLSHandler::characters( const XMLCh* const chars	55	void NLSHandler::characters( const XMLCh* const chars
51	, const unsigned int length)	56	, const XalanSize_t length)
52	{	57	{
53		58
54	if ( m_startCollectingCharacters == true )	59	if ( m_startCollectingCharacters == true )
Lines 128-130 Link Here
128	m_fStream.writeAsASCII("^\n",2);	133	m_fStream.writeAsASCII("^\n",2);
129	}	134	}
130	}	135	}
		136
		137
		138
		139	XALAN_CPP_NAMESPACE_END

Lines 20-27 Link Here

(-)src/xalanc/Utils/MsgCreator/ICUResHandler.hpp (-1 / +11 lines)
20	#include "SAX2Handler.hpp"	20	#include "SAX2Handler.hpp"
21		21
22		22
		23
		24	XALAN_CPP_NAMESPACE_BEGIN
		25
		26
		27
23	XERCES_CPP_NAMESPACE_USE	28	XERCES_CPP_NAMESPACE_USE
24		29
		30
		31
25	class ICUResHandler : public SAX2Handler	32	class ICUResHandler : public SAX2Handler
26	{	33	{
27	public:	34	public:
Lines 84-88 Link Here
84	operator==(const ICUResHandler&) const;	91	operator==(const ICUResHandler&) const;
85	};	92	};
86		93
		94
		95	XALAN_CPP_NAMESPACE_END
		96
		97
87	#endif // ICURESHANDLER_MSGCREATOR_1357924680	98	#endif // ICURESHANDLER_MSGCREATOR_1357924680
88

Lines 50-56 Link Here

(-)src/xalanc/XalanDOM/XalanDOMString.hpp (-2 / +2 lines)
50	typedef XalanDOMChar& reference;	50	typedef XalanDOMChar& reference;
51	typedef const XalanDOMChar& const_reference;	51	typedef const XalanDOMChar& const_reference;
52		52
53	typedef unsigned int size_type;	53	typedef XalanSize_t size_type;
54		54
55	typedef XalanDOMCharVectorType::iterator iterator;	55	typedef XalanDOMCharVectorType::iterator iterator;
56	typedef XalanDOMCharVectorType::const_iterator const_iterator;	56	typedef XalanDOMCharVectorType::const_iterator const_iterator;
Lines 60-66 Link Here
60	#if defined(XALAN_INLINE_INITIALIZATION)	60	#if defined(XALAN_INLINE_INITIALIZATION)
61	static const size_type npos = ~0u;	61	static const size_type npos = ~0u;
62	#else	62	#else
63	enum { npos = -1 };	63	enum { npos = ~0u };
64	#endif	64	#endif
65		65
66	XalanDOMString(MemoryManagerType& theManager XALAN_DEFAULT_CONSTRACTOR_MEMORY_MGR );	66	XalanDOMString(MemoryManagerType& theManager XALAN_DEFAULT_CONSTRACTOR_MEMORY_MGR );

Lines 96-101 Link Here

(-)src/xalanc/Harness/XalanDiagnosticMemoryManager.hpp (+3 lines)
96	virtual void	96	virtual void
97	deallocate(void* pointer);	97	deallocate(void* pointer);
98		98
		99	virtual MemoryManager*
		100	getExceptionMemoryManager();
		101
99	bool	102	bool
100	getAssertErrors() const	103	getAssertErrors() const
101	{	104	{

Lines 157-162 Link Here

(-)src/xalanc/Harness/XalanDiagnosticMemoryManager.cpp (+8 lines)
157		157
158		158
159		159
		160	MemoryManager*
		161	XalanDiagnosticMemoryManager::getExceptionMemoryManager()
		162	{
		163	return &m_memoryManager;
		164	}
		165
		166
		167
160	void	168	void
161	XalanDiagnosticMemoryManager::dumpStatistics(	169	XalanDiagnosticMemoryManager::dumpStatistics(
162	StreamType* theStream,	170	StreamType* theStream,




public:

	typedef XalanVector<XalanSourceTreeElement*> 		ElementStackType;
	typedef XalanVector<XalanNode*> 					LastChildStackType;
    typedef XalanSize_t                                 size_type;

	enum { eDefaultStackSize = 50, eDefaultTextBufferSize = 100 };


	virtual void
	characters(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	endDocument();

	virtual void
	ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	processingInstruction(

	virtual void
	comment(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	endCDATA();


	void
	doCharacters(
			const XMLCh*	chars,
			size_type	    length);

	// Data members...





void
FormatterToSourceTree::characters(
			const XMLCh* const	chars,
			const size_type	    length)
{
	if (m_documentFragment != 0)
	{

void
FormatterToSourceTree::charactersRaw(
		const XMLCh* const	chars,
		const size_type	    length)
{
	assert(m_document != 0);


void
FormatterToSourceTree::ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length)
{
	assert(m_document != 0);


void
FormatterToSourceTree::cdata(
			const XMLCh* const	/* ch */,
			const size_type 	/* length */)
{
}



void
FormatterToSourceTree::doCharacters(
			const XMLCh*	chars,
			size_type	    length)
{
	if (m_currentElement != 0)
	{




	virtual void
	charactersRaw(
			const XMLCh* const	chars,
			const size_type	    length);

	virtual void
	comment(const XMLCh* const	data);

	virtual void
	cdata(
			const XMLCh* const	ch,
			const size_type 	length);

	virtual void
	entityReference(const XMLCh* const	name);

	virtual void
	characters(
				const XMLCh* const	chars,
				const size_type	    length);

	virtual void
	ignorableWhitespace(
				const XMLCh* const	chars,
				const size_type	    length);

	virtual void
	processingInstruction(


	void
	doCharacters(
			const XalanDOMChar*		chars,
			size_type	            length);

	void
	doProcessingInstruction(




void
XalanSourceTreeContentHandler::characters(
			const	XMLCh* const	chars,
			const size_type		    length)
{
	assert(m_inDTD == false);


void
XalanSourceTreeContentHandler::ignorableWhitespace(
			const XMLCh* const	chars,
			const size_type	    length)
{
	assert(m_inDTD == false);


void
XalanSourceTreeContentHandler::comment(
			const XMLCh* const	chars,
			const size_type	    length)
{
	assert(m_document != 0);



void
XalanSourceTreeContentHandler::doCharacters(
			const XMLCh*	chars,
			size_type	    length)
{
	assert(m_inDTD == false);






			if (theNode != 0 && theNode->getNodeType() == XalanNode::ENTITY_NODE)
			{
				const XalanEntity* const    theEntity =
#if defined(XALAN_OLD_STYLE_CASTS)
					(const XalanEntity*)theNode;
#else
					static_cast<const XalanEntity*>(theNode);
#endif

				if(length(theEntity->getNotationName()) != 0) // then it's unparsed
                                            theEntity->getNotationName(),
                                            theMemoryManager);

				if(isEmpty(theNotationName) == false) // then it's unparsed
				{
					// The draft says: "The XSLT processor may use the public
					// identifier to generate a URI for the entity instead of the URI

					// So I'm falling a bit short here.
					theURI = theEntity->getSystemId();

                    if(theURI.length() == 0)
					{
						theURI = theEntity->getPublicId();
					}

Lines 203-209 Link Here

(-)src/xalanc/DOMSupport/DOMServices.hpp (-1 / +1 lines)
203	append(data, text.getData());	203	append(data, text.getData());
204	}	204	}
205		205
206	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const unsigned int);	206	typedef void (FormatterListener::MemberFunctionPtr)(const XMLCh const, const FormatterListener::size_type);
207		207
208	/**	208	/**
209	* Sends the data for a node to a FormatterListener	209	* Sends the data for a node to a FormatterListener

Lines 207-213 Link Here

(-)Tests/Conf/conf.cpp (-1 / +8 lines)
207		207
208	XercesDOMParser theParser(0, &mgr);	208	XercesDOMParser theParser(0, &mgr);
209		209
		210	#if XERCES_VERSION_MAJOR < 3
210	theParser.setDoValidation(true);	211	theParser.setDoValidation(true);
		212	#else
		213	theParser.setValidationScheme(XercesDOMParser::Val_Auto);
		214	#endif
		215
211	theParser.setDoNamespaces(true);	216	theParser.setDoNamespaces(true);
212		217
213	theParser.parse(xmlInput);	218	theParser.parse(xmlInput);
Lines 308-314 Link Here
308	//	313	//
309	const XalanDOMString& currentDir = dirs[j];	314	const XalanDOMString& currentDir = dirs[j];
310		315
311	if (length(h.args.sub) == 0 \|\| equals(currentDir, h.args.sub) == true)	316	if ((length(h.args.sub) == 0 \|\|
		317	equals(currentDir, h.args.sub) == true) &&
		318	currentDir[0] != XalanUnicode::charFullStop)
312	{	319	{
313	// Check that output directory is there.	320	// Check that output directory is there.
314	//	321	//

Lines 96-102 Link Here

(-)samples/SimpleTransform/XalanMemoryManagerImpl.hpp (-1 / +7 lines)
96		96
97	}	97	}
98		98
99	virtual	99	MemoryManager*
		100	getExceptionMemoryManager()
		101	{
		102	return this;
		103	}
		104
		105	virtual
100	~XalanMemoryManagerImpl()	106	~XalanMemoryManagerImpl()
101	{	107	{
102	if( 0 == HeapDestroy(m_heapHandle) )	108	if( 0 == HeapDestroy(m_heapHandle) )

Return to bug 242218

Lines 928-936 Link Here

(-)src/xalanc/XSLT/StylesheetExecutionContextDefault.cpp (-6 / +6 lines)
928		928
929	void	929	void
930	StylesheetExecutionContextDefault::characters(	930	StylesheetExecutionContextDefault::characters(
931	const XalanDOMChar* ch,	931	const XalanDOMChar* ch,
932	XalanDOMString::size_type start,	932	fl_size_type start,
933	XalanDOMString::size_type length)	933	fl_size_type length)
934	{	934	{
935	assert(m_xsltProcessor != 0);	935	assert(m_xsltProcessor != 0);
936		936
Lines 941-949 Link Here
941		941
942	void	942	void
943	StylesheetExecutionContextDefault::charactersRaw(	943	StylesheetExecutionContextDefault::charactersRaw(
944	const XalanDOMChar* ch,	944	const XalanDOMChar* ch,
945	XalanDOMString::size_type start,	945	fl_size_type start,
946	XalanDOMString::size_type length)	946	fl_size_type length)
947	{	947	{
948	assert(m_xsltProcessor != 0);	948	assert(m_xsltProcessor != 0);
949		949

Lines 109-115 Link Here

(-)src/xalanc/PlatformSupport/AttributesImpl.cpp (-12 / +57 lines)
109	// until we're done.	109	// until we're done.
110	AttributesVectorType tempVector(getMemoryManager());	110	AttributesVectorType tempVector(getMemoryManager());
111		111
112	const unsigned int theLength = theRHS.getLength();	112	const XalanSize_t theLength = theRHS.getLength();
113		113
114	if (theLength > 0)	114	if (theLength > 0)
115	{	115	{
Lines 167-178 Link Here
167	// safe and don't need any try blocks.	167	// safe and don't need any try blocks.
168	AttributesImpl theTempList(getMemoryManager());	168	AttributesImpl theTempList(getMemoryManager());
169		169
170	const unsigned int theLength = theRHS.getLength();	170	const XalanSize_t theLength = theRHS.getLength();
171		171
172	theTempList.reserve(theLength);	172	theTempList.reserve(theLength);
173		173
174	// Add each attribute.	174	// Add each attribute.
175	for(unsigned int i = 0; i < theLength; i++)	175	for(XalanSize_t i = 0; i < theLength; i++)
176	{	176	{
177	theTempList.addAttribute(	177	theTempList.addAttribute(
178	theRHS.getURI(i),	178	theRHS.getURI(i),
Lines 192-198 Link Here
192		192
193		193
194		194
195	unsigned int	195	XalanSize_t
196	AttributesImpl::getLength() const	196	AttributesImpl::getLength() const
197	{	197	{
198	return unsigned(m_attributesVector.size());	198	return unsigned(m_attributesVector.size());
Lines 201-207 Link Here
201		201
202		202
203	const XMLCh*	203	const XMLCh*
204	AttributesImpl::getURI(const unsigned int index) const	204	AttributesImpl::getURI(const XalanSize_t index) const
205	{	205	{
206	assert(index < getLength());	206	assert(index < getLength());
207		207
Lines 211-217 Link Here
211		211
212		212
213	const XMLCh*	213	const XMLCh*
214	AttributesImpl::getLocalName(const unsigned int index) const	214	AttributesImpl::getLocalName(const XalanSize_t index) const
215	{	215	{
216	assert(index < getLength());	216	assert(index < getLength());
217		217
Lines 221-227 Link Here
221		221
222		222
223	const XMLCh*	223	const XMLCh*
224	AttributesImpl::getQName(const unsigned int index) const	224	AttributesImpl::getQName(const XalanSize_t index) const
225	{	225	{
226	assert(index < getLength());	226	assert(index < getLength());
227		227
Lines 231-237 Link Here
231		231
232		232
233	const XMLCh*	233	const XMLCh*
234	AttributesImpl::getType(const unsigned int index) const	234	AttributesImpl::getType(const XalanSize_t index) const
235	{	235	{
236	assert(index < getLength());	236	assert(index < getLength());
237		237
Lines 241-247 Link Here
241		241
242		242
243	const XMLCh*	243	const XMLCh*
244	AttributesImpl::getValue(const unsigned int index) const	244	AttributesImpl::getValue(const XalanSize_t index) const
245	{	245	{
246	assert(index < getLength());	246	assert(index < getLength());
247		247
Lines 380-397 Link Here
380		380
381		381
382		382
		383	bool
		384	AttributesImpl::getIndex(
		385	const XMLCh* const uri,
		386	const XMLCh* const localPart,
		387	XalanSize_t& index) const
		388	{
		389	const int tempIndex =
		390	getIndex(uri, localPart);
		391
		392	if (tempIndex == -1)
		393	{
		394	return false;
		395	}
		396	else
		397	{
		398	index = tempIndex;
		399
		400	return true;
		401	}
		402	}
		403
		404
		405
383	int	406	int
384	AttributesImpl::getIndex(	407	AttributesImpl::getIndex(
385	const XMLCh* const uri,	408	const XMLCh* const uri,
386	const XMLCh* const localName) const	409	const XMLCh* const localPart) const
387	{	410	{
388	assert(uri != 0 && localName != 0);	411	assert(uri != 0 && localPart != 0);
389		412
390	const AttributesVectorType::const_iterator i =	413	const AttributesVectorType::const_iterator i =
391	XALAN_STD_QUALIFIER find_if(	414	XALAN_STD_QUALIFIER find_if(
392	m_attributesVector.begin(),	415	m_attributesVector.begin(),
393	m_attributesVector.end(),	416	m_attributesVector.end(),
394	URIAndLocalNameCompareFunctor(uri, localName));	417	URIAndLocalNameCompareFunctor(uri, localPart));
395		418
396	if (i != m_attributesVector.end())	419	if (i != m_attributesVector.end())
397	{	420	{
Lines 407-412 Link Here
407		430
408		431
409		432
		433	bool
		434	AttributesImpl::getIndex(
		435	const XMLCh* const qName,
		436	XalanSize_t& index) const
		437	{
		438	const int tempIndex =
		439	getIndex(qName);
		440
		441	if (tempIndex == -1)
		442	{
		443	return false;
		444	}
		445	else
		446	{
		447	index = tempIndex;
		448
		449	return true;
		450	}
		451	}
		452
		453
		454
410	int	455	int
411	AttributesImpl::getIndex(const XMLCh* const qname) const	456	AttributesImpl::getIndex(const XMLCh* const qname) const
412	{	457	{

Lines 43-55 Link Here

(-)src/xalanc/PlatformSupport/NamedNodeMapAttributeList.cpp (-8 / +12 lines)
43		43
44		44
45		45
46	NamedNodeMapAttributeList::NamedNodeMapAttributeList(const XalanNamedNodeMap& theMap,	46	NamedNodeMapAttributeList::NamedNodeMapAttributeList(
47	MemoryManagerType& theManager) :	47	const XalanNamedNodeMap& theMap,
		48	MemoryManagerType& theManager) :
48	ParentType(),	49	ParentType(),
49	m_nodeMap(theMap),	50	m_nodeMap(theMap),
50	m_lastIndex(theMap.getLength() - 1),	51	m_lastIndex(theMap.getLength() - 1),
51	m_memoryManager(theManager)	52	m_memoryManager(theManager)
52	{	53	{
		54	assert(theMap.getLength() != 0);
53	}	55	}
54		56
55		57
Lines 60-66 Link Here
60		62
61		63
62		64
63	unsigned int	65	XalanSize_t
64	NamedNodeMapAttributeList::getLength() const	66	NamedNodeMapAttributeList::getLength() const
65	{	67	{
66	return m_nodeMap.getLength();	68	return m_nodeMap.getLength();
Lines 69-75 Link Here
69		71
70		72
71	const XMLCh*	73	const XMLCh*
72	NamedNodeMapAttributeList::getName(const unsigned int index) const	74	NamedNodeMapAttributeList::getName(const XalanSize_t index) const
73	{	75	{
74	const XalanNode* const theAttribute = m_nodeMap.item(m_lastIndex - index);	76	const XalanNode* const theAttribute = m_nodeMap.item(m_lastIndex - index);
75	assert(theAttribute != 0);	77	assert(theAttribute != 0);
Lines 80-86 Link Here
80		82
81		83
82	const XMLCh*	84	const XMLCh*
83	NamedNodeMapAttributeList::getType(const unsigned int /* index */) const	85	NamedNodeMapAttributeList::getType(const XalanSize_t /* index */) const
84	{	86	{
85	assert(length(s_typeString) > 0);	87	assert(length(s_typeString) > 0);
86		88
Lines 90-98 Link Here
90		92
91		93
92	const XMLCh*	94	const XMLCh*
93	NamedNodeMapAttributeList::getValue(const unsigned int index) const	95	NamedNodeMapAttributeList::getValue(const XalanSize_t index) const
94	{	96	{
95	const XalanNode* const theAttribute = m_nodeMap.item(m_lastIndex - index);	97	assert(index <= m_lastIndex);
		98
		99	const XalanNode* const theAttribute = m_nodeMap.item(m_lastIndex - index);
96	assert(theAttribute != 0);	100	assert(theAttribute != 0);
97		101
98	return c_wstr(theAttribute->getNodeValue());	102	return c_wstr(theAttribute->getNodeValue());
Lines 111-117 Link Here
111		115
112		116
113	const XMLCh*	117	const XMLCh*
114	NamedNodeMapAttributeList::getValue(const XMLCh* const name) const	118	NamedNodeMapAttributeList::getValue(const XMLCh* const name) const
115	{	119	{
116	const XalanNode* theNode = m_nodeMap.getNamedItem(XalanDOMString(name, m_memoryManager));	120	const XalanNode* theNode = m_nodeMap.getNamedItem(XalanDOMString(name, m_memoryManager));
117		121

Lines 43-49 Link Here

(-)src/xalanc/PlatformSupport/StdBinInputStream.cpp (-3 / +11 lines)
43		43
44		44
45		45
46	unsigned int	46	XalanFilePos
47	StdBinInputStream::curPos() const	47	StdBinInputStream::curPos() const
48	{	48	{
49	return m_stream.tellg();	49	return m_stream.tellg();
Lines 51-60 Link Here
51		51
52		52
53		53
54	unsigned int	54	XalanSize_t
55	StdBinInputStream::readBytes(	55	StdBinInputStream::readBytes(
56	XMLByte* const toFill,	56	XMLByte* const toFill,
57	const unsigned int maxToRead)	57	const XalanSize_t maxToRead)
58	{	58	{
59	assert(sizeof(XMLByte) == sizeof(char));	59	assert(sizeof(XMLByte) == sizeof(char));
60		60
Lines 80-83 Link Here
80		80
81		81
82		82
		83	const XalanDOMChar*
		84	StdBinInputStream::getContentType() const
		85	{
		86	return 0;
		87	}
		88
		89
		90
83	XALAN_CPP_NAMESPACE_END	91	XALAN_CPP_NAMESPACE_END

Lines 73-89 Link Here

(-)src/xalanc/PlatformSupport/AttributeListImpl.hpp (-5 / +5 lines)
73	}	73	}
74		74
75	// These are inherited from AttributeList	75	// These are inherited from AttributeList
76	virtual unsigned int	76	virtual XalanSize_t
77	getLength() const;	77	getLength() const;
78		78
79	virtual const XMLCh*	79	virtual const XMLCh*
80	getName(const unsigned int index) const;	80	getName(const XalanSize_t index) const;
81		81
82	virtual const XMLCh*	82	virtual const XMLCh*
83	getType(const unsigned int index) const;	83	getType(const XalanSize_t index) const;
84		84
85	virtual const XMLCh*	85	virtual const XMLCh*
86	getValue(const unsigned int index) const;	86	getValue(const XalanSize_t index) const;
87		87
88	virtual const XMLCh*	88	virtual const XMLCh*
89	getType(const XMLCh* const name) const;	89	getType(const XMLCh* const name) const;
Lines 141-147 Link Here
141	* @param theCount The number to reserve	141	* @param theCount The number to reserve
142	*/	142	*/
143	void	143	void
144	reserve(unsigned int theCount)	144	reserve(XalanSize_t theCount)
145	{	145	{
146	m_AttributeVector.reserve(theCount);	146	m_AttributeVector.reserve(theCount);
147	}	147	}

Lines 40-47 Link Here

(-)src/xalanc/PlatformSupport/XSLException.hpp (-5 / +2 lines)
40	{	40	{
41	public:	41	public:
42		42
43	typedef XalanLocator::size_type size_type;
44
45	/**	43	/**
46	* Constructor	44	* Constructor
47	*	45	*
Lines 119-125 Link Here
119	*	117	*
120	* @return the line number	118	* @return the line number
121	*/	119	*/
122	size_type	120	XalanFileLoc
123	getLineNumber() const	121	getLineNumber() const
124	{	122	{
125	return m_lineNumber;	123	return m_lineNumber;
Lines 130-142 Link Here
130	*	128	*
131	* @return the column number	129	* @return the column number
132	*/	130	*/
133	size_type	131	XalanFileLoc
134	getColumnNumber() const	132	getColumnNumber() const
135	{	133	{
136	return m_columnNumber;	134	return m_columnNumber;
137	}	135	}
138		136
139
140	MemoryManagerType&	137	MemoryManagerType&
141	getMemoryManager()const	138	getMemoryManager()const
142	{	139	{

Lines 45-52 Link Here

(-)src/xalanc/PlatformSupport/XalanLocator.hpp (-10 / +8 lines)
45		45
46	typedef Locator ParentType;	46	typedef Locator ParentType;
47		47
48	typedef XMLSSize_t size_type;
49
50	XalanLocator() {}	48	XalanLocator() {}
51		49
52	virtual	50	virtual
Lines 58-85 Link Here
58	virtual const XMLCh*	56	virtual const XMLCh*
59	getSystemId() const = 0;	57	getSystemId() const = 0;
60		58
61	virtual size_type	59	virtual XalanFileLoc
62	getLineNumber() const = 0;	60	getLineNumber() const = 0;
63		61
64	virtual size_type	62	virtual XalanFileLoc
65	getColumnNumber() const = 0;	63	getColumnNumber() const = 0;
66		64
67	static size_type	65	static XalanFileLoc
68	getLineNumber(const ParentType* theLocator)	66	getLineNumber(const ParentType* theLocator)
69	{	67	{
70	return theLocator == 0 ? size_type(-1) : theLocator->getLineNumber();	68	return theLocator == 0 ? getUnknownValue() : theLocator->getLineNumber();
71	}	69	}
72		70
73	static size_type	71	static XalanFileLoc
74	getColumnNumber(const ParentType* theLocator)	72	getColumnNumber(const ParentType* theLocator)
75	{	73	{
76	return theLocator == 0 ? size_type(-1) : theLocator->getColumnNumber();	74	return theLocator == 0 ? getUnknownValue() : theLocator->getColumnNumber();
77	}	75	}
78		76
79	static size_type	77	static XalanFileLoc
80	getUnknownValue()	78	getUnknownValue()
81	{	79	{
82	return size_type(-1);	80	return XalanFileLoc(-1);
83	}	81	}
84		82
85	private:	83	private:

Lines 43-66 Link Here

(-)src/xalanc/PlatformSupport/NamedNodeMapAttributeList.hpp (-9 / +10 lines)
43	typedef XERCES_CPP_NAMESPACE_QUALIFIER AttributeList ParentType;	43	typedef XERCES_CPP_NAMESPACE_QUALIFIER AttributeList ParentType;
44		44
45	explicit	45	explicit
46	NamedNodeMapAttributeList(const XalanNamedNodeMap& theMap,	46	NamedNodeMapAttributeList(
47	MemoryManagerType& theManager);	47	const XalanNamedNodeMap& theMap,
		48	MemoryManagerType& theManager);
48		49
49	virtual	50	virtual
50	~NamedNodeMapAttributeList();	51	~NamedNodeMapAttributeList();
51		52
52	// These are inherited from AttributeList	53	// These are inherited from AttributeList
53	virtual unsigned int	54	virtual XalanSize_t
54	getLength() const;	55	getLength() const;
55		56
56	virtual const XalanDOMChar*	57	virtual const XalanDOMChar*
57	getName(const unsigned int index) const;	58	getName(const XalanSize_t index) const;
58		59
59	virtual const XalanDOMChar*	60	virtual const XalanDOMChar*
60	getType(const unsigned int index) const;	61	getType(const XalanSize_t index) const;
61		62
62	virtual const XalanDOMChar*	63	virtual const XalanDOMChar*
63	getValue(const unsigned int index) const;	64	getValue(const XalanSize_t index) const;
64		65
65	virtual const XalanDOMChar*	66	virtual const XalanDOMChar*
66	getType(const XalanDOMChar* const name) const;	67	getType(const XalanDOMChar* const name) const;
Lines 83-93 Link Here
83	// Data members...	84	// Data members...
84	const XalanNamedNodeMap& m_nodeMap;	85	const XalanNamedNodeMap& m_nodeMap;
85		86
86	const unsigned int m_lastIndex;	87	const XalanSize_t m_lastIndex;
87		88
		89	MemoryManagerType& m_memoryManager;
		90
88	static const XalanDOMChar s_typeString[];	91	static const XalanDOMChar s_typeString[];
89
90	MemoryManagerType& m_memoryManager;
91	};	92	};
92		93
93		94

Lines 65-95 Link Here

(-)src/xalanc/PlatformSupport/AttributesImpl.hpp (-11 / +22 lines)
65	AttributesImpl&	65	AttributesImpl&
66	operator=(const AttributesType& theRHS);	66	operator=(const AttributesType& theRHS);
67		67
68	// These are inherited from AttributeList	68	// These are inherited from Attributes
69	virtual unsigned int	69	virtual XalanSize_t
70	getLength() const;	70	getLength() const;
71		71
72	virtual const XMLCh*	72	virtual const XMLCh*
73	getURI(const unsigned int index) const;	73	getURI(const XalanSize_t index) const;
74		74
75	virtual const XMLCh*	75	virtual const XMLCh*
76	getLocalName(const unsigned int index) const;	76	getLocalName(const XalanSize_t index) const;
77		77
78	virtual const XMLCh*	78	virtual const XMLCh*
79	getQName(const unsigned int index) const;	79	getQName(const XalanSize_t index) const;
80		80
81	virtual const XMLCh*	81	virtual const XMLCh*
82	getType(const unsigned int index) const;	82	getType(const XalanSize_t index) const;
83		83
84	virtual const XMLCh*	84	virtual const XMLCh*
85	getValue(const unsigned int index) const;	85	getValue(const XalanSize_t index) const;
86		86
87	virtual int	87	virtual bool
		88	getIndex(
		89	const XMLCh* const uri,
		90	const XMLCh* const localPart,
		91	XalanSize_t& index) const;
		92
		93	virtual int
88	getIndex(	94	getIndex(
89	const XMLCh* const uri,	95	const XMLCh* const uri,
90	const XMLCh* const localName) const;	96	const XMLCh* const localPart) const;
91		97
92	virtual int	98	virtual bool
		99	getIndex(
		100	const XMLCh* const qName,
		101	XalanSize_t& index) const;
		102
		103	virtual int
93	getIndex(const XMLCh* const qname) const;	104	getIndex(const XMLCh* const qname) const;
94		105
95	virtual const XMLCh*	106	virtual const XMLCh*
Lines 186-192 Link Here
186	* @param theCount The number to reserve	197	* @param theCount The number to reserve
187	*/	198	*/
188	void	199	void
189	reserve(unsigned int theCount)	200	reserve(XalanSize_t theCount)
190	{	201	{
191	m_attributesVector.reserve(theCount);	202	m_attributesVector.reserve(theCount);
192	}	203	}

Lines 120-125 Link Here

(-)src/xalanc/Include/PlatformDefinitions.hpp (+10 lines)
120	typedef unsigned short XalanDOMChar;	120	typedef unsigned short XalanDOMChar;
121	#endif	121	#endif
122		122
		123	#if XERCES_VERSION_MAJOR < 3
		124	typedef unsigned int XalanSize_t;
		125	typedef unsigned int XalanFilePos;
		126	typedef unsigned int XalanFileLoc;
		127	#else
		128	typedef XMLSize_t XalanSize_t;
		129	typedef XMLFilePos XalanFilePos;
		130	typedef XMLFileLoc XalanFileLoc;
		131	#endif
		132
123	template<bool value>	133	template<bool value>
124	struct XalanCompileErrorBoolean	134	struct XalanCompileErrorBoolean
125	{	135	{

Lines 492-499 Link Here

(-)src/xalanc/XPath/XPathExecutionContextDefault.cpp (-6 / +6 lines)
492	{	492	{
493	assert(m_xpathEnvSupport != 0);	493	assert(m_xpathEnvSupport != 0);
494		494
495	XalanLocator::size_type lineNumber = XalanLocator::getUnknownValue();	495	XalanFileLoc lineNumber = XalanLocator::getUnknownValue();
496	XalanLocator::size_type columnNumber = XalanLocator::getUnknownValue();	496	XalanFileLoc columnNumber = XalanLocator::getUnknownValue();
497		497
498	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();	498	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();
499		499
Lines 546-553 Link Here
546	{	546	{
547	assert(m_xpathEnvSupport != 0);	547	assert(m_xpathEnvSupport != 0);
548		548
549	XalanLocator::size_type lineNumber = XalanLocator::getUnknownValue();	549	XalanFileLoc lineNumber = XalanLocator::getUnknownValue();
550	XalanLocator::size_type columnNumber = XalanLocator::getUnknownValue();	550	XalanFileLoc columnNumber = XalanLocator::getUnknownValue();
551		551
552	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();	552	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();
553		553
Lines 600-607 Link Here
600	{	600	{
601	assert(m_xpathEnvSupport != 0);	601	assert(m_xpathEnvSupport != 0);
602		602
603	XalanLocator::size_type lineNumber = XalanLocator::getUnknownValue();	603	XalanFileLoc lineNumber = XalanLocator::getUnknownValue();
604	XalanLocator::size_type columnNumber = XalanLocator::getUnknownValue();	604	XalanFileLoc columnNumber = XalanLocator::getUnknownValue();
605		605
606	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();	606	MemoryManagerType& theManager = const_cast<XPathExecutionContextDefault*>(this)->getMemoryManager();
607		607

Lines 76-83 Link Here

(-)src/xalanc/XPath/FormatterStringLengthCounter.cpp (-8 / +8 lines)
76		76
77	void	77	void
78	FormatterStringLengthCounter::characters(	78	FormatterStringLengthCounter::characters(
79	const XMLCh* const /* chars */,	79	const XMLCh* const /* chars */,
80	const unsigned int length)	80	const size_type length)
81	{	81	{
82	m_count += length;	82	m_count += length;
83	}	83	}
Lines 86-93 Link Here
86		86
87	void	87	void
88	FormatterStringLengthCounter::charactersRaw(	88	FormatterStringLengthCounter::charactersRaw(
89	const XMLCh* const /* chars */,	89	const XMLCh* const /* chars */,
90	const unsigned int /length /)	90	const size_type /length /)
91	{	91	{
92	}	92	}
93		93
Lines 101-108 Link Here
101		101
102	void	102	void
103	FormatterStringLengthCounter::ignorableWhitespace(	103	FormatterStringLengthCounter::ignorableWhitespace(
104	const XMLCh* const /* chars */,	104	const XMLCh* const /* chars */,
105	const unsigned int /* length */)	105	const size_type /* length */)
106	{	106	{
107	}	107	}
108		108
Lines 133-140 Link Here
133		133
134	void	134	void
135	FormatterStringLengthCounter::cdata(	135	FormatterStringLengthCounter::cdata(
136	const XMLCh* const /* ch */,	136	const XMLCh* const /* ch */,
137	const unsigned int /* length */)	137	const size_type /* length */)
138	{	138	{
139	}	139	}
140		140

Lines 123-142 Link Here

(-)src/xalanc/XPath/XPathConstructionContext.hpp (-13 / +9 lines)
123	{	123	{
124	}	124	}
125		125
126	// Note non-const copy semantics...
127	GetAndReleaseCachedString(GetAndReleaseCachedString& theSource) :
128	m_constructionContext(theSource.m_constructionContext),
129	m_string(theSource.m_string)
130	{
131	theSource.m_string = 0;
132	}
133
134	~GetAndReleaseCachedString()	126	~GetAndReleaseCachedString()
135	{	127	{
136	if (m_string != 0)	128	assert(m_string != 0);
137	{	129
138	m_constructionContext->releaseCachedString(*m_string);	130	m_constructionContext->releaseCachedString(*m_string);
139	}
140	}	131	}
141		132
142	XalanDOMString&	133	XalanDOMString&
Lines 150-162 Link Here
150	XPathConstructionContext&	141	XPathConstructionContext&
151	getConstructionContext() const	142	getConstructionContext() const
152	{	143	{
		144	assert(m_constructionContext != 0);
		145
153	return *m_constructionContext;	146	return *m_constructionContext;
154	}	147	}
155		148
156
157	private:	149	private:
158		150
159	// Not implemented...	151	// Not implemented...
		152	GetAndReleaseCachedString();
		153
		154	GetAndReleaseCachedString(const GetAndReleaseCachedString&);
		155
160	GetAndReleaseCachedString&	156	GetAndReleaseCachedString&
161	operator=(const GetAndReleaseCachedString&);	157	operator=(const GetAndReleaseCachedString&);
162		158

Lines 212-227 Link Here

(-)src/xalanc/XPath/XPathProcessorImpl.cpp (-31 / +33 lines)
212		212
213	m_expression->setCurrentPattern(m_constructionContext->getPooledString(pat));	213	m_expression->setCurrentPattern(m_constructionContext->getPooledString(pat));
214		214
215	const int nChars = length(pat);	215	const t_size_type nChars = length(pat);
216		216
217	int startSubstring = -1;	217	t_size_type startSubstring = XalanDOMString::npos;
218	int posOfNSSep = -1;	218	t_size_type posOfNSSep = XalanDOMString::npos;
219		219
220	const XPathConstructionContext::GetAndReleaseCachedString theGuard(*m_constructionContext);	220	const XPathConstructionContext::GetAndReleaseCachedString theGuard(*m_constructionContext);
221		221
222	XalanDOMString& theToken = theGuard.get();	222	XalanDOMString& theToken = theGuard.get();
223		223
224	for(int i = 0; i < nChars; i++)	224	for(t_size_type i = 0; i < nChars; i++)
225	{	225	{
226	XalanDOMChar c = charAt(pat, i);	226	XalanDOMChar c = charAt(pat, i);
227		227
Lines 229-237 Link Here
229	{	229	{
230	case XalanUnicode::charQuoteMark:	230	case XalanUnicode::charQuoteMark:
231	{	231	{
232	if(startSubstring != -1)	232	if(startSubstring != XalanDOMString::npos)
233	{	233	{
234	if(-1 != posOfNSSep)	234	if(XalanDOMString::npos != posOfNSSep)
235	{	235	{
236	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);	236	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
237	}	237	}
Lines 253-259 Link Here
253		253
254	addToTokenQueue(theToken);	254	addToTokenQueue(theToken);
255		255
256	startSubstring = -1;	256	startSubstring = XalanDOMString::npos;
257	}	257	}
258	else	258	else
259	{	259	{
Lines 264-272 Link Here
264		264
265	case XalanUnicode::charApostrophe:	265	case XalanUnicode::charApostrophe:
266	{	266	{
267	if(startSubstring != -1)	267	if(startSubstring != XalanDOMString::npos)
268	{	268	{
269	if(-1 != posOfNSSep)	269	if(XalanDOMString::npos != posOfNSSep)
270	{	270	{
271	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);	271	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
272	}	272	}
Lines 288-294 Link Here
288		288
289	addToTokenQueue(theToken);	289	addToTokenQueue(theToken);
290		290
291	startSubstring = -1;	291	startSubstring = XalanDOMString::npos;
292	}	292	}
293	else	293	else
294	{	294	{
Lines 302-310 Link Here
302	case XalanUnicode::charSpace:	302	case XalanUnicode::charSpace:
303	case XalanUnicode::charHTab:	303	case XalanUnicode::charHTab:
304	{	304	{
305	if(startSubstring != -1)	305	if(startSubstring != XalanDOMString::npos)
306	{	306	{
307	if(-1 != posOfNSSep)	307	if(XalanDOMString::npos != posOfNSSep)
308	{	308	{
309	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);	309	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
310	}	310	}
Lines 315-328 Link Here
315	addToTokenQueue(theToken);	315	addToTokenQueue(theToken);
316	}	316	}
317		317
318	startSubstring = -1;	318	startSubstring = XalanDOMString::npos;
319	}	319	}
320	}	320	}
321	break;	321	break;
322		322
323	case XalanUnicode::charHyphenMinus:	323	case XalanUnicode::charHyphenMinus:
324	{	324	{
325	if(!(startSubstring == -1))	325	if(!(startSubstring == XalanDOMString::npos))
326	{	326	{
327	break;	327	break;
328	}	328	}
Lines 347-355 Link Here
347	case XalanUnicode::charLessThanSign:	347	case XalanUnicode::charLessThanSign:
348	case XalanUnicode::charGreaterThanSign:	348	case XalanUnicode::charGreaterThanSign:
349	{	349	{
350	if(startSubstring != -1)	350	if(startSubstring != XalanDOMString::npos)
351	{	351	{
352	if(-1 != posOfNSSep)	352	if(XalanDOMString::npos != posOfNSSep)
353	{	353	{
354	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);	354	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, i);
355	}	355	}
Lines 360-366 Link Here
360	addToTokenQueue(theToken);	360	addToTokenQueue(theToken);
361	}	361	}
362		362
363	startSubstring = -1;	363	startSubstring = XalanDOMString::npos;
364	}	364	}
365		365
366	substring(pat, theToken, i, i + 1);	366	substring(pat, theToken, i, i + 1);
Lines 373-379 Link Here
373	{	373	{
374	if(posOfNSSep == i - 1 && i > 0)	374	if(posOfNSSep == i - 1 && i > 0)
375	{	375	{
376	if(startSubstring != -1)	376	if(startSubstring != XalanDOMString::npos)
377	{	377	{
378	if (startSubstring < i - 1)	378	if (startSubstring < i - 1)
379	{	379	{
Lines 383-390 Link Here
383	}	383	}
384	}	384	}
385		385
386	startSubstring = -1;	386	startSubstring = XalanDOMString::npos;
387	posOfNSSep = -1;	387	posOfNSSep = XalanDOMString::npos;
388		388
389	substring(pat, theToken, i - 1, i + 1);	389	substring(pat, theToken, i - 1, i + 1);
390		390
Lines 401-407 Link Here
401		401
402	default:	402	default:
403	{	403	{
404	if(-1 == startSubstring)	404	if(XalanDOMString::npos == startSubstring)
405	{	405	{
406	startSubstring = i;	406	startSubstring = i;
407		407
Lines 440-455 Link Here
440		440
441	addToTokenQueue(theToken);	441	addToTokenQueue(theToken);
442		442
443	startSubstring = -1;	443	startSubstring = XalanDOMString::npos;
444	}	444	}
445	}	445	}
446	}	446	}
447	}	447	}
448	}	448	}
449		449
450	if(startSubstring != -1)	450	if(startSubstring != XalanDOMString::npos)
451	{	451	{
452	if(-1 != posOfNSSep)	452	if(XalanDOMString::npos != posOfNSSep)
453	{	453	{
454	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, nChars);	454	posOfNSSep = mapNSTokens(pat, startSubstring, posOfNSSep, nChars);
455	}	455	}
Lines 504-515 Link Here
504		504
505		505
506		506
507	int	507	XPathProcessorImpl::t_size_type
508	XPathProcessorImpl::mapNSTokens(	508	XPathProcessorImpl::mapNSTokens(
509	const XalanDOMString& pat,	509	const XalanDOMString& pat,
510	int startSubstring,	510	t_size_type startSubstring,
511	int posOfNSSep,	511	t_size_type posOfNSSep,
512	int posOfScan)	512	t_size_type posOfScan)
513	{	513	{
514	assert(m_prefixResolver != 0);	514	assert(m_prefixResolver != 0);
515		515
Lines 575-581 Link Here
575	}	575	}
576	}	576	}
577		577
578	return -1;	578	return XalanDOMString::npos;
579	}	579	}
580		580
581		581
Lines 2938-2951 Link Here
2938	bool	2938	bool
2939	XPathProcessorImpl::isCurrentLiteral() const	2939	XPathProcessorImpl::isCurrentLiteral() const
2940	{	2940	{
2941	const int last = length(m_token) - 1;	2941	const t_size_type theLength = m_token.length();
2942		2942
2943	if (last <= 0)	2943	if (theLength <= 1)
2944	{	2944	{
2945	return false;	2945	return false;
2946	}	2946	}
2947	else	2947	else
2948	{	2948	{
		2949	const t_size_type last = theLength - 1;
		2950
2949	const XalanDOMChar c0 = m_tokenChar;	2951	const XalanDOMChar c0 = m_tokenChar;
2950	const XalanDOMChar cX = charAt(m_token, last);	2952	const XalanDOMChar cX = charAt(m_token, last);
2951		2953

Lines 48-64 Link Here

(-)src/xalanc/XercesParserLiaison/XercesNamedNodeMapAttributeList.hpp (-5 / +5 lines)
48	~XercesNamedNodeMapAttributeList();	48	~XercesNamedNodeMapAttributeList();
49		49
50	// These are inherited from AttributeList	50	// These are inherited from AttributeList
51	virtual unsigned int	51	virtual XalanSize_t
52	getLength() const;	52	getLength() const;
53		53
54	virtual const XMLCh*	54	virtual const XMLCh*
55	getName(const unsigned int index) const;	55	getName(const XalanSize_t index) const;
56		56
57	virtual const XMLCh*	57	virtual const XMLCh*
58	getType(const unsigned int index) const;	58	getType(const XalanSize_t index) const;
59		59
60	virtual const XMLCh*	60	virtual const XMLCh*
61	getValue(const unsigned int index) const;	61	getValue(const XalanSize_t index) const;
62		62
63	virtual const XMLCh*	63	virtual const XMLCh*
64	getType(const XMLCh* const name) const;	64	getType(const XMLCh* const name) const;
Lines 81-87 Link Here
81	// Data members...	81	// Data members...
82	const DOMNamedNodeMapType* const m_nodeMap;	82	const DOMNamedNodeMapType* const m_nodeMap;
83		83
84	const XMLSizeType m_lastIndex;	84	const XalanSize_t m_lastIndex;
85		85
86	static const XMLCh s_typeString[];	86	static const XMLCh s_typeString[];
87	};	87	};

Lines 191-197 Link Here

(-)src/xalanc/XercesParserLiaison/FormatterToXercesDOM.cpp (-4 / +4 lines)
191	void	191	void
192	FormatterToXercesDOM::characters(	192	FormatterToXercesDOM::characters(
193	const XMLCh* const chars,	193	const XMLCh* const chars,
194	const unsigned int length)	194	const size_type length)
195	{	195	{
196	m_textBuffer.append(chars, length);	196	m_textBuffer.append(chars, length);
197	}	197	}
Lines 201-207 Link Here
201	void	201	void
202	FormatterToXercesDOM::charactersRaw(	202	FormatterToXercesDOM::charactersRaw(
203	const XMLCh* const chars,	203	const XMLCh* const chars,
204	const unsigned int length)	204	const size_type length)
205	{	205	{
206	try	206	try
207	{	207	{
Lines 237-243 Link Here
237	void	237	void
238	FormatterToXercesDOM::ignorableWhitespace(	238	FormatterToXercesDOM::ignorableWhitespace(
239	const XMLCh* const chars,	239	const XMLCh* const chars,
240	const unsigned int length)	240	const size_type length)
241	{	241	{
242	try	242	try
243	{	243	{
Lines 301-307 Link Here
301	void	301	void
302	FormatterToXercesDOM::cdata(	302	FormatterToXercesDOM::cdata(
303	const XMLCh* const ch,	303	const XMLCh* const ch,
304	const unsigned int length)	304	const size_type length)
305	{	305	{
306	try	306	try
307	{	307	{

Lines 82-93 Link Here

(-)src/xalanc/XercesParserLiaison/FormatterToXercesDOM.hpp (-5 / +5 lines)
82	~FormatterToXercesDOM();	82	~FormatterToXercesDOM();
83		83
84		84
85	// These methods are inherited from DocumentHandler ...	85	// These methods are inherited from FormatterListener...
86		86
87	virtual void	87	virtual void
88	charactersRaw(	88	charactersRaw(
89	const XMLCh* const chars,	89	const XMLCh* const chars,
90	const unsigned int length);	90	const size_type length);
91		91
92	virtual void	92	virtual void
93	comment(const XMLCh* const data);	93	comment(const XMLCh* const data);
Lines 95-101 Link Here
95	virtual void	95	virtual void
96	cdata(	96	cdata(
97	const XMLCh* const ch,	97	const XMLCh* const ch,
98	const unsigned int length);	98	const size_type length);
99		99
100	virtual void	100	virtual void
101	entityReference(const XMLCh* const name);	101	entityReference(const XMLCh* const name);
Lines 120-131 Link Here
120	virtual void	120	virtual void
121	characters(	121	characters(
122	const XMLCh* const chars,	122	const XMLCh* const chars,
123	const unsigned int length);	123	const size_type length);
124		124
125	virtual void	125	virtual void
126	ignorableWhitespace(	126	ignorableWhitespace(
127	const XMLCh* const chars,	127	const XMLCh* const chars,
128	const unsigned int length);	128	const size_type length);
129		129
130	virtual void	130	virtual void
131	processingInstruction(	131	processingInstruction(

Lines 49-56 Link Here

(-)src/xalanc/XSLT/ElemCopyOf.cpp (-11 / +11 lines)
49	StylesheetConstructionContext& constructionContext,	49	StylesheetConstructionContext& constructionContext,
50	Stylesheet& stylesheetTree,	50	Stylesheet& stylesheetTree,
51	const AttributeListType& atts,	51	const AttributeListType& atts,
52	int lineNumber,	52	XalanFileLoc lineNumber,
53	int columnNumber) :	53	XalanFileLoc columnNumber) :
54	ElemTemplateElement(constructionContext,	54	ElemTemplateElement(constructionContext,
55	stylesheetTree,	55	stylesheetTree,
56	lineNumber,	56	lineNumber,
Lines 60-72 Link Here
60	{	60	{
61	bool isSelectCurrentNode = false;	61	bool isSelectCurrentNode = false;
62		62
63	const unsigned int nAttrs = atts.getLength();	63	const XalanSize_t nAttrs = atts.getLength();
64		64
65	for(unsigned int i = 0; i < nAttrs; ++i)	65	for (XalanSize_t i = 0; i < nAttrs; ++i)
66	{	66	{
67	const XalanDOMChar* const aname = atts.getName(i);	67	const XalanDOMChar* const aname = atts.getName(i);
68		68
69	if(equals(aname, Constants::ATTRNAME_SELECT))	69	if (equals(aname, Constants::ATTRNAME_SELECT))
70	{	70	{
71	const XalanDOMChar* const avalue = atts.getValue(i);	71	const XalanDOMChar* const avalue = atts.getValue(i);
72	assert(avalue != 0);	72	assert(avalue != 0);
Lines 80-86 Link Here
80	m_selectPattern = constructionContext.createXPath(getLocator(), avalue, *this);	80	m_selectPattern = constructionContext.createXPath(getLocator(), avalue, *this);
81	}	81	}
82	}	82	}
83	else if(isAttrOK(	83	else if (isAttrOK(
84	aname,	84	aname,
85	atts,	85	atts,
86	i,	86	i,
Lines 124-130 Link Here
124		124
125	if (m_selectPattern == 0)	125	if (m_selectPattern == 0)
126	{	126	{
127	if(0 != executionContext.getTraceListeners())	127	if (0 != executionContext.getTraceListeners())
128	{	128	{
129	StylesheetExecutionContext::BorrowReturnMutableNodeRefList theNodeList(executionContext);	129	StylesheetExecutionContext::BorrowReturnMutableNodeRefList theNodeList(executionContext);
130		130
Lines 147-153 Link Here
147	const XObjectPtr value(m_selectPattern->execute(*this, executionContext));	147	const XObjectPtr value(m_selectPattern->execute(*this, executionContext));
148	assert(value.null() == false);	148	assert(value.null() == false);
149		149
150	if(0 != executionContext.getTraceListeners())	150	if (0 != executionContext.getTraceListeners())
151	{	151	{
152	executionContext.fireSelectEvent(	152	executionContext.fireSelectEvent(
153	SelectionEvent(	153	SelectionEvent(
Lines 209-215 Link Here
209		209
210	if (m_selectPattern == 0)	210	if (m_selectPattern == 0)
211	{	211	{
212	if(0 != executionContext.getTraceListeners())	212	if (0 != executionContext.getTraceListeners())
213	{	213	{
214	StylesheetExecutionContext::BorrowReturnMutableNodeRefList theNodeList(executionContext);	214	StylesheetExecutionContext::BorrowReturnMutableNodeRefList theNodeList(executionContext);
215		215
Lines 232-238 Link Here
232	const XObjectPtr value(m_selectPattern->execute(*this, executionContext));	232	const XObjectPtr value(m_selectPattern->execute(*this, executionContext));
233	assert(value.null() == false);	233	assert(value.null() == false);
234		234
235	if(0 != executionContext.getTraceListeners())	235	if (0 != executionContext.getTraceListeners())
236	{	236	{
237	executionContext.fireSelectEvent(	237	executionContext.fireSelectEvent(
238	SelectionEvent(	238	SelectionEvent(
Lines 283-289 Link Here
283		283
284		284
285	const XPath*	285	const XPath*
286	ElemCopyOf::getXPath(unsigned int index) const	286	ElemCopyOf::getXPath(XalanSize_t index) const
287	{	287	{
288	return index == 0 ? m_selectPattern : 0;	288	return index == 0 ? m_selectPattern : 0;
289	}	289	}

Lines 76-87 Link Here

(-)src/xalanc/XSLT/StylesheetConstructionContext.hpp (-6 lines)
76		76
77	typedef XalanQName::NamespacesStackType NamespacesStackType;	77	typedef XalanQName::NamespacesStackType NamespacesStackType;
78		78
79	#if defined(XALAN_STRICT_ANSI_HEADERS)
80	typedef std::size_t size_type;
81	#else
82	typedef size_t size_type;
83	#endif
84
85	/**	79	/**
86	* IDs for XSL element types. These are the values	80	* IDs for XSL element types. These are the values
87	* that must be returned by getElementToken().	81	* that must be returned by getElementToken().

Lines 39-46 Link Here

(-)src/xalanc/XSLT/ElemSort.cpp (-13 / +13 lines)
39	StylesheetConstructionContext& constructionContext,	39	StylesheetConstructionContext& constructionContext,
40	Stylesheet& stylesheetTree,	40	Stylesheet& stylesheetTree,
41	const AttributeListType& atts,	41	const AttributeListType& atts,
42	int lineNumber,	42	XalanFileLoc lineNumber,
43	int columnNumber) :	43	XalanFileLoc columnNumber) :
44	ElemTemplateElement(constructionContext,	44	ElemTemplateElement(constructionContext,
45	stylesheetTree,	45	stylesheetTree,
46	lineNumber,	46	lineNumber,
Lines 52-89 Link Here
52	m_orderAVT(0),	52	m_orderAVT(0),
53	m_caseOrderAVT(0)	53	m_caseOrderAVT(0)
54	{	54	{
55	const unsigned int nAttrs = atts.getLength();	55	const XalanSize_t nAttrs = atts.getLength();
56		56
57	for(unsigned int i = 0; i < nAttrs; i++)	57	for (XalanSize_t i = 0; i < nAttrs; i++)
58	{	58	{
59	const XalanDOMChar* const aname = atts.getName(i);	59	const XalanDOMChar* const aname = atts.getName(i);
60		60
61	if(equals(aname, Constants::ATTRNAME_SELECT))	61	if (equals(aname, Constants::ATTRNAME_SELECT))
62	{	62	{
63	m_selectPattern	63	m_selectPattern
64	= constructionContext.createXPath(getLocator(), atts.getValue(i), *this);	64	= constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
65	}	65	}
66	else if(equals(aname, Constants::ATTRNAME_LANG))	66	else if (equals(aname, Constants::ATTRNAME_LANG))
67	{	67	{
68	m_langAVT =	68	m_langAVT =
69	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);	69	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
70	}	70	}
71	else if(equals(aname, Constants::ATTRNAME_DATATYPE))	71	else if (equals(aname, Constants::ATTRNAME_DATATYPE))
72	{	72	{
73	m_dataTypeAVT =	73	m_dataTypeAVT =
74	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);	74	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
75	}	75	}
76	else if(equals(aname, Constants::ATTRNAME_ORDER))	76	else if (equals(aname, Constants::ATTRNAME_ORDER))
77	{	77	{
78	m_orderAVT =	78	m_orderAVT =
79	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);	79	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
80	}	80	}
81	else if(equals(aname, Constants::ATTRNAME_CASEORDER))	81	else if (equals(aname, Constants::ATTRNAME_CASEORDER))
82	{	82	{
83	m_caseOrderAVT =	83	m_caseOrderAVT =
84	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);	84	constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
85	}	85	}
86	else if(isAttrOK(	86	else if (isAttrOK(
87	aname,	87	aname,
88	atts,	88	atts,
89	i,	89	i,
Lines 126-133 Link Here
126	StylesheetConstructionContext& constructionContext,	126	StylesheetConstructionContext& constructionContext,
127	Stylesheet& stylesheetTree,	127	Stylesheet& stylesheetTree,
128	const AttributeListType& atts,	128	const AttributeListType& atts,
129	int lineNumber,	129	XalanFileLoc lineNumber,
130	int columnNumber)	130	XalanFileLoc columnNumber)
131	{	131	{
132	typedef ElemSort ThisType;	132	typedef ElemSort ThisType;
133		133
Lines 163-169 Link Here
163		163
164		164
165	const XPath*	165	const XPath*
166	ElemSort::getXPath(unsigned int index) const	166	ElemSort::getXPath(XalanSize_t index) const
167	{	167	{
168	return index == 0 ? m_selectPattern : 0;	168	return index == 0 ? m_selectPattern : 0;
169	}	169	}

Lines 50-57 Link Here

(-)src/xalanc/XSLT/ElemApplyTemplates.cpp (-4 / +4 lines)
50	StylesheetConstructionContext& constructionContext,	50	StylesheetConstructionContext& constructionContext,
51	Stylesheet& stylesheetTree,	51	Stylesheet& stylesheetTree,
52	const AttributeListType& atts,	52	const AttributeListType& atts,
53	int lineNumber,	53	XalanFileLoc lineNumber,
54	int columnNumber) :	54	XalanFileLoc columnNumber) :
55	ParentType(	55	ParentType(
56	constructionContext,	56	constructionContext,
57	stylesheetTree,	57	stylesheetTree,
Lines 60-68 Link Here
60	StylesheetConstructionContext::ELEMNAME_APPLY_TEMPLATES),	60	StylesheetConstructionContext::ELEMNAME_APPLY_TEMPLATES),
61	m_mode(0)	61	m_mode(0)
62	{	62	{
63	const unsigned int nAttrs = atts.getLength();	63	const XalanSize_t nAttrs = atts.getLength();
64		64
65	for(unsigned int i = 0; i < nAttrs; i++)	65	for (XalanSize_t i = 0; i < nAttrs; i++)
66	{	66	{
67	const XalanDOMChar* const aname = atts.getName(i);	67	const XalanDOMChar* const aname = atts.getName(i);
68		68

Lines 82-89 Link Here

(-)src/xalanc/XSLT/ElemTemplateElement.cpp (-11 / +12 lines)
82	ElemTemplateElement::ElemTemplateElement(	82	ElemTemplateElement::ElemTemplateElement(
83	StylesheetConstructionContext& constructionContext,	83	StylesheetConstructionContext& constructionContext,
84	Stylesheet& stylesheetTree,	84	Stylesheet& stylesheetTree,
85	int lineNumber,	85	XalanFileLoc lineNumber,
86	int columnNumber,	86	XalanFileLoc columnNumber,
87	int xslToken) :	87	int xslToken) :
88	PrefixResolver(),	88	PrefixResolver(),
89	m_stylesheet(stylesheetTree),	89	m_stylesheet(stylesheetTree),
Lines 112-119 Link Here
112	Stylesheet& stylesheetTree,	112	Stylesheet& stylesheetTree,
113	int xslToken,	113	int xslToken,
114	const XalanDOMString& baseURI,	114	const XalanDOMString& baseURI,
115	int lineNumber,	115	XalanFileLoc lineNumber,
116	int columnNumber) :	116	XalanFileLoc columnNumber) :
117	PrefixResolver(),	117	PrefixResolver(),
118	m_stylesheet(stylesheetTree),	118	m_stylesheet(stylesheetTree),
119	m_namespacesHandler(constructionContext.getMemoryManager()),	119	m_namespacesHandler(constructionContext.getMemoryManager()),
Lines 158-164 Link Here
158	ElemTemplateElement::isAttrOK(	158	ElemTemplateElement::isAttrOK(
159	const XalanDOMChar* attrName,	159	const XalanDOMChar* attrName,
160	const AttributeListType& atts,	160	const AttributeListType& atts,
161	int which,	161	XalanSize_t which,
162	StylesheetConstructionContext& constructionContext) const	162	StylesheetConstructionContext& constructionContext) const
163	{	163	{
164	return m_stylesheet.isAttrOK(attrName, atts, which, constructionContext);	164	return m_stylesheet.isAttrOK(attrName, atts, which, constructionContext);
Lines 171-177 Link Here
171	const XalanDOMChar* elementName,	171	const XalanDOMChar* elementName,
172	const XalanDOMChar* aname,	172	const XalanDOMChar* aname,
173	const AttributeListType& atts,	173	const AttributeListType& atts,
174	int which,	174	XalanSize_t which,
175	StylesheetConstructionContext& constructionContext)	175	StylesheetConstructionContext& constructionContext)
176	{	176	{
177	if(constructionContext.isXMLSpaceAttribute(	177	if(constructionContext.isXMLSpaceAttribute(
Lines 1062-1073 Link Here
1062		1062
1063		1063
1064	const XPath*	1064	const XPath*
1065	ElemTemplateElement::getXPath(unsigned int /* index */) const	1065	ElemTemplateElement::getXPath(XalanSize_t /* index */) const
1066	{	1066	{
1067	return 0;	1067	return 0;
1068	}	1068	}
1069		1069
1070		1070
		1071
1071	#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)	1072	#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
1072	const ElemTemplateElement*	1073	const ElemTemplateElement*
1073	ElemTemplateElement::findTemplateToTransformChild(	1074	ElemTemplateElement::findTemplateToTransformChild(
Lines 1504-1511 Link Here
1504		1505
1505		1506
1506	ElemTemplateElement::LocatorProxy::LocatorProxy(	1507	ElemTemplateElement::LocatorProxy::LocatorProxy(
1507	size_type theLineNumber,	1508	XMLFileLoc theLineNumber,
1508	size_type theColumnNumber,	1509	XMLFileLoc theColumnNumber,
1509	const XalanDOMString& theURI) :	1510	const XalanDOMString& theURI) :
1510	m_lineNumber(theLineNumber),	1511	m_lineNumber(theLineNumber),
1511	m_columnNumber(theColumnNumber),	1512	m_columnNumber(theColumnNumber),
Lines 1521-1527 Link Here
1521		1522
1522		1523
1523		1524
1524	ElemTemplateElement::LocatorProxy::size_type	1525	XMLFileLoc
1525	ElemTemplateElement::LocatorProxy::getLineNumber() const	1526	ElemTemplateElement::LocatorProxy::getLineNumber() const
1526	{	1527	{
1527	return m_lineNumber;	1528	return m_lineNumber;
Lines 1529-1535 Link Here
1529		1530
1530		1531
1531		1532
1532	ElemTemplateElement::LocatorProxy::size_type	1533	XMLFileLoc
1533	ElemTemplateElement::LocatorProxy::getColumnNumber() const	1534	ElemTemplateElement::LocatorProxy::getColumnNumber() const
1534	{	1535	{
1535	return m_columnNumber;	1536	return m_columnNumber;

Lines 252-260 Link Here

(-)src/xalanc/XSLT/Stylesheet.cpp (-19 / +17 lines)
252	XPath* matchAttr = 0;	252	XPath* matchAttr = 0;
253	XPath* useAttr = 0;	253	XPath* useAttr = 0;
254		254
255	const unsigned int nAttrs = atts.getLength();	255	const XalanSize_t nAttrs = atts.getLength();
256		256
257	for(unsigned int i = 0; i < nAttrs; i++)	257	for(XalanSize_t i = 0; i < nAttrs; i++)
258	{	258	{
259	const XalanDOMChar* const aname = atts.getName(i);	259	const XalanDOMChar* const aname = atts.getName(i);
260		260
Lines 317-323 Link Here
317	}	317	}
318	}	318	}
319		319
320	if(0 == theQName)	320	if (0 == theQName)
321	{	321	{
322	const GetAndReleaseCachedString theGuard(constructionContext);	322	const GetAndReleaseCachedString theGuard(constructionContext);
323		323
Lines 331-337 Link Here
331	locator);	331	locator);
332	}	332	}
333		333
334	if(0 == matchAttr)	334	if (0 == matchAttr)
335	{	335	{
336	const GetAndReleaseCachedString theGuard(constructionContext);	336	const GetAndReleaseCachedString theGuard(constructionContext);
337		337
Lines 345-351 Link Here
345	locator);	345	locator);
346	}	346	}
347		347
348	if(0 == useAttr)	348	if (0 == useAttr)
349	{	349	{
350	const GetAndReleaseCachedString theGuard(constructionContext);	350	const GetAndReleaseCachedString theGuard(constructionContext);
351		351
Lines 374-386 Link Here
374	void	374	void
375	Stylesheet::pushNamespaces(const AttributeListType& atts)	375	Stylesheet::pushNamespaces(const AttributeListType& atts)
376	{	376	{
377	const unsigned int nAttrs = atts.getLength();	377	const XalanSize_t nAttrs = atts.getLength();
378		378
379	NamespaceVectorType namespaces(getMemoryManager());	379	NamespaceVectorType namespaces(getMemoryManager());
380		380
381	XalanDOMString prefix(getMemoryManager());	381	XalanDOMString prefix(getMemoryManager());
382		382
383	for(unsigned int i = 0; i < nAttrs; i++)	383	for(XalanSize_t i = 0; i < nAttrs; i++)
384	{	384	{
385	const XalanDOMChar* const aname = atts.getName(i);	385	const XalanDOMChar* const aname = atts.getName(i);
386	const XalanDOMChar* const value = atts.getValue(i);	386	const XalanDOMChar* const value = atts.getValue(i);
Lines 438-449 Link Here
438	Stylesheet::PatternTableVectorType& theList,	438	Stylesheet::PatternTableVectorType& theList,
439	const XalanMatchPatternData* thePattern)	439	const XalanMatchPatternData* thePattern)
440	{	440	{
441
442	typedef Stylesheet::size_type size_type;
443	assert(thePattern != 0);	441	assert(thePattern != 0);
444		442
445	const double thePatternPriority = thePattern->getPriorityOrDefault();	443	const double thePatternPriority = thePattern->getPriorityOrDefault();
446	const size_type thePatternPosition = thePattern->getPosition();	444	const XalanSize_t thePatternPosition = thePattern->getPosition();
447		445
448	typedef Stylesheet::PatternTableVectorType PatternTableListType;	446	typedef Stylesheet::PatternTableVectorType PatternTableListType;
449	typedef PatternTableListType::iterator iterator;	447	typedef PatternTableListType::iterator iterator;
Lines 452-458 Link Here
452		450
453	const iterator theEnd = theList.end();	451	const iterator theEnd = theList.end();
454		452
455	while(theCurrent != theEnd)	453	while (theCurrent != theEnd)
456	{	454	{
457	const double theCurrentPriority = (*theCurrent)->getPriorityOrDefault();	455	const double theCurrentPriority = (*theCurrent)->getPriorityOrDefault();
458		456
Lines 626-632 Link Here
626	Stylesheet::isAttrOK(	624	Stylesheet::isAttrOK(
627	const XalanDOMChar* attrName,	625	const XalanDOMChar* attrName,
628	const AttributeListType& /* atts */,	626	const AttributeListType& /* atts */,
629	int /* which */,	627	XalanSize_t /* which */,
630	StylesheetConstructionContext& constructionContext) const	628	StylesheetConstructionContext& constructionContext) const
631	{	629	{
632	// Namespace declarations are OK by definition	630	// Namespace declarations are OK by definition
Lines 1497-1512 Link Here
1497	const AttributeListType& atts,	1495	const AttributeListType& atts,
1498	StylesheetConstructionContext& constructionContext)	1496	StylesheetConstructionContext& constructionContext)
1499	{	1497	{
1500	const unsigned int nAttrs = atts.getLength();	1498	const XalanSize_t nAttrs = atts.getLength();
1501		1499
1502	const XalanDOMString* stylesheetNamespace = 0;	1500	const XalanDOMString* stylesheetNamespace = 0;
1503	const XalanDOMString* resultNamespace = 0;	1501	const XalanDOMString* resultNamespace = 0;
1504		1502
1505	for(unsigned int i = 0; i < nAttrs; i++)	1503	for (XalanSize_t i = 0; i < nAttrs; i++)
1506	{	1504	{
1507	const XalanDOMChar* const aname = atts.getName(i);	1505	const XalanDOMChar* const aname = atts.getName(i);
1508		1506
1509	if(equals(aname, Constants::ATTRNAME_STYLESHEET_PREFIX) == true)	1507	if (equals(aname, Constants::ATTRNAME_STYLESHEET_PREFIX) == true)
1510	{	1508	{
1511	const XalanDOMChar* const value = atts.getValue(i);	1509	const XalanDOMChar* const value = atts.getValue(i);
1512		1510
Lines 1519-1525 Link Here
1519	stylesheetNamespace = getNamespaceForPrefix(value, constructionContext);	1517	stylesheetNamespace = getNamespaceForPrefix(value, constructionContext);
1520	}	1518	}
1521	}	1519	}
1522	else if(equals(aname, Constants::ATTRNAME_RESULT_PREFIX))	1520	else if (equals(aname, Constants::ATTRNAME_RESULT_PREFIX))
1523	{	1521	{
1524	const XalanDOMChar* const value = atts.getValue(i);	1522	const XalanDOMChar* const value = atts.getValue(i);
1525		1523
Lines 1532-1538 Link Here
1532	resultNamespace = getNamespaceForPrefix(value, constructionContext);	1530	resultNamespace = getNamespaceForPrefix(value, constructionContext);
1533	}	1531	}
1534	}	1532	}
1535	else if(!isAttrOK(aname, atts, i, constructionContext))	1533	else if (!isAttrOK(aname, atts, i, constructionContext))
1536	{	1534	{
1537	const GetAndReleaseCachedString theGuard(constructionContext);	1535	const GetAndReleaseCachedString theGuard(constructionContext);
1538		1536
Lines 1588-1597 Link Here
1588	const AttributeListType& atts,	1586	const AttributeListType& atts,
1589	const LocatorType* locator)	1587	const LocatorType* locator)
1590	{	1588	{
1591	const XalanLocator::size_type lineNumber =	1589	const XalanFileLoc lineNumber =
1592	XalanLocator::getLineNumber(locator);	1590	XalanLocator::getLineNumber(locator);
1593		1591
1594	const XalanLocator::size_type columnNumber =	1592	const XalanFileLoc columnNumber =
1595	XalanLocator::getColumnNumber(locator);	1593	XalanLocator::getColumnNumber(locator);
1596		1594
1597	m_elemDecimalFormats.reserve(m_elemDecimalFormats.size() + 1);	1595	m_elemDecimalFormats.reserve(m_elemDecimalFormats.size() + 1);

Lines 185-191 Link Here

(-)src/xalanc/XSLT/ElemValueOf.cpp (-4 / +4 lines)
185	void	185	void
186	characters(	186	characters(
187	const XMLCh* const chars,	187	const XMLCh* const chars,
188	const unsigned int length)	188	const size_type length)
189	{	189	{
190	m_executionContext.characters(chars, 0, length);	190	m_executionContext.characters(chars, 0, length);
191	}	191	}
Lines 193-199 Link Here
193	void	193	void
194	charactersRaw(	194	charactersRaw(
195	const XMLCh* const chars,	195	const XMLCh* const chars,
196	const unsigned int length)	196	const size_type length)
197	{	197	{
198	m_executionContext.charactersRaw(chars, 0, length);	198	m_executionContext.charactersRaw(chars, 0, length);
199	}	199	}
Lines 206-212 Link Here
206	void	206	void
207	ignorableWhitespace(	207	ignorableWhitespace(
208	const XMLCh* const /* chars */,	208	const XMLCh* const /* chars */,
209	const unsigned int /* length */)	209	const size_type /* length */)
210	{	210	{
211	}	211	}
212		212
Lines 232-238 Link Here
232	void	232	void
233	cdata(	233	cdata(
234	const XMLCh* const /* ch */,	234	const XMLCh* const /* ch */,
235	const unsigned int /* length */)	235	const size_type /* length */)
236	{	236	{
237	}	237	}
238		238

Lines 46-77 Link Here

(-)src/xalanc/XSLT/ElemCopy.cpp (-8 / +8 lines)
46	StylesheetConstructionContext& constructionContext,	46	StylesheetConstructionContext& constructionContext,
47	Stylesheet& stylesheetTree,	47	Stylesheet& stylesheetTree,
48	const AttributeListType& atts,	48	const AttributeListType& atts,
49	int lineNumber,	49	XalanFileLoc lineNumber,
50	int columnNumber) :	50	XalanFileLoc columnNumber) :
51	ElemUse(constructionContext,	51	ElemUse(constructionContext,
52	stylesheetTree,	52	stylesheetTree,
53	lineNumber,	53	lineNumber,
54	columnNumber,	54	columnNumber,
55	StylesheetConstructionContext::ELEMNAME_COPY)	55	StylesheetConstructionContext::ELEMNAME_COPY)
56	{	56	{
57	const unsigned int nAttrs = atts.getLength();	57	const XalanSize_t nAttrs = atts.getLength();
58		58
59	for(unsigned int i = 0; i < nAttrs; i++)	59	for (XalanSize_t i = 0; i < nAttrs; i++)
60	{	60	{
61	const XalanDOMChar* const aname = atts.getName(i);	61	const XalanDOMChar* const aname = atts.getName(i);
62		62
63	if(processUseAttributeSets(	63	if (processUseAttributeSets(
64	constructionContext,	64	constructionContext,
65	aname,	65	aname,
66	atts,	66	atts,
67	i) == false &&	67	i) == false &&
68	processSpaceAttr(	68	processSpaceAttr(
69	Constants::ELEMNAME_COPY_WITH_PREFIX_STRING.c_str(),	69	Constants::ELEMNAME_COPY_WITH_PREFIX_STRING.c_str(),
70	aname,	70	aname,
71	atts,	71	atts,
72	i,	72	i,
73	constructionContext) == false &&	73	constructionContext) == false &&
74	isAttrOK(	74	isAttrOK(
75	aname,	75	aname,
76	atts,	76	atts,
77	i,	77	i,
Lines 94-99 Link Here
94	}	94	}
95		95
96		96
		97
97	#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)	98	#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
98	const ElemTemplateElement*	99	const ElemTemplateElement*
99	ElemCopy::startElement(StylesheetExecutionContext& executionContext) const	100	ElemCopy::startElement(StylesheetExecutionContext& executionContext) const
Lines 120-126 Link Here
120	executionContext.copyNamespaceAttributes(*sourceNode);	121	executionContext.copyNamespaceAttributes(*sourceNode);
121		122
122	return beginExecuteChildren(executionContext);	123	return beginExecuteChildren(executionContext);
123
124	}	124	}
125	else	125	else
126	{	126	{

Lines 213-220 Link Here

(-)src/xalanc/XSLT/StylesheetConstructionContextDefault.hpp (-3 / +4 lines)
213	getURLFromString(const XalanDOMString& urlString);	213	getURLFromString(const XalanDOMString& urlString);
214		214
215	virtual XalanDOMString&	215	virtual XalanDOMString&
216	getURLStringFromString(const XalanDOMString& urlString,	216	getURLStringFromString(
217	XalanDOMString& theResult);	217	const XalanDOMString& urlString,
		218	XalanDOMString& theResult);
218		219
219	virtual URLAutoPtrType	220	virtual URLAutoPtrType
220	getURLFromString(	221	getURLFromString(
Lines 648-654 Link Here
648		649
649	static const ElementTokenTableEntry s_elementTokenTable[];	650	static const ElementTokenTableEntry s_elementTokenTable[];
650		651
651	static const unsigned int s_elementTokenTableSize;	652	static const XalanSize_t s_elementTokenTableSize;
652		653
653	static const ElementTokenTableEntry& s_elementTokenTableLast;	654	static const ElementTokenTableEntry& s_elementTokenTableLast;
654		655

Lines 59-66 Link Here

(-)src/xalanc/XSLT/ElemSort.hpp (-5 / +5 lines)
59	StylesheetConstructionContext& constructionContext,	59	StylesheetConstructionContext& constructionContext,
60	Stylesheet& stylesheetTree,	60	Stylesheet& stylesheetTree,
61	const AttributeListType& atts,	61	const AttributeListType& atts,
62	int lineNumber,	62	XalanFileLoc lineNumber,
63	int columnNumber);	63	XalanFileLoc columnNumber);
64		64
65	static ElemSort*	65	static ElemSort*
66	create(	66	create(
Lines 68-75 Link Here
68	StylesheetConstructionContext& constructionContext,	68	StylesheetConstructionContext& constructionContext,
69	Stylesheet& stylesheetTree,	69	Stylesheet& stylesheetTree,
70	const AttributeListType& atts,	70	const AttributeListType& atts,
71	int lineNumber,	71	XalanFileLoc lineNumber,
72	int columnNumber);	72	XalanFileLoc columnNumber);
73		73
74	~ElemSort();	74	~ElemSort();
75		75
Lines 132-138 Link Here
132	getElementName() const;	132	getElementName() const;
133		133
134	virtual const XPath*	134	virtual const XPath*
135	getXPath(unsigned int index = 0) const;	135	getXPath(XalanSize_t index = 0) const;
136		136
137	private:	137	private:
138		138

Lines 55-62 Link Here

(-)src/xalanc/XSLT/ElemForEach.cpp (-12 / +12 lines)
55	StylesheetConstructionContext& constructionContext,	55	StylesheetConstructionContext& constructionContext,
56	Stylesheet& stylesheetTree,	56	Stylesheet& stylesheetTree,
57	const AttributeListType& atts,	57	const AttributeListType& atts,
58	int lineNumber,	58	XalanFileLoc lineNumber,
59	int columnNumber) :	59	XalanFileLoc columnNumber) :
60	ElemTemplateElement(constructionContext,	60	ElemTemplateElement(constructionContext,
61	stylesheetTree,	61	stylesheetTree,
62	lineNumber,	62	lineNumber,
Lines 66-82 Link Here
66	m_sortElems(constructionContext.getMemoryManager()),	66	m_sortElems(constructionContext.getMemoryManager()),
67	m_sortElemsCount(0)	67	m_sortElemsCount(0)
68	{	68	{
69	const unsigned int nAttrs = atts.getLength();	69	const XalanSize_t nAttrs = atts.getLength();
70		70
71	for(unsigned int i = 0; i < nAttrs; i++)	71	for (XalanSize_t i = 0; i < nAttrs; i++)
72	{	72	{
73	const XalanDOMChar* const aname = atts.getName(i);	73	const XalanDOMChar* const aname = atts.getName(i);
74		74
75	if(equals(aname, Constants::ATTRNAME_SELECT))	75	if (equals(aname, Constants::ATTRNAME_SELECT))
76	{	76	{
77	m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);	77	m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
78	}	78	}
79	else if(isAttrOK(	79	else if (isAttrOK(
80	aname,	80	aname,
81	atts,	81	atts,
82	i,	82	i,
Lines 96-102 Link Here
96	}	96	}
97	}	97	}
98		98
99	if(0 == m_selectPattern)	99	if (0 == m_selectPattern)
100	{	100	{
101	error(	101	error(
102	constructionContext,	102	constructionContext,
Lines 111-118 Link Here
111	ElemForEach::ElemForEach(	111	ElemForEach::ElemForEach(
112	StylesheetConstructionContext& constructionContext,	112	StylesheetConstructionContext& constructionContext,
113	Stylesheet& stylesheetTree,	113	Stylesheet& stylesheetTree,
114	int lineNumber,	114	XalanFileLoc lineNumber,
115	int columnNumber,	115	XalanFileLoc columnNumber,
116	int xslToken) :	116	int xslToken) :
117	ElemTemplateElement(constructionContext,	117	ElemTemplateElement(constructionContext,
118	stylesheetTree,	118	stylesheetTree,
Lines 147-154 Link Here
147	const AttributeListType& atts,	147	const AttributeListType& atts,
148	const LocatorType* locator)	148	const LocatorType* locator)
149	{	149	{
150	const int lineNumber = XalanLocator::getLineNumber(locator);	150	const XalanFileLoc lineNumber = XalanLocator::getLineNumber(locator);
151	const int columnNumber = XalanLocator::getColumnNumber(locator);	151	const XalanFileLoc columnNumber = XalanLocator::getColumnNumber(locator);
152		152
153	m_sortElems.reserve(m_sortElems.size() + 1);	153	m_sortElems.reserve(m_sortElems.size() + 1);
154		154
Lines 826-832 Link Here
826		826
827		827
828	const XPath*	828	const XPath*
829	ElemForEach::getXPath(unsigned int index) const	829	ElemForEach::getXPath(XalanSize_t index) const
830	{	830	{
831	return index == 0 ? m_selectPattern : 0;	831	return index == 0 ? m_selectPattern : 0;
832	}	832	}

Lines 1525-1531 Link Here

(-)src/xalanc/XSLT/StylesheetHandler.cpp (-8 / +8 lines)
1525	void	1525	void
1526	StylesheetHandler::characters(	1526	StylesheetHandler::characters(
1527	const XMLCh* const chars,	1527	const XMLCh* const chars,
1528	const unsigned int length)	1528	const size_type length)
1529	{	1529	{
1530	if (m_inTemplate == false &&	1530	if (m_inTemplate == false &&
1531	inExtensionElement() == false &&	1531	inExtensionElement() == false &&
Lines 1551-1557 Link Here
1551	void	1551	void
1552	StylesheetHandler::cdata(	1552	StylesheetHandler::cdata(
1553	const XMLCh* const chars,	1553	const XMLCh* const chars,
1554	const unsigned int length)	1554	const size_type length)
1555	{	1555	{
1556	accumulateText(chars, length);	1556	accumulateText(chars, length);
1557		1557
Lines 1565-1571 Link Here
1565	void	1565	void
1566	StylesheetHandler::ignorableWhitespace(	1566	StylesheetHandler::ignorableWhitespace(
1567	const XMLCh* const /chars/,	1567	const XMLCh* const /chars/,
1568	const unsigned int /length/)	1568	const size_type /length/)
1569	{	1569	{
1570	// Ignore!	1570	// Ignore!
1571	m_lastPopped = 0;	1571	m_lastPopped = 0;
Lines 1617-1623 Link Here
1617	void	1617	void
1618	StylesheetHandler::charactersRaw(	1618	StylesheetHandler::charactersRaw(
1619	const XMLCh* const /* chars */,	1619	const XMLCh* const /* chars */,
1620	const unsigned int /* length */)	1620	const size_type /* length */)
1621	{	1621	{
1622	}	1622	}
1623		1623
Lines 1625-1632 Link Here
1625		1625
1626	void	1626	void
1627	StylesheetHandler::processText(	1627	StylesheetHandler::processText(
1628	const XMLCh* chars,	1628	const XMLCh* chars,
1629	XalanDOMString::size_type length)	1629	size_type length)
1630	{	1630	{
1631	if(m_inTemplate)	1631	if(m_inTemplate)
1632	{	1632	{
Lines 1719-1726 Link Here
1719		1719
1720	void	1720	void
1721	StylesheetHandler::accumulateText(	1721	StylesheetHandler::accumulateText(
1722	const XMLCh* chars,	1722	const XMLCh* chars,
1723	XalanDOMString::size_type length)	1723	size_type length)
1724	{	1724	{
1725	if(m_inTemplate)	1725	if(m_inTemplate)
1726	{	1726	{

Lines 89-96 Link Here

(-)src/xalanc/XSLT/ElemTemplateElement.hpp (-15 / +15 lines)
89	ElemTemplateElement(	89	ElemTemplateElement(
90	StylesheetConstructionContext& constructionContext,	90	StylesheetConstructionContext& constructionContext,
91	Stylesheet& stylesheetTree,	91	Stylesheet& stylesheetTree,
92	int lineNumber,	92	XalanFileLoc lineNumber,
93	int columnNumber,	93	XalanFileLoc columnNumber,
94	int xslToken);	94	int xslToken);
95		95
96	/**	96	/**
Lines 110-117 Link Here
110	Stylesheet& stylesheetTree,	110	Stylesheet& stylesheetTree,
111	int xslToken,	111	int xslToken,
112	const XalanDOMString& baseURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),	112	const XalanDOMString& baseURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
113	int lineNumber = XalanLocator::getUnknownValue(),	113	XalanFileLoc lineNumber = XalanLocator::getUnknownValue(),
114	int columnNumber = XalanLocator::getUnknownValue());	114	XalanFileLoc columnNumber = XalanLocator::getUnknownValue());
115		115
116	virtual	116	virtual
117	~ElemTemplateElement();	117	~ElemTemplateElement();
Lines 138-144 Link Here
138	isAttrOK(	138	isAttrOK(
139	const XalanDOMChar* attrName,	139	const XalanDOMChar* attrName,
140	const AttributeListType& atts,	140	const AttributeListType& atts,
141	int which,	141	XalanSize_t which,
142	StylesheetConstructionContext& constructionContext) const;	142	StylesheetConstructionContext& constructionContext) const;
143		143
144	/**	144	/**
Lines 156-162 Link Here
156	const XalanDOMChar* elementName,	156	const XalanDOMChar* elementName,
157	const XalanDOMChar* aname,	157	const XalanDOMChar* aname,
158	const AttributeListType& atts,	158	const AttributeListType& atts,
159	int which,	159	XalanSize_t which,
160	StylesheetConstructionContext& constructionContext);	160	StylesheetConstructionContext& constructionContext);
161		161
162	/**	162	/**
Lines 615-621 Link Here
615	* @return pointer or null	615	* @return pointer or null
616	*/	616	*/
617	virtual const XPath*	617	virtual const XPath*
618	getXPath(unsigned int index = 0) const;	618	getXPath(XalanSize_t index) const;
619		619
620	// These interfaces are inherited from PrefixResolver...	620	// These interfaces are inherited from PrefixResolver...
621		621
Lines 633-640 Link Here
633	public:	633	public:
634		634
635	LocatorProxy(	635	LocatorProxy(
636	size_type theLineNumber,	636	XMLFileLoc theLineNumber,
637	size_type theColumnNumber,	637	XMLFileLoc theColumnNumber,
638	const XalanDOMString& theURI);	638	const XalanDOMString& theURI);
639		639
640	virtual	640	virtual
Lines 646-655 Link Here
646	virtual const XMLCh*	646	virtual const XMLCh*
647	getSystemId() const;	647	getSystemId() const;
648		648
649	virtual size_type	649	virtual XMLFileLoc
650	getLineNumber() const;	650	getLineNumber() const;
651		651
652	virtual size_type	652	virtual XMLFileLoc
653	getColumnNumber() const;	653	getColumnNumber() const;
654		654
655	const XalanDOMString&	655	const XalanDOMString&
Lines 670-690 Link Here
670	operator==(const LocatorProxy&) const;	670	operator==(const LocatorProxy&) const;
671		671
672	// data members...	672	// data members...
673	const size_type m_lineNumber;	673	const XMLFileLoc m_lineNumber;
674		674
675	const size_type m_columnNumber;	675	const XMLFileLoc m_columnNumber;
676		676
677	const XalanDOMString& m_uri;	677	const XalanDOMString& m_uri;
678	};	678	};
679		679
680		680
681	LocatorProxy::size_type	681	XMLFileLoc
682	getLineNumber() const	682	getLineNumber() const
683	{	683	{
684	return m_locatorProxy.getLineNumber();	684	return m_locatorProxy.getLineNumber();
685	}	685	}
686		686
687	LocatorProxy::size_type	687	XMLFileLoc
688	getColumnNumber() const	688	getColumnNumber() const
689	{	689	{
690	return m_locatorProxy.getColumnNumber();	690	return m_locatorProxy.getColumnNumber();

Lines 86-92 Link Here

(-)src/xalanc/XSLT/Stylesheet.hpp (-6 / +7 lines)
86		86
87	public:	87	public:
88		88
89	typedef StylesheetConstructionContext::size_type size_type;
90	typedef StylesheetExecutionContext::ParamVectorType ParamVectorType;	89	typedef StylesheetExecutionContext::ParamVectorType ParamVectorType;
91	typedef XalanQName::NamespaceVectorType NamespaceVectorType;	90	typedef XalanQName::NamespaceVectorType NamespaceVectorType;
92	typedef XalanQName::NamespacesStackType NamespacesStackType;	91	typedef XalanQName::NamespacesStackType NamespacesStackType;
Lines 288-294 Link Here
288	isAttrOK(	287	isAttrOK(
289	const XalanDOMChar* attrName,	288	const XalanDOMChar* attrName,
290	const AttributeListType& atts,	289	const AttributeListType& atts,
291	int which,	290	XalanSize_t which,
292	StylesheetConstructionContext& constructionContext) const;	291	StylesheetConstructionContext& constructionContext) const;
293		292
294	/**	293	/**
Lines 298-305 Link Here
298	* @return namespace string for node, or null if not found.	297	* @return namespace string for node, or null if not found.
299	*/	298	*/
300	const XalanDOMString*	299	const XalanDOMString*
301	getNamespaceFromStack(const XalanDOMString& nodeName,	300	getNamespaceFromStack(
302	XalanDOMString& theBuffer) const	301	const XalanDOMString& nodeName,
		302	XalanDOMString& theBuffer) const
303	{	303	{
304	return getNamespaceFromStack(c_wstr(nodeName), theBuffer);	304	return getNamespaceFromStack(c_wstr(nodeName), theBuffer);
305	}	305	}
Lines 311-318 Link Here
311	* @return namespace string for node, or null if not found.	311	* @return namespace string for node, or null if not found.
312	*/	312	*/
313	const XalanDOMString*	313	const XalanDOMString*
314	getNamespaceFromStack(const XalanDOMChar* nodeName,	314	getNamespaceFromStack(
315	XalanDOMString& theBuffer) const;	315	const XalanDOMChar* nodeName,
		316	XalanDOMString& theBuffer) const;
316		317
317	/**	318	/**
318	* Get the namespace from a prefix by searching the stack of namespace	319	* Get the namespace from a prefix by searching the stack of namespace