void
Attr::setPrefix(String * prefix)
throw(DOMException)
{
if (isReadOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
// +++FIXME more checks
unicode::StringBuffer buf(prefix);
buf += ":";
buf += localName;
name = buf.internString();
}
DOMNode *DOMAttrMapImpl::setNamedItem(DOMNode *arg)
{
if (arg->getNodeType() != DOMNode::ATTRIBUTE_NODE)
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR, 0, GetDOMNamedNodeMapMemoryManager);
DOMDocument *doc = fOwnerNode->getOwnerDocument();
DOMNodeImpl *argImpl = castToNodeImpl(arg);
if(argImpl->getOwnerDocument() != doc)
throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if (this->readOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if ((arg->getNodeType() == DOMNode::ATTRIBUTE_NODE) && argImpl->isOwned() && (argImpl->fOwnerNode != fOwnerNode))
throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR,0, GetDOMNamedNodeMapMemoryManager);
argImpl->fOwnerNode = fOwnerNode;
argImpl->isOwned(true);
int i=findNamePoint(arg->getNodeName());
DOMNode * previous=0;
if(i>=0)
{
previous = fNodes->elementAt(i);
fNodes->setElementAt(arg,i);
}
else
{
i=-1-i; // Insert point (may be end of list)
if(0==fNodes)
{
fNodes=new (doc) DOMNodeVector(doc);
}
fNodes->insertElementAt(arg,i);
}
if (previous != 0) {
castToNodeImpl(previous)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(previous)->isOwned(false);
}
return previous;
}
Node *
Attr::internalRemoveChild(Node * oldChild)
throw(DOMException)
{
Document * owner = getOwnerDocument();
if (isReadOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
if (oldChild != null && oldChild->getParentNode() != this)
throw DOMException(DOMException::NOT_FOUND_ERR);
owner->removedChildNode(oldChild);
ChildNode * oldInternal = dynamic_cast<ChildNode*>(oldChild);
if (oldInternal == text) {
text->isFirstChild(false);
text = dynamic_cast<Text*>(text->nextSibling);
if (text != null) {
text->isFirstChild(true);
text->previousSibling = oldInternal->previousSibling;
}
}
else {
ChildNode * prev = oldInternal->previousSibling;
ChildNode * next = oldInternal->nextSibling;
prev->nextSibling = next;
if (next != null) {
text->previousSibling = prev;
}
else {
next->previousSibling = prev;
}
}
//ChildNode * oldPreviousSibling = oldInternal->previousSibling;
oldInternal->ownerNode = owner;
oldInternal->isOwned(false);
oldInternal->nextSibling = null;
oldInternal->previousSibling = null;
changed();
return oldInternal;
}
Node *
DocumentType::insertBefore(Node * newChild, Node * refChild)
throw(DOMException)
{
NodeType type = newChild->getNodeType();
if ((type != Node::ELEMENT_NODE) &&
(type != Node::COMMENT_NODE))
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
ParentNode::insertBefore(newChild, refChild);
if (type == Node::ELEMENT_NODE)
elements->setNamedItemNS(newChild);
return newChild;
}
Event* Document::createEvent(const XMLString& eventType) const
{
if (eventType == MutationEvent::DOMSubtreeModified ||
eventType == MutationEvent::DOMNodeInserted ||
eventType == MutationEvent::DOMNodeRemoved ||
eventType == MutationEvent::DOMNodeRemovedFromDocument ||
eventType == MutationEvent::DOMNodeInsertedIntoDocument ||
eventType == MutationEvent::DOMAttrModified ||
eventType == MutationEvent::DOMCharacterDataModified)
{
return new MutationEvent(const_cast<Document*>(this), eventType);
}
throw DOMException(DOMException::NOT_SUPPORTED_ERR);
}
void CharacterData::deleteData(unsigned long offset, unsigned long count)
{
if (offset >= _data.length())
throw DOMException(DOMException::INDEX_SIZE_ERR);
if (events())
{
XMLString oldData = _data;
_data.replace(offset, count, EMPTY_STRING);
dispatchCharacterDataModified(oldData, _data);
}
else
_data.replace(offset, count, EMPTY_STRING);
}
void DOMElementImpl::removeAttribute(const XMLCh *nam)
{
if (fNode.isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
XMLSSize_t i = fAttributes->findNamePoint(nam);
if (i >= 0)
{
DOMNode *att = fAttributes->removeNamedItemAt(i);
((DOMAttrImpl *)att)->removeAttrFromIDNodeMap();
att->release();
}
}
void DOMElementImpl::removeAttributeNS(const XMLCh *fNamespaceURI,
const XMLCh *fLocalName)
{
if (fNode.isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
XMLSSize_t i = fAttributes->findNamePoint(fNamespaceURI, fLocalName);
if (i >= 0)
{
DOMNode *att = fAttributes->removeNamedItemAt(i);
att->release();
}
}
void DOMElementNSImpl::setName(const XMLCh *namespaceURI,
const XMLCh *qualifiedName)
{
DOMDocumentImpl* ownerDoc = (DOMDocumentImpl *) fParent.fOwnerDocument;
this->fName = ownerDoc->getPooledString(qualifiedName);
int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
if (index < 0)
throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);
if (index == 0)
{
//qualifiedName contains no ':'
//
fPrefix = 0;
fLocalName = fName;
}
else
{ //0 < index < this->name.length()-1
//
fPrefix = ownerDoc->getPooledNString(qualifiedName, index);
fLocalName = ownerDoc->getPooledString(fName+index+1);
// Before we carry on, we should check if the prefix or localName are valid XMLName
if (!ownerDoc->isXMLName(fPrefix) || !ownerDoc->isXMLName(fLocalName))
throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);
}
// DOM Level 3: namespace URI is never empty string.
//
const XMLCh * URI = DOMNodeImpl::mapPrefix (
fPrefix,
(!namespaceURI || !*namespaceURI) ? 0 : namespaceURI,
DOMNode::ELEMENT_NODE);
fNamespaceURI = (URI == 0) ? 0 : ownerDoc->getPooledString(URI);
}
// remove the name using index
// avoid calling findNamePoint again if the index is already known
DOMNode * DOMAttrMapImpl::removeNamedItemAt(XMLSize_t index)
{
if (this->readOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
DOMNode *removed = item(index);
if(!removed)
throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);
fNodes->removeElementAt(index);
castToNodeImpl(removed)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(removed)->isOwned(false);
// Replace it if it had a default value
// (DOM spec level 1 - Element Interface)
if (hasDefaults() && (removed != 0))
{
DOMAttrMapImpl* defAttrs = ((DOMElementImpl*)fOwnerNode)->getDefaultAttributes();
const XMLCh* localName = removed->getLocalName();
DOMAttr* attr = 0;
if (localName)
attr = (DOMAttr*)(defAttrs->getNamedItemNS(removed->getNamespaceURI(), localName));
else
attr = (DOMAttr*)(defAttrs->getNamedItem(((DOMAttr*)removed)->getName()));
if (attr != 0)
{
DOMAttr* newAttr = (DOMAttr*)attr->cloneNode(true);
setNamedItem(newAttr);
}
}
return removed;
}
// Non standard extension for the range to work
DOMProcessingInstruction *DOMProcessingInstructionImpl::splitText(XMLSize_t offset)
{
if (fNode.isReadOnly())
{
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager);
}
XMLSize_t len = fCharacterData.fDataBuf->getLen();
if (offset > len)
throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMNodeMemoryManager);
DOMDocumentImpl *doc = (DOMDocumentImpl *)getOwnerDocument();
DOMProcessingInstruction *newText =
doc->createProcessingInstruction(
fTarget, this->substringData(offset, len - offset));
DOMNode *parent = getParentNode();
if (parent != 0)
parent->insertBefore(newText, getNextSibling());
fCharacterData.fDataBuf->chop(offset);
if (doc != 0) {
Ranges* ranges = doc->getRanges();
if (ranges != 0) {
XMLSize_t sz = ranges->size();
if (sz != 0) {
for (XMLSize_t i =0; i<sz; i++) {
ranges->elementAt(i)->updateSplitInfo( this, newText, offset);
}
}
}
}
return newText;
}
// removeNamedItemNS() - Remove the named item, and return it.
// The caller can release the
// returned item if it's not used
// we can't do it here because the caller would
// never see the returned node.
DOMNode *DOMNamedNodeMapImpl::removeNamedItemNS(const XMLCh *namespaceURI,
const XMLCh *localName)
{
if (this->readOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
// the map is indexed using the full name of nodes; to search given a namespace and a local name
// we have to do a linear search
for (int index = 0; index < MAP_SIZE; index++) {
if(fBuckets[index]==0)
continue;
int i = 0;
int size = fBuckets[index]->size();
for (i = 0; i < size; ++i) {
DOMNode *n=fBuckets[index]->elementAt(i);
const XMLCh * nNamespaceURI = n->getNamespaceURI();
const XMLCh * nLocalName = n->getLocalName();
if (!XMLString::equals(nNamespaceURI, namespaceURI)) //URI not match
continue;
else {
if (XMLString::equals(localName, nLocalName)
||
(nLocalName == 0 && XMLString::equals(localName, n->getNodeName()))) {
fBuckets[index]->removeElementAt(i);
castToNodeImpl(n)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(n)->isOwned(false);
return n;
}
}
}
}
throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);
return 0;
}
void DOMElementImpl::setAttribute(const XMLCh *nam, const XMLCh *val)
{
if (fNode.isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
DOMAttr* newAttr = getAttributeNode(nam);
if (!newAttr)
{
newAttr = this->fNode.getOwnerDocument()->createAttribute(nam);
fAttributes->setNamedItem(newAttr);
}
newAttr->setNodeValue(val);
}
void CharacterData::insertData(unsigned long offset, const XMLString& arg)
{
if (offset > _data.length())
throw DOMException(DOMException::INDEX_SIZE_ERR);
if (events())
{
XMLString oldData = _data;
_data.insert(offset, arg);
dispatchCharacterDataModified(oldData, _data);
}
else
{
_data.insert(offset, arg);
}
}
AttributeP Document::createAttributeNS(DOMString* nsUri,
DOMString* nsPrefix,
DOMString* localName,
DOMString* value )
{
Element* ownerElement = NULL;
if(_stateful) {
if(_currentElement) {
ownerElement = _currentElement;
}
else {
throw DOMException("createAttributeNS: found an attrNode without any owner element");
}
}
return new Attribute( localName, value, nsUri, nsPrefix, ownerElement, this);
}
void DOMElementImpl::setAttributeNS(const XMLCh *fNamespaceURI,
const XMLCh *qualifiedName, const XMLCh *fValue)
{
if (fNode.isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
DOMAttr* newAttr = getAttributeNodeNS(fNamespaceURI, qualifiedName);
if (!newAttr)
{
newAttr = this->fNode.getOwnerDocument()->createAttributeNS(fNamespaceURI, qualifiedName);
fAttributes->setNamedItemNS(newAttr);
}
newAttr->setNodeValue(fValue);
}
void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue )
{
if(!impl) return;
int exceptioncode = 0;
((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );
#if KHTML_NO_EXCEPTIONS
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
{ _exceptioncode = exceptioncode - CSSException::_EXCEPTION_OFFSET; return; }
if ( exceptioncode )
{ _exceptioncode = exceptioncode ; return; }
#else
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
if ( exceptioncode )
throw DOMException( exceptioncode );
#endif
}
void CSSPrimitiveValue::setStringValue( unsigned short stringType, const DOMString &stringValue )
{
int exceptioncode = 0;
if(impl)
((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode );
#if KHTML_NO_EXCEPTIONS
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
{ _exceptioncode = exceptioncode - CSSException::_EXCEPTION_OFFSET; return; }
if ( exceptioncode )
{ _exceptioncode = exceptioncode ; return; }
#else
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
if ( exceptioncode )
throw DOMException( exceptioncode );
#endif
}
void DOMCharacterDataImpl::setNodeValue(const DOMNode *node, const XMLCh *value)
{
if (castToNodeImpl(node)->isReadOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);
fDataBuf->set(value);
if (node->getOwnerDocument() != 0) {
Ranges* ranges = ((DOMDocumentImpl *)node->getOwnerDocument())->getRanges();
if (ranges != 0) {
XMLSize_t sz = ranges->size();
if (sz != 0) {
for (XMLSize_t i =0; i<sz; i++) {
ranges->elementAt(i)->receiveReplacedText((DOMNode*)node);
}
}
}
}
}
void
Attr::setOwnerElement(Element * e)
{
if (e == null) {
if (ownerNode != null) {
ownerNode = getOwnerDocument();
isOwned(false);
isSpecified(true);
isId(false);
}
}
else {
if (isOwned())
throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR);
ownerNode = e;
isOwned(true);
setId();
}
}
void NodeAppender::appendChild(Node* newChild)
{
poco_check_ptr (newChild);
poco_assert (_pLast == 0 || _pLast->_pNext == 0);
if (static_cast<AbstractNode*>(newChild)->_pOwner != _pParent->_pOwner)
throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)
{
AbstractContainerNode* pFrag = static_cast<AbstractContainerNode*>(newChild);
AbstractNode* pChild = pFrag->_pFirstChild;
if (pChild)
{
if (_pLast)
_pLast->_pNext = pChild;
else
_pParent->_pFirstChild = pChild;
while (pChild)
{
_pLast = pChild;
pChild->_pParent = _pParent;
pChild = pChild->_pNext;
}
pFrag->_pFirstChild = 0;
}
}
else
{
AbstractNode* pAN = static_cast<AbstractNode*>(newChild);
pAN->duplicate();
if (pAN->_pParent)
pAN->_pParent->removeChild(pAN);
pAN->_pParent = _pParent;
if (_pLast)
_pLast->_pNext = pAN;
else
_pParent->_pFirstChild = pAN;
_pLast = pAN;
}
}
DOMNode* DOMNodeIteratorImpl::nextNode () {
if (fDetached)
throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeIteratorMemoryManager);
// if root is 0 there is no next node->
if (!fRoot)
return 0;
DOMNode* aNextNode = fCurrentNode;
bool accepted = false; // the next node has not been accepted.
while (!accepted) {
// if last direction is not forward, repeat node->
if (!fForward && (aNextNode != 0)) {
//System.out.println("nextNode():!fForward:"+fCurrentNode.getNodeName());
aNextNode = fCurrentNode;
} else {
// else get the next node via depth-first
aNextNode = nextNode(aNextNode, true);
}
fForward = true; //REVIST: should direction be set forward before 0 check?
// nothing in the list. return 0.
if (!aNextNode) return 0;
// does node pass the filters and whatToShow?
accepted = acceptNode(aNextNode);
if (accepted) {
// if so, then the node is the current node->
fCurrentNode = aNextNode;
return fCurrentNode;
}
}
// no nodes, or no accepted nodes.
return 0;
}
void XMLHttpRequest::send()
{
if (m_readyState != ReadyState_OPENED)
{
raise(DOMException(INVALID_STATE_ERR));
}
m_request->Send();
/*
uint8 buf[512];
while (1)
{
ULONG nRead = m_request->GetContentStream()->Read(buf, 512);
if (nRead > 0)
{
//fwrite(buf, 1, nRead, tempfile);
}
if (nRead < 512)
break;
}
*/
}
DOMNode* DOMNodeIteratorImpl::nextNode (DOMNode* node, bool visitChildren) {
if (fDetached)
throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeIteratorMemoryManager);
if (!node) return fRoot;
DOMNode* result = 0;
// only check children if we visit children.
if (visitChildren) {
//if hasChildren, return 1st child.
if ((fExpandEntityReferences || node->getNodeType()!=DOMNode::ENTITY_REFERENCE_NODE) &&
node->hasChildNodes()) {
result = node->getFirstChild();
return result;
}
}
// if hasSibling, return sibling
if (node != fRoot) {
result = node->getNextSibling();
if (result != 0) return result;
// return parent's 1st sibling.
DOMNode* parent = node->getParentNode();
while ((parent != 0) && parent != fRoot) {
result = parent->getNextSibling();
if (result != 0) {
return result;
} else {
parent = parent->getParentNode();
}
} // while (parent != 0 && parent != fRoot) {
}
// end of list, return 0
return 0;
}
DOMNode* DOMNodeIteratorImpl::previousNode () {
if (fDetached)
throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeIteratorMemoryManager);
// if the root is 0, or the current node is 0, return 0.
if (!fRoot || !fCurrentNode) return 0;
DOMNode* aPreviousNode = fCurrentNode;
bool accepted = false;
while (!accepted) {
if (fForward && (aPreviousNode != 0)) {
//repeat last node->
aPreviousNode = fCurrentNode;
} else {
// get previous node in backwards depth first order.
aPreviousNode = previousNode(aPreviousNode);
}
// we are going backwards
fForward = false;
// if the new previous node is 0, we're at head or past the root,
// so return 0.
if (!aPreviousNode) return 0;
// check if node passes filters and whatToShow.
accepted = acceptNode(aPreviousNode);
if (accepted) {
// if accepted, update the current node, and return it.
fCurrentNode = aPreviousNode;
return fCurrentNode;
}
}
// there are no nodes?
return 0;
}
const XMLCh * DOMCharacterDataImpl::substringData(const DOMNode *node, XMLSize_t offset,
XMLSize_t count) const
{
// Note: the C++ XMLCh * operation throws the correct DOMExceptions
// when parameter values are bad.
//
XMLSize_t len = fDataBuf->getLen();
if (offset > len)
throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMCharacterDataImplMemoryManager);
DOMDocumentImpl *doc = (DOMDocumentImpl *)node->getOwnerDocument();
XMLCh* newString;
XMLCh temp[4096];
if (len >= 4095)
newString = (XMLCh*) doc->getMemoryManager()->allocate
(
(len + 1) * sizeof(XMLCh)
);//new XMLCh[len+1];
else
newString = temp;
XMLString::copyNString(newString, fDataBuf->getRawBuffer()+offset, count);
newString[count] = chNull;
const XMLCh* retString = doc->getPooledString(newString);
if (len >= 4095)
doc->getMemoryManager()->deallocate(newString);//delete[] newString;
return retString;
}
Node* AbstractContainerNode::removeChild(Node* oldChild)
{
poco_check_ptr (oldChild);
bool doEvents = events();
if (oldChild == _pFirstChild)
{
if (doEvents)
{
static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
}
_pFirstChild = _pFirstChild->_pNext;
static_cast<AbstractNode*>(oldChild)->_pNext = 0;
static_cast<AbstractNode*>(oldChild)->_pParent = 0;
}
else
{
AbstractNode* pCur = _pFirstChild;
while (pCur && pCur->_pNext != oldChild) pCur = pCur->_pNext;
if (pCur)
{
if (doEvents)
{
static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
}
pCur->_pNext = pCur->_pNext->_pNext;
static_cast<AbstractNode*>(oldChild)->_pNext = 0;
static_cast<AbstractNode*>(oldChild)->_pParent = 0;
}
else throw DOMException(DOMException::NOT_FOUND_ERR);
}
oldChild->autoRelease();
if (doEvents) dispatchSubtreeModified();
return oldChild;
}
Attr* Element::removeAttributeNode(Attr* oldAttr)
{
poco_check_ptr (oldAttr);
if (_pOwner->events())
dispatchAttrModified(oldAttr, MutationEvent::REMOVAL, oldAttr->getValue(), EMPTY_STRING);
if (oldAttr != _pFirstAttr)
{
Attr* pCur = _pFirstAttr;
while (pCur->_pNext != oldAttr) pCur = static_cast<Attr*>(pCur->_pNext);
if (pCur)
{
pCur->_pNext = static_cast<Attr*>(pCur->_pNext->_pNext);
}
else throw DOMException(DOMException::NOT_FOUND_ERR);
}
else _pFirstAttr = static_cast<Attr*>(_pFirstAttr->_pNext);
oldAttr->_pNext = 0;
oldAttr->_pParent = 0;
oldAttr->autoRelease();
return oldAttr;
}
void DOMCharacterDataImpl::deleteData(const DOMNode *node, XMLSize_t offset, XMLSize_t count)
{
if (castToNodeImpl(node)->isReadOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);
// Note: the C++ XMLCh * operation throws the correct DOMExceptions
// when parameter values are bad.
//
XMLSize_t len = this->fDataBuf->getLen();
if (offset > len)
throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMCharacterDataImplMemoryManager);
// Cap the value of delLength to avoid trouble with overflows
// in the following length computations.
if (count > len)
count = len;
// If the length of data to be deleted would extend off the end
// of the string, cut it back to stop at the end of string.
if (offset + count >= len)
count = len - offset;
XMLSize_t newLen = len - count;
XMLCh* newString;
XMLCh temp[4000];
if (newLen >= 3999)
newString = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate
(
(newLen+1) * sizeof(XMLCh)
);//new XMLCh[newLen+1];
else
newString = temp;
XMLString::copyNString(newString, fDataBuf->getRawBuffer(), offset);
XMLString::copyString(newString+offset, fDataBuf->getRawBuffer()+offset+count);
fDataBuf->set(newString);
if (newLen >= 3999)
XMLPlatformUtils::fgMemoryManager->deallocate(newString);//delete[] newString;
// We don't delete the old string (doesn't work), or alter
// the old string (may be shared)
// It just hangs around, possibly orphaned.
if (node->getOwnerDocument() != 0) {
Ranges* ranges = ((DOMDocumentImpl *)node->getOwnerDocument())->getRanges();
if (ranges != 0) {
XMLSize_t sz = ranges->size();
if (sz != 0) {
for (XMLSize_t i =0; i<sz; i++) {
ranges->elementAt(i)->updateRangeForDeletedText( (DOMNode*)node, offset, count);
}
}
}
}
}
void DOMNodeImpl::setPrefix(const XMLCh *)
{
throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);
}