| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include "XalanSourceTreeDocument.hpp" |
| |
| |
| |
| #include <xercesc/sax/AttributeList.hpp> |
| #include <xercesc/sax2/Attributes.hpp> |
| |
| |
| |
| #include <xalanc/XalanDOM/XalanDOMException.hpp> |
| |
| |
| |
| #include <xalanc/PlatformSupport/PrefixResolver.hpp> |
| #include <xalanc/PlatformSupport/XalanUnicode.hpp> |
| |
| |
| |
| #include <xalanc/DOMSupport/DOMServices.hpp> |
| |
| |
| |
| #include "XalanSourceTreeHelper.hpp" |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| static const XalanDOMString s_emptyString(XalanMemMgrs::getDummyMemMgr()); |
| |
| |
| |
| bool XalanSourceTreeDocument::s_poolAllTextNodes = false; |
| |
| |
| |
| XalanSourceTreeDocument::XalanSourceTreeDocument( |
| MemoryManager& theManager, |
| bool fPoolAllText, |
| block_size_type theNamesStringPoolBlockSize, |
| bucket_count_type theNamesStringPoolBucketCount, |
| bucket_size_type theNamesStringPoolBucketSize, |
| block_size_type theValuesStringPoolBlockSize, |
| bucket_count_type theValuesStringPoolBucketCount, |
| bucket_size_type theValuesStringPoolBucketSize) : |
| XalanDocument(), |
| m_firstChild(0), |
| m_documentElement(0), |
| m_attributeAllocator(theManager, eDefaultAttributeAllocatorBlockSize), |
| m_attributeNSAllocator(theManager, eDefaultAttributeNSAllocatorBlockSize), |
| m_commentAllocator(theManager, eDefaultCommentAllocatorBlockSize), |
| m_elementAAllocator(theManager, eDefaultElementAllocatorBlockSize), |
| m_elementANSAllocator(theManager, eDefaultElementNSAllocatorBlockSize), |
| m_elementNAAllocator(theManager, eDefaultElementAllocatorBlockSize), |
| m_elementNANSAllocator(theManager, eDefaultElementNSAllocatorBlockSize), |
| m_piAllocator(theManager, eDefaultPIAllocatorBlockSize), |
| m_textAllocator(theManager, eDefaultTextAllocatorBlockSize), |
| m_textIWSAllocator(theManager, eDefaultTextIWSAllocatorBlockSize), |
| m_namesStringPool(theManager, theNamesStringPoolBlockSize, theNamesStringPoolBucketCount, theNamesStringPoolBucketSize), |
| m_valuesStringPool(theManager, theValuesStringPoolBlockSize, theValuesStringPoolBucketCount, theValuesStringPoolBucketSize), |
| m_attributesVector(theManager), |
| m_nextIndexValue(2), |
| m_poolAllText(fPoolAllText), |
| m_elementsByID(theManager), |
| m_unparsedEntityURIs(theManager), |
| m_nonPooledStrings(theManager, theValuesStringPoolBlockSize), |
| m_stringBuffer(theManager) |
| { |
| } |
| |
| |
| |
| XalanSourceTreeDocument* |
| XalanSourceTreeDocument::create( |
| MemoryManager& theManager, |
| bool fPoolAllText, |
| block_size_type theNamesStringPoolBlockSize, |
| bucket_count_type theNamesStringPoolBucketCount, |
| bucket_size_type theNamesStringPoolBucketSize, |
| block_size_type theValuesStringPoolBlockSize, |
| bucket_count_type theValuesStringPoolBucketCount, |
| bucket_size_type theValuesStringPoolBucketSize) |
| { |
| typedef XalanSourceTreeDocument ThisType; |
| |
| XalanAllocationGuard theGuard(theManager, theManager.allocate(sizeof(ThisType))); |
| |
| ThisType* const theResult = |
| new (theGuard.get()) ThisType( |
| theManager, |
| fPoolAllText, |
| theNamesStringPoolBlockSize, |
| theNamesStringPoolBucketCount, |
| theNamesStringPoolBucketSize, |
| theValuesStringPoolBlockSize, |
| theValuesStringPoolBucketCount, |
| theValuesStringPoolBucketSize); |
| |
| theGuard.release(); |
| |
| return theResult; |
| } |
| |
| |
| |
| XalanSourceTreeDocument::XalanSourceTreeDocument( |
| MemoryManager& theManager, |
| allocator_size_type theAttributeBlockSize, |
| allocator_size_type theAttributeNSBlockSize, |
| allocator_size_type theCommentBlockSize, |
| allocator_size_type theElementBlockSize, |
| allocator_size_type theElementNSBlockSize, |
| allocator_size_type thePIBlockSize, |
| allocator_size_type theTextBlockSize, |
| allocator_size_type theTextIWSBlockSize, |
| bool fPoolAllText) : |
| XalanDocument(), |
| m_firstChild(0), |
| m_documentElement(0), |
| m_attributeAllocator(theManager, theAttributeBlockSize), |
| m_attributeNSAllocator(theManager, theAttributeNSBlockSize), |
| m_commentAllocator(theManager, theCommentBlockSize), |
| m_elementAAllocator(theManager, theElementBlockSize), |
| m_elementANSAllocator(theManager, theElementNSBlockSize), |
| m_elementNAAllocator(theManager, theElementBlockSize), |
| m_elementNANSAllocator(theManager, theElementNSBlockSize), |
| m_piAllocator(theManager, thePIBlockSize), |
| m_textAllocator(theManager, theTextBlockSize), |
| m_textIWSAllocator(theManager, theTextIWSBlockSize), |
| m_namesStringPool(theManager, eDefaultNamesStringPoolBlockSize, eDefaultNamesStringPoolBucketCount, eDefaultNamesStringPoolBucketSize), |
| m_valuesStringPool(theManager, eDefaultValuesStringPoolBlockSize, eDefaultValuesStringPoolBucketCount, eDefaultValuesStringPoolBucketSize), |
| m_attributesVector(theManager), |
| m_nextIndexValue(2), |
| m_poolAllText(fPoolAllText), |
| m_elementsByID(theManager), |
| m_unparsedEntityURIs(theManager), |
| m_nonPooledStrings(theManager, eDefaultValuesStringPoolBlockSize), |
| m_stringBuffer(theManager) |
| { |
| } |
| |
| |
| |
| XalanSourceTreeDocument::~XalanSourceTreeDocument() |
| { |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getNodeName() const |
| { |
| return s_nameString; |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getNodeValue() const |
| { |
| return s_emptyString; |
| } |
| |
| |
| |
| XalanSourceTreeDocument::NodeType |
| XalanSourceTreeDocument::getNodeType() const |
| { |
| return DOCUMENT_NODE; |
| } |
| |
| |
| |
| XalanNode* |
| XalanSourceTreeDocument::getParentNode() const |
| { |
| return 0; |
| } |
| |
| |
| |
| const XalanNodeList* |
| XalanSourceTreeDocument::getChildNodes() const |
| { |
| throw XalanDOMException(XalanDOMException::NOT_SUPPORTED_ERR); |
| |
| // Dummy return value... |
| return 0; |
| } |
| |
| |
| |
| XalanNode* |
| XalanSourceTreeDocument::getFirstChild() const |
| { |
| return m_firstChild; |
| } |
| |
| |
| |
| XalanNode* |
| XalanSourceTreeDocument::getLastChild() const |
| { |
| return m_documentElement; |
| } |
| |
| |
| |
| XalanNode* |
| XalanSourceTreeDocument::getPreviousSibling() const |
| { |
| return 0; |
| } |
| |
| |
| |
| XalanNode* |
| XalanSourceTreeDocument::getNextSibling() const |
| { |
| return 0; |
| } |
| |
| |
| |
| const XalanNamedNodeMap* |
| XalanSourceTreeDocument::getAttributes() const |
| { |
| return 0; |
| } |
| |
| |
| |
| XalanDocument* |
| XalanSourceTreeDocument::getOwnerDocument() const |
| { |
| return 0; |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getNamespaceURI() const |
| { |
| return s_emptyString; |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getPrefix() const |
| { |
| return s_emptyString; |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getLocalName() const |
| { |
| return s_nameString; |
| } |
| |
| |
| |
| bool |
| XalanSourceTreeDocument::isIndexed() const |
| { |
| return true; |
| } |
| |
| |
| |
| XalanSourceTreeDocument::IndexType |
| XalanSourceTreeDocument::getIndex() const |
| { |
| return 1; |
| } |
| |
| |
| |
| XalanElement* |
| XalanSourceTreeDocument::getDocumentElement() const |
| { |
| return m_documentElement; |
| } |
| |
| |
| |
| XalanElement* |
| XalanSourceTreeDocument::getElementById(const XalanDOMString& elementId) const |
| { |
| const ElementByIDMapType::const_iterator i = |
| m_elementsByID.find(elementId.c_str()); |
| |
| if (i == m_elementsByID.end()) |
| { |
| return 0; |
| } |
| else |
| { |
| return (*i).second; |
| } |
| } |
| |
| |
| |
| static bool |
| hasXMLNamespaceAttribute(const AttributeListType& attrs) |
| { |
| const XalanSize_t theLength = attrs.getLength(); |
| |
| for (XalanSize_t i = 0; i < theLength; ++i) |
| { |
| const XalanDOMChar* const theName = |
| attrs.getName(i); |
| assert(theName != 0); |
| |
| if (equals(theName, DOMServices::s_XMLNamespacePrefix) == true) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| |
| static bool |
| hasXMLNamespaceAttribute(const AttributesType& attrs) |
| { |
| const XalanSize_t theLength = attrs.getLength(); |
| |
| for (XalanSize_t i = 0; i < theLength; ++i) |
| { |
| const XalanDOMChar* const theName = |
| attrs.getQName(i); |
| assert(theName != 0); |
| |
| if (equals(theName, DOMServices::s_XMLNamespacePrefix) == true) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| |
| size_t |
| XalanSourceTreeDocument::createAttributes( |
| XalanSourceTreeAttr** theAttributeVector, |
| const AttributeListType& attrs, |
| size_t theStartIndex, |
| XalanSourceTreeElement* theOwnerElement, |
| bool fCreateNamespaces, |
| const PrefixResolver* thePrefixResolver) |
| { |
| const XalanSize_t theSAXAttributeCount = attrs.getLength(); |
| |
| // Now, create the attributes... |
| for (XalanSize_t i = 0; i < theSAXAttributeCount; ++i) |
| { |
| const XalanDOMChar* const theName = |
| attrs.getName(i); |
| assert(theName != 0); |
| |
| const bool isNamespaceNode = startsWith(theName, DOMServices::s_XMLNamespaceWithSeparator) == true || |
| theName == DOMServices::s_XMLNamespace; |
| |
| if ((isNamespaceNode == true && fCreateNamespaces == true) || |
| (isNamespaceNode == false && fCreateNamespaces == false)) |
| { |
| const XalanDOMChar* const theValue = |
| attrs.getValue(i); |
| assert(theValue != 0); |
| |
| if (thePrefixResolver == 0) |
| { |
| theAttributeVector[theStartIndex] = |
| m_attributeAllocator.create( |
| m_namesStringPool.get(theName), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| |
| assert(theAttributeVector[theStartIndex] != 0); |
| } |
| else |
| { |
| const XalanDOMChar* theLocalName = 0; |
| |
| const XalanDOMString* const theNamespace = |
| getNamespaceForPrefix( |
| theName, |
| *thePrefixResolver, |
| m_stringBuffer, |
| false, |
| &theLocalName); |
| |
| if (theNamespace == 0 || theNamespace->empty() == true) |
| { |
| // the prefix was returned by getNamespaceForPrefix()... |
| assert(m_stringBuffer.empty() == true); |
| |
| theAttributeVector[theStartIndex] = |
| m_attributeAllocator.create( |
| m_namesStringPool.get(theName), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| |
| assert(theAttributeVector[theStartIndex] != 0); |
| } |
| else |
| { |
| assert(theLocalName != 0); |
| |
| theAttributeVector[theStartIndex] = |
| m_attributeNSAllocator.create( |
| m_namesStringPool.get(theName), |
| m_namesStringPool.get(theLocalName), |
| m_namesStringPool.get(*theNamespace), |
| // This is the prefix... |
| m_namesStringPool.get(m_stringBuffer), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| } |
| } |
| |
| ++theStartIndex; |
| } |
| } |
| |
| return theStartIndex; |
| } |
| |
| |
| |
| XalanSourceTreeElement* |
| XalanSourceTreeDocument::createElementNode( |
| const XalanDOMChar* name, |
| const AttributeListType& attrs, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling, |
| bool fAddXMLNamespaceAttribute) |
| { |
| XalanSize_t theAttributeCount = attrs.getLength(); |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| if (hasXMLNamespaceAttribute(attrs) == true) |
| { |
| fAddXMLNamespaceAttribute = false; |
| } |
| else |
| { |
| ++theAttributeCount; |
| } |
| } |
| |
| XalanSourceTreeAttr** theAttributeVector = 0; |
| XalanSourceTreeElement* theNewElement = 0; |
| |
| if (theAttributeCount == 0) |
| { |
| theNewElement = m_elementNAAllocator.create( |
| m_namesStringPool.get(name), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| theAttributeVector = m_attributesVector.allocate(theAttributeCount); |
| |
| theNewElement = m_elementAAllocator.create( |
| m_namesStringPool.get(name), |
| this, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| assert(theNewElement != 0); |
| |
| size_t theIndex = 0; |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| // The constructor parameters for AttrNS are: |
| // |
| // name |
| // local name |
| // namespace URI |
| // prefix |
| // value |
| // owner element |
| // index |
| // |
| theAttributeVector[theIndex] = |
| m_attributeNSAllocator.create( |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefix), |
| m_namesStringPool.get(DOMServices::s_XMLString), |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefixURI), |
| m_namesStringPool.get(DOMServices::s_XMLNamespace), |
| m_valuesStringPool.get(DOMServices::s_XMLNamespaceURI), |
| theNewElement, |
| m_nextIndexValue++); |
| |
| assert(theAttributeVector[theIndex] != 0); |
| |
| ++theIndex; |
| } |
| |
| // Create the namespace "nodes" first... |
| theIndex = createAttributes( |
| theAttributeVector, |
| attrs, |
| theIndex, |
| theNewElement, |
| true); |
| |
| // Now, create the attribute "nodes"... |
| theIndex = createAttributes( |
| theAttributeVector, |
| attrs, |
| theIndex, |
| theNewElement, |
| false); |
| |
| return theNewElement; |
| } |
| |
| |
| |
| XalanSourceTreeElement* |
| XalanSourceTreeDocument::createElementNode( |
| const XalanDOMChar* tagName, |
| const AttributeListType& attrs, |
| const PrefixResolver& thePrefixResolver, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling, |
| bool fAddXMLNamespaceAttribute) |
| { |
| XalanSize_t theAttributeCount = attrs.getLength(); |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| if (hasXMLNamespaceAttribute(attrs) == true) |
| { |
| fAddXMLNamespaceAttribute = false; |
| } |
| else |
| { |
| ++theAttributeCount; |
| } |
| } |
| |
| XalanSourceTreeAttr** const theAttributeVector = |
| theAttributeCount == 0 ? 0 : m_attributesVector.allocate(theAttributeCount); |
| |
| XalanSourceTreeElement* const theNewElement = |
| createElementNode( |
| tagName, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| thePrefixResolver); |
| |
| assert(theNewElement != 0); |
| |
| size_t theIndex = 0; |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| // The constructor parameters for AttrNS are: |
| // |
| // name |
| // local name |
| // namespace URI |
| // prefix |
| // value |
| // owner element |
| // index |
| // |
| theAttributeVector[theIndex] = |
| m_attributeNSAllocator.create( |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefix), |
| m_namesStringPool.get(DOMServices::s_XMLString), |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefixURI), |
| m_namesStringPool.get(DOMServices::s_XMLNamespace), |
| m_valuesStringPool.get(DOMServices::s_XMLNamespaceURI), |
| theNewElement, |
| m_nextIndexValue++); |
| |
| assert(theAttributeVector[theIndex] != 0); |
| |
| ++theIndex; |
| } |
| |
| // Create the namespace "nodes" first... |
| theIndex = createAttributes( |
| theAttributeVector, |
| attrs, |
| theIndex, |
| theNewElement, |
| true, |
| &thePrefixResolver); |
| |
| // Now, create the attribute "nodes"... |
| theIndex = createAttributes( |
| theAttributeVector, |
| attrs, |
| theIndex, |
| theNewElement, |
| false, |
| &thePrefixResolver); |
| |
| return theNewElement; |
| } |
| |
| |
| |
| inline const XalanDOMString& |
| getElementNodePrefix( |
| MemoryManager& theManager, |
| const XalanDOMChar* qname, |
| XalanDOMStringPool* theStringPool, |
| XalanDOMString::size_type theLength, |
| XalanDOMString::size_type theColonIndex) |
| { |
| if(theColonIndex == theLength) |
| { |
| return theStringPool->get(XalanDOMString( theManager)); |
| } |
| else |
| { |
| return theStringPool->get(qname, theColonIndex); |
| } |
| } |
| |
| |
| |
| XalanSourceTreeElement* |
| XalanSourceTreeDocument::createElementNode( |
| const XalanDOMChar* uri, |
| const XalanDOMChar* localname, |
| const XalanDOMChar* qname, |
| const AttributesType& attrs, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling, |
| bool fAddXMLNamespaceAttribute) |
| { |
| XalanSize_t theAttributeCount = attrs.getLength(); |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| if (hasXMLNamespaceAttribute(attrs) == true) |
| { |
| fAddXMLNamespaceAttribute = false; |
| } |
| else |
| { |
| ++theAttributeCount; |
| } |
| } |
| |
| XalanSourceTreeAttr** theAttributeVector = 0; |
| XalanSourceTreeElement* theNewElement = 0; |
| |
| const XalanDOMString::size_type theColonIndex = indexOf(qname, XalanUnicode::charColon); |
| const XalanDOMString::size_type theLength = length(qname); |
| |
| if (theAttributeCount == 0) |
| { |
| |
| theNewElement = m_elementNANSAllocator.create( |
| m_namesStringPool.get(qname), |
| m_namesStringPool.get(localname), |
| m_namesStringPool.get(uri), |
| // This is the prefix... |
| getElementNodePrefix( getMemoryManager() , qname, &m_namesStringPool, theLength, theColonIndex), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| theAttributeVector = m_attributesVector.allocate(theAttributeCount); |
| |
| theNewElement = m_elementANSAllocator.create( |
| m_namesStringPool.get(qname), |
| m_namesStringPool.get(localname), |
| m_namesStringPool.get(uri), |
| // This is the prefix... |
| getElementNodePrefix( getMemoryManager() ,qname, &m_namesStringPool, theLength, theColonIndex), |
| this, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| |
| createAttributes(attrs, theAttributeVector, theNewElement, fAddXMLNamespaceAttribute); |
| } |
| |
| return theNewElement; |
| } |
| |
| |
| |
| XalanSourceTreeElement* |
| XalanSourceTreeDocument::createElementNode( |
| const XalanDOMChar* name, |
| const AttributesType& attrs, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling, |
| bool fAddXMLNamespaceAttribute) |
| { |
| assert(indexOf(name, XalanUnicode::charColon) == length(name)); |
| |
| XalanSize_t theAttributeCount = attrs.getLength(); |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| if (hasXMLNamespaceAttribute(attrs) == true) |
| { |
| fAddXMLNamespaceAttribute = false; |
| } |
| else |
| { |
| ++theAttributeCount; |
| } |
| } |
| |
| XalanSourceTreeAttr** theAttributeVector = 0; |
| XalanSourceTreeElement* theNewElement = 0; |
| |
| if (theAttributeCount == 0) |
| { |
| theNewElement = m_elementNAAllocator.create( |
| m_namesStringPool.get(name), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| theAttributeVector = m_attributesVector.allocate(theAttributeCount); |
| |
| theNewElement = m_elementAAllocator.create( |
| m_namesStringPool.get(name), |
| this, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| |
| createAttributes(attrs, theAttributeVector, theNewElement, fAddXMLNamespaceAttribute); |
| } |
| |
| return theNewElement; |
| } |
| |
| |
| |
| XalanSourceTreeComment* |
| XalanSourceTreeDocument::createCommentNode( |
| const XalanDOMChar* data, |
| XalanDOMString::size_type length, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling) |
| { |
| return m_commentAllocator.create( |
| m_valuesStringPool.get(data, length), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| |
| |
| |
| XalanSourceTreeProcessingInstruction* |
| XalanSourceTreeDocument::createProcessingInstructionNode( |
| const XalanDOMChar* target, |
| const XalanDOMChar* data, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling) |
| { |
| assert(target != 0); |
| assert(data != 0); |
| |
| return m_piAllocator.create( |
| m_namesStringPool.get(target), |
| m_valuesStringPool.get(data), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| |
| |
| |
| inline const XalanDOMString& |
| XalanSourceTreeDocument::getTextNodeString( |
| const XalanDOMChar* chars, |
| XalanDOMString::size_type length) |
| { |
| if (m_poolAllText == true) |
| { |
| return m_valuesStringPool.get(chars, length); |
| } |
| else |
| { |
| XalanDOMString* const theString = |
| m_nonPooledStrings.create(chars, length); |
| assert(theString != 0); |
| |
| return *theString; |
| } |
| } |
| |
| |
| |
| const XalanDOMString* |
| XalanSourceTreeDocument::getNamespaceForPrefix( |
| const XalanDOMChar* theName, |
| const PrefixResolver& thePrefixResolver, |
| XalanDOMString& thePrefix, |
| bool fUseDefault, |
| const XalanDOMChar** theLocalName) |
| { |
| const XalanDOMString::size_type theLength = length(theName); |
| const XalanDOMString::size_type theColonIndex = indexOf(theName, XalanUnicode::charColon); |
| |
| if (theColonIndex != theLength) |
| { |
| // Get the prefix from theName... |
| thePrefix.assign(theName, theColonIndex); |
| assert(thePrefix.empty() == false); |
| |
| if (theLocalName != 0) |
| { |
| *theLocalName = theName + theColonIndex + 1; |
| } |
| |
| return thePrefixResolver.getNamespaceForPrefix(thePrefix); |
| } |
| else |
| { |
| thePrefix.clear(); |
| |
| if (theLocalName != 0) |
| { |
| *theLocalName = theName; |
| } |
| |
| if (fUseDefault == false) |
| { |
| return 0; |
| } |
| else |
| { |
| return thePrefixResolver.getNamespaceForPrefix(s_emptyString); |
| } |
| } |
| } |
| |
| |
| |
| XalanSourceTreeText* |
| XalanSourceTreeDocument::createTextNode( |
| const XalanDOMChar* chars, |
| XalanDOMString::size_type length, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling) |
| { |
| assert(chars != 0); |
| |
| if (isXMLWhitespace(chars, 0, length) == true) |
| { |
| const XalanDOMString& theString = m_valuesStringPool.get(chars, length); |
| |
| return m_textIWSAllocator.create( |
| theString, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| return m_textAllocator.create( |
| getTextNodeString(chars, length), |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| } |
| |
| |
| |
| XalanSourceTreeText* |
| XalanSourceTreeDocument::createTextIWSNode( |
| const XalanDOMChar* chars, |
| XalanDOMString::size_type length, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling) |
| { |
| assert(chars != 0); |
| |
| return m_textIWSAllocator.create( |
| m_valuesStringPool.get(chars, length), |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::unparsedEntityDeclaration( |
| const XalanDOMChar* name, |
| const XalanDOMChar* /* publicId */, |
| const XalanDOMChar* systemId, |
| const XalanDOMChar* /* notationName */) |
| { |
| m_unparsedEntityURIs[XalanDOMString(name, getMemoryManager())] = XalanDOMString(systemId, getMemoryManager()); |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanSourceTreeDocument::getUnparsedEntityURI(const XalanDOMString& theName) const |
| { |
| const UnparsedEntityURIMapType::const_iterator i = |
| m_unparsedEntityURIs.find(theName); |
| |
| if (i != m_unparsedEntityURIs.end()) |
| { |
| return (*i).second; |
| } |
| else |
| { |
| return s_emptyString; |
| } |
| } |
| |
| |
| |
| XalanSourceTreeAttr* |
| XalanSourceTreeDocument::createAttribute( |
| const XalanDOMChar* theName, |
| const XalanDOMChar* theValue, |
| XalanSourceTreeElement* theOwnerElement, |
| const PrefixResolver& thePrefixResolver) |
| { |
| // Get the namespace for the theName. Since attributes do not use |
| // the default namespace, make sure we don't get it... |
| const XalanDOMString* const theNamespace = |
| getNamespaceForPrefix( |
| theName, |
| thePrefixResolver, |
| m_stringBuffer, |
| false); |
| |
| assert((theNamespace == 0 && m_stringBuffer.empty() == true) || |
| (theNamespace != 0 && m_stringBuffer.empty() == false)); |
| |
| if (theNamespace == 0 || theNamespace->empty() == true) |
| { |
| return m_attributeAllocator.create( |
| m_namesStringPool.get(theName), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| // There must be a prefix, so we don't have to check to see if |
| // we got one... |
| |
| // The constructor parameters for AttrNS are: |
| // |
| // name |
| // local name |
| // namespace URI |
| // prefix |
| // value |
| // owner element |
| // index |
| // |
| return m_attributeNSAllocator.create( |
| m_namesStringPool.get(theName), |
| m_namesStringPool.get(theName + m_stringBuffer.length() + 1), |
| m_namesStringPool.get(*theNamespace), |
| // This is the prefix... |
| m_namesStringPool.get(m_stringBuffer), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| } |
| } |
| |
| |
| |
| XalanSourceTreeElement* |
| XalanSourceTreeDocument::createElementNode( |
| const XalanDOMChar* theTagName, |
| XalanSourceTreeAttr** theAttributeVector, |
| XalanSize_t theAttributeCount, |
| XalanNode* theParentNode, |
| XalanNode* thePreviousSibling, |
| XalanNode* theNextSibling, |
| const PrefixResolver& thePrefixResolver) |
| { |
| const XalanDOMString* const theNamespace = |
| getNamespaceForPrefix( |
| theTagName, |
| thePrefixResolver, |
| m_stringBuffer, |
| true); |
| |
| if (theNamespace == 0 || theNamespace->empty() == true) |
| { |
| // the prefix was returned by getNamespaceForPrefix()... |
| assert(m_stringBuffer.empty() == true); |
| |
| if (theAttributeCount == 0) |
| { |
| return m_elementNAAllocator.create( |
| m_namesStringPool.get(theTagName), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| return m_elementAAllocator.create( |
| m_namesStringPool.get(theTagName), |
| this, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| } |
| else |
| { |
| // We need figure out if there's a prefix on theTagName. If not, |
| // the local name is the same as the tag name. Otherwise, we need |
| // to remove the prefix and the ':' that separates them. If |
| // m_stringBuffer is of length 0, there's no prefix. |
| const XalanDOMString::size_type thePrefixLength = m_stringBuffer.length(); |
| |
| const XalanDOMChar* const theLocalName = |
| thePrefixLength == 0 ? theTagName : theTagName + thePrefixLength + 1; |
| |
| // The constructor parameters for ElementNS are: |
| // |
| // tag name |
| // local name |
| // namespace URI |
| // prefix |
| // owner document |
| // attributes |
| // attribute count |
| // parent element |
| // previous sibling |
| // next sibling |
| // index |
| // |
| if (theAttributeCount == 0) |
| { |
| return m_elementNANSAllocator.create( |
| m_namesStringPool.get(theTagName), |
| m_namesStringPool.get(theLocalName), |
| m_namesStringPool.get(*theNamespace), |
| m_namesStringPool.get(m_stringBuffer), |
| this, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| return m_elementANSAllocator.create( |
| m_namesStringPool.get(theTagName), |
| m_namesStringPool.get(theLocalName), |
| m_namesStringPool.get(*theNamespace), |
| m_namesStringPool.get(m_stringBuffer), |
| this, |
| theAttributeVector, |
| theAttributeCount, |
| theParentNode, |
| thePreviousSibling, |
| theNextSibling, |
| m_nextIndexValue++); |
| } |
| } |
| } |
| |
| |
| |
| size_t |
| XalanSourceTreeDocument::createAttributes( |
| XalanSourceTreeAttr** theAttributeVector, |
| const AttributesType& theAttributes, |
| size_t theStartIndex, |
| XalanSourceTreeElement* theOwnerElement, |
| bool fCreateNamespaces) |
| { |
| const XalanSize_t theSAXAttributeCount = theAttributes.getLength(); |
| |
| // Now, create the attributes... |
| for (XalanSize_t i = 0; i < theSAXAttributeCount; ++i) |
| { |
| const XalanDOMChar* const theQName = |
| theAttributes.getQName(i); |
| assert(theQName != 0); |
| |
| const bool isNamespaceNode = startsWith(theQName, DOMServices::s_XMLNamespaceWithSeparator) == true || |
| theQName == DOMServices::s_XMLNamespace; |
| |
| if ((isNamespaceNode == true && fCreateNamespaces == true) || |
| (isNamespaceNode == false && fCreateNamespaces == false)) |
| { |
| const XalanDOMChar* const theValue = |
| theAttributes.getValue(i); |
| assert(theValue != 0); |
| |
| const XalanDOMChar* const theURI = |
| theAttributes.getURI(i); |
| assert(theURI != 0); |
| |
| if (length(theURI) == 0) |
| { |
| theAttributeVector[theStartIndex] = |
| m_attributeAllocator.create( |
| m_namesStringPool.get(theQName), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| } |
| else |
| { |
| const XalanDOMChar* const theLocalName = |
| theAttributes.getLocalName(i); |
| assert(theLocalName != 0); |
| |
| const XalanDOMString::size_type theColonIndex = |
| indexOf(theQName, XalanUnicode::charColon); |
| assert(theColonIndex != length(theQName)); |
| |
| // The constructor parameters for AttrNS are: |
| // |
| // name |
| // local name |
| // namespace URI |
| // prefix |
| // value |
| // owner element |
| // index |
| // |
| theAttributeVector[theStartIndex] = |
| m_attributeNSAllocator.create( |
| m_namesStringPool.get(theQName), |
| m_namesStringPool.get(theLocalName), |
| m_namesStringPool.get(theURI), |
| // This is the prefix... |
| m_namesStringPool.get(theQName, theColonIndex), |
| m_valuesStringPool.get(theValue), |
| theOwnerElement, |
| m_nextIndexValue++); |
| } |
| |
| // OK, now let's see if we have an ID attribute... |
| const XalanDOMChar* theType = |
| theAttributes.getType(i); |
| |
| // Look for an attribute that was declared as type ID in the DTD. |
| // Note that we can just save a pointer to the attribute's XalanDOMString |
| // data, since the attribute is guaranteed to exist for as long as the |
| // document does. |
| if (*theType == XalanUnicode::charLetter_I && |
| *++theType == XalanUnicode::charLetter_D && |
| *++theType == 0) |
| { |
| // The XPath says that if there are duplicate IDs, the first node is |
| // always returned, so use insert(), rather than [] |
| m_elementsByID.insert( |
| ElementByIDMapType::value_type( |
| theAttributeVector[theStartIndex]->getValue().c_str(), |
| theOwnerElement)); |
| } |
| |
| ++theStartIndex; |
| } |
| } |
| |
| return theStartIndex; |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::createAttributes( |
| const AttributesType& theAttributes, |
| XalanSourceTreeAttr** theAttributeVector, |
| XalanSourceTreeElement* theOwnerElement, |
| bool fAddXMLNamespaceAttribute) |
| { |
| size_t theIndex = 0; |
| |
| if (fAddXMLNamespaceAttribute == true) |
| { |
| // The constructor parameters for AttrNS are: |
| // |
| // name |
| // local name |
| // namespace URI |
| // prefix |
| // value |
| // owner element |
| // index |
| // |
| theAttributeVector[theIndex] = |
| m_attributeNSAllocator.create( |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefix), |
| m_namesStringPool.get(DOMServices::s_XMLString), |
| m_namesStringPool.get(DOMServices::s_XMLNamespacePrefixURI), |
| m_namesStringPool.get(DOMServices::s_XMLNamespace), |
| m_valuesStringPool.get(DOMServices::s_XMLNamespaceURI), |
| theOwnerElement, |
| m_nextIndexValue++); |
| |
| ++theIndex; |
| } |
| |
| // Create the namespace "nodes" first... |
| theIndex = createAttributes( |
| theAttributeVector, |
| theAttributes, |
| theIndex, |
| theOwnerElement, |
| true); |
| |
| // Now, create the attribute "nodes"... |
| theIndex = createAttributes( |
| theAttributeVector, |
| theAttributes, |
| theIndex, |
| theOwnerElement, |
| false); |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::appendChildNode(XalanSourceTreeComment* theChild) |
| { |
| XalanSourceTreeHelper::appendSibling(this, m_firstChild, theChild); |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::appendChildNode(XalanSourceTreeElement* theChild) |
| { |
| if (m_documentElement != 0) |
| { |
| throw XalanDOMException(XalanDOMException::HIERARCHY_REQUEST_ERR); |
| } |
| else |
| { |
| m_documentElement = theChild; |
| |
| XalanSourceTreeHelper::appendSibling(this, m_firstChild, theChild); |
| } |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::appendChildNode(XalanSourceTreeProcessingInstruction* theChild) |
| { |
| XalanSourceTreeHelper::appendSibling(this, m_firstChild, theChild); |
| } |
| |
| |
| |
| static XalanDOMString s_staticNameString(XalanMemMgrs::getDummyMemMgr()); |
| |
| |
| |
| const XalanDOMString& XalanSourceTreeDocument::s_nameString = s_staticNameString; |
| |
| |
| |
| static const XalanDOMChar s_document[] = |
| { |
| XalanUnicode::charNumberSign, |
| XalanUnicode::charLetter_d, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_c, |
| XalanUnicode::charLetter_u, |
| XalanUnicode::charLetter_m, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_t, |
| 0 |
| }; |
| |
| |
| |
| void |
| XalanSourceTreeDocument::initialize(MemoryManager& theManager) |
| { |
| XalanDOMString tmpString(s_document, theManager); |
| |
| s_staticNameString.swap(tmpString); |
| } |
| |
| |
| |
| void |
| XalanSourceTreeDocument::terminate() |
| { |
| releaseMemory(s_staticNameString, XalanMemMgrs::getDummyMemMgr()); |
| } |
| |
| |
| |
| } |
