sippeangelo
892 lines
29 KiB
C++
892 lines
29 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* $Id: ElemStack.cpp 830538 2009-10-28 13:41:11Z amassari $
|
|
*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Includes
|
|
// ---------------------------------------------------------------------------
|
|
#include <string.h>
|
|
#include <xercesc/util/EmptyStackException.hpp>
|
|
#include <xercesc/util/NoSuchElementException.hpp>
|
|
#include <xercesc/framework/XMLElementDecl.hpp>
|
|
#include <xercesc/internal/ElemStack.hpp>
|
|
#include <xercesc/validators/common/Grammar.hpp>
|
|
|
|
XERCES_CPP_NAMESPACE_BEGIN
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Constructors and Destructor
|
|
// ---------------------------------------------------------------------------
|
|
ElemStack::ElemStack(MemoryManager* const manager) :
|
|
|
|
fEmptyNamespaceId(0)
|
|
, fGlobalPoolId(0)
|
|
, fPrefixPool(109, manager)
|
|
, fGlobalNamespaces(0)
|
|
, fStack(0)
|
|
, fStackCapacity(32)
|
|
, fStackTop(0)
|
|
, fUnknownNamespaceId(0)
|
|
, fXMLNamespaceId(0)
|
|
, fXMLPoolId(0)
|
|
, fXMLNSNamespaceId(0)
|
|
, fXMLNSPoolId(0)
|
|
, fNamespaceMap(0)
|
|
, fMemoryManager(manager)
|
|
{
|
|
// Do an initial allocation of the stack and zero it out
|
|
fStack = (StackElem**) fMemoryManager->allocate
|
|
(
|
|
fStackCapacity * sizeof(StackElem*)
|
|
);//new StackElem*[fStackCapacity];
|
|
memset(fStack, 0, fStackCapacity * sizeof(StackElem*));
|
|
|
|
fNamespaceMap = new (fMemoryManager) ValueVectorOf<PrefMapElem*>(16, fMemoryManager);
|
|
}
|
|
|
|
ElemStack::~ElemStack()
|
|
{
|
|
if(fGlobalNamespaces)
|
|
{
|
|
fMemoryManager->deallocate(fGlobalNamespaces->fMap);
|
|
delete fGlobalNamespaces;
|
|
}
|
|
|
|
//
|
|
// Start working from the bottom of the stack and clear it out as we
|
|
// go up. Once we hit an uninitialized one, we can break out.
|
|
//
|
|
for (XMLSize_t stackInd = 0; stackInd < fStackCapacity; stackInd++)
|
|
{
|
|
// If this entry has been set, then lets clean it up
|
|
if (!fStack[stackInd])
|
|
break;
|
|
|
|
fMemoryManager->deallocate(fStack[stackInd]->fChildren);//delete [] fStack[stackInd]->fChildren;
|
|
fMemoryManager->deallocate(fStack[stackInd]->fMap);//delete [] fStack[stackInd]->fMap;
|
|
fMemoryManager->deallocate(fStack[stackInd]->fSchemaElemName);
|
|
delete fStack[stackInd];
|
|
}
|
|
|
|
// Delete the stack array itself now
|
|
fMemoryManager->deallocate(fStack);//delete [] fStack;
|
|
delete fNamespaceMap;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Stack access
|
|
// ---------------------------------------------------------------------------
|
|
XMLSize_t ElemStack::addLevel()
|
|
{
|
|
// See if we need to expand the stack
|
|
if (fStackTop == fStackCapacity)
|
|
expandStack();
|
|
|
|
// If this element has not been initialized yet, then initialize it
|
|
if (!fStack[fStackTop])
|
|
{
|
|
fStack[fStackTop] = new (fMemoryManager) StackElem;
|
|
fStack[fStackTop]->fChildCapacity = 0;
|
|
fStack[fStackTop]->fChildren = 0;
|
|
fStack[fStackTop]->fMapCapacity = 0;
|
|
fStack[fStackTop]->fMap = 0;
|
|
fStack[fStackTop]->fSchemaElemName = 0;
|
|
fStack[fStackTop]->fSchemaElemNameMaxLen = 0;
|
|
}
|
|
|
|
// Set up the new top row
|
|
fStack[fStackTop]->fThisElement = 0;
|
|
fStack[fStackTop]->fReaderNum = 0xFFFFFFFF;
|
|
fStack[fStackTop]->fChildCount = 0;
|
|
fStack[fStackTop]->fMapCount = 0;
|
|
fStack[fStackTop]->fValidationFlag = false;
|
|
fStack[fStackTop]->fCommentOrPISeen = false;
|
|
fStack[fStackTop]->fReferenceEscaped = false;
|
|
fStack[fStackTop]->fCurrentURI = fUnknownNamespaceId;
|
|
fStack[fStackTop]->fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
|
|
fStack[fStackTop]->fCurrentGrammar = 0;
|
|
|
|
// Bump the top of stack
|
|
fStackTop++;
|
|
|
|
return fStackTop-1;
|
|
}
|
|
|
|
|
|
XMLSize_t ElemStack::addLevel(XMLElementDecl* const toSet, const XMLSize_t readerNum)
|
|
{
|
|
// See if we need to expand the stack
|
|
if (fStackTop == fStackCapacity)
|
|
expandStack();
|
|
|
|
// If this element has not been initialized yet, then initialize it
|
|
if (!fStack[fStackTop])
|
|
{
|
|
fStack[fStackTop] = new (fMemoryManager) StackElem;
|
|
fStack[fStackTop]->fChildCapacity = 0;
|
|
fStack[fStackTop]->fChildren = 0;
|
|
fStack[fStackTop]->fMapCapacity = 0;
|
|
fStack[fStackTop]->fMap = 0;
|
|
fStack[fStackTop]->fSchemaElemName = 0;
|
|
fStack[fStackTop]->fSchemaElemNameMaxLen = 0;
|
|
}
|
|
|
|
// Set up the new top row
|
|
fStack[fStackTop]->fThisElement = toSet;
|
|
fStack[fStackTop]->fReaderNum = readerNum;
|
|
fStack[fStackTop]->fChildCount = 0;
|
|
fStack[fStackTop]->fMapCount = 0;
|
|
fStack[fStackTop]->fValidationFlag = false;
|
|
fStack[fStackTop]->fCommentOrPISeen = false;
|
|
fStack[fStackTop]->fReferenceEscaped = false;
|
|
fStack[fStackTop]->fCurrentURI = fUnknownNamespaceId;
|
|
fStack[fStackTop]->fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
|
|
fStack[fStackTop]->fCurrentGrammar = 0;
|
|
|
|
// Bump the top of stack
|
|
fStackTop++;
|
|
|
|
return fStackTop-1;
|
|
}
|
|
|
|
|
|
|
|
const ElemStack::StackElem* ElemStack::popTop()
|
|
{
|
|
// Watch for an underflow error
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_StackUnderflow, fMemoryManager);
|
|
|
|
fStackTop--;
|
|
return fStack[fStackTop];
|
|
}
|
|
|
|
|
|
void
|
|
ElemStack::setElement(XMLElementDecl* const toSet, const XMLSize_t readerNum)
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
fStack[fStackTop - 1]->fThisElement = toSet;
|
|
fStack[fStackTop - 1]->fReaderNum = readerNum;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Stack top access
|
|
// ---------------------------------------------------------------------------
|
|
XMLSize_t ElemStack::addChild(QName* const child, const bool toParent)
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
//
|
|
// If they want to add to the parent, then we have to have at least two
|
|
// elements on the stack.
|
|
//
|
|
if (toParent && (fStackTop < 2))
|
|
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::ElemStack_NoParentPushed, fMemoryManager);
|
|
|
|
// Get a convenience pointer to the stack top row
|
|
StackElem* curRow = toParent
|
|
? fStack[fStackTop - 2] : fStack[fStackTop - 1];
|
|
|
|
// See if we need to expand this row's child array
|
|
if (curRow->fChildCount == curRow->fChildCapacity)
|
|
{
|
|
// Increase the capacity by a quarter and allocate a new row
|
|
const XMLSize_t newCapacity = curRow->fChildCapacity ?
|
|
(XMLSize_t)(curRow->fChildCapacity * 1.25) :
|
|
32;
|
|
QName** newRow = (QName**) fMemoryManager->allocate
|
|
(
|
|
newCapacity * sizeof(QName*)
|
|
);//new QName*[newCapacity];
|
|
|
|
//
|
|
// Copy over the old contents. We don't have to initialize the new
|
|
// part because The current child count is used to know how much of
|
|
// it is valid.
|
|
//
|
|
// Only both doing this if there is any current content, since
|
|
// this code also does the initial faulting in of the array when
|
|
// both the current capacity and child count are zero.
|
|
//
|
|
for (XMLSize_t index = 0; index < curRow->fChildCount; index++)
|
|
newRow[index] = curRow->fChildren[index];
|
|
|
|
// Clean up the old children and store the new info
|
|
fMemoryManager->deallocate(curRow->fChildren);//delete [] curRow->fChildren;
|
|
curRow->fChildren = newRow;
|
|
curRow->fChildCapacity = newCapacity;
|
|
}
|
|
|
|
// Add this id to the end of the row's child id array and bump the count
|
|
curRow->fChildren[curRow->fChildCount++] = child;
|
|
|
|
// Return the level of the index we just filled (before the bump)
|
|
return curRow->fChildCount - 1;
|
|
}
|
|
|
|
const ElemStack::StackElem* ElemStack::topElement() const
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
return fStack[fStackTop - 1];
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Prefix map methods
|
|
// ---------------------------------------------------------------------------
|
|
void ElemStack::addGlobalPrefix(const XMLCh* const prefixToAdd
|
|
, const unsigned int uriId)
|
|
{
|
|
if (!fGlobalNamespaces)
|
|
{
|
|
fGlobalNamespaces = new (fMemoryManager) StackElem;
|
|
fGlobalNamespaces->fChildCapacity = 0;
|
|
fGlobalNamespaces->fChildren = 0;
|
|
fGlobalNamespaces->fMapCapacity = 0;
|
|
fGlobalNamespaces->fMap = 0;
|
|
fGlobalNamespaces->fMapCount = 0;
|
|
fGlobalNamespaces->fSchemaElemName = 0;
|
|
fGlobalNamespaces->fSchemaElemNameMaxLen = 0;
|
|
fGlobalNamespaces->fThisElement = 0;
|
|
fGlobalNamespaces->fReaderNum = 0xFFFFFFFF;
|
|
fGlobalNamespaces->fChildCount = 0;
|
|
fGlobalNamespaces->fValidationFlag = false;
|
|
fGlobalNamespaces->fCommentOrPISeen = false;
|
|
fGlobalNamespaces->fReferenceEscaped = false;
|
|
fGlobalNamespaces->fCurrentURI = fUnknownNamespaceId;
|
|
fGlobalNamespaces->fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
|
|
fGlobalNamespaces->fCurrentGrammar = 0;
|
|
}
|
|
|
|
// Map the prefix to its unique id
|
|
const unsigned int prefId = fPrefixPool.addOrFind(prefixToAdd);
|
|
|
|
//
|
|
// Add a new element to the prefix map for this element. If its full,
|
|
// then expand it out.
|
|
//
|
|
if (fGlobalNamespaces->fMapCount == fGlobalNamespaces->fMapCapacity)
|
|
expandMap(fGlobalNamespaces);
|
|
|
|
//
|
|
// And now add a new element for this prefix. Watch for the special case
|
|
// of xmlns=="", and force it to ""=[globalid]
|
|
//
|
|
fGlobalNamespaces->fMap[fGlobalNamespaces->fMapCount].fPrefId = prefId;
|
|
if ((prefId == fGlobalPoolId) && (uriId == fEmptyNamespaceId))
|
|
fGlobalNamespaces->fMap[fGlobalNamespaces->fMapCount].fURIId = fEmptyNamespaceId;
|
|
else
|
|
fGlobalNamespaces->fMap[fGlobalNamespaces->fMapCount].fURIId = uriId;
|
|
|
|
// Bump the map count now
|
|
fGlobalNamespaces->fMapCount++;
|
|
}
|
|
|
|
void ElemStack::addPrefix( const XMLCh* const prefixToAdd
|
|
, const unsigned int uriId)
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
// Get a convenience pointer to the stack top row
|
|
StackElem* curRow = fStack[fStackTop - 1];
|
|
|
|
// Map the prefix to its unique id
|
|
const unsigned int prefId = fPrefixPool.addOrFind(prefixToAdd);
|
|
|
|
//
|
|
// Add a new element to the prefix map for this element. If its full,
|
|
// then expand it out.
|
|
//
|
|
if (curRow->fMapCount == curRow->fMapCapacity)
|
|
expandMap(curRow);
|
|
|
|
//
|
|
// And now add a new element for this prefix. Watch for the special case
|
|
// of xmlns=="", and force it to ""=[globalid]
|
|
//
|
|
curRow->fMap[curRow->fMapCount].fPrefId = prefId;
|
|
if ((prefId == fGlobalPoolId) && (uriId == fEmptyNamespaceId))
|
|
curRow->fMap[curRow->fMapCount].fURIId = fEmptyNamespaceId;
|
|
else
|
|
curRow->fMap[curRow->fMapCount].fURIId = uriId;
|
|
|
|
// Bump the map count now
|
|
curRow->fMapCount++;
|
|
}
|
|
|
|
|
|
unsigned int ElemStack::mapPrefixToURI( const XMLCh* const prefixToMap
|
|
, bool& unknown) const
|
|
{
|
|
// Assume we find it
|
|
unknown = false;
|
|
|
|
//
|
|
// Map the prefix to its unique id, from the prefix string pool. If its
|
|
// not a valid prefix, then its a failure.
|
|
//
|
|
unsigned int prefixId = (!prefixToMap || !*prefixToMap)?fGlobalPoolId : fPrefixPool.getId(prefixToMap);
|
|
if (prefixId == 0)
|
|
{
|
|
unknown = true;
|
|
return fUnknownNamespaceId;
|
|
}
|
|
//
|
|
// Check for the special prefixes 'xml' and 'xmlns' since they cannot
|
|
// be overridden.
|
|
//
|
|
else if (prefixId == fXMLPoolId)
|
|
return fXMLNamespaceId;
|
|
else if (prefixId == fXMLNSPoolId)
|
|
return fXMLNSNamespaceId;
|
|
|
|
//
|
|
// Start at the stack top and work backwards until we come to some
|
|
// element that mapped this prefix.
|
|
//
|
|
for (XMLSize_t index = fStackTop; index > 0; index--)
|
|
{
|
|
// Get a convenience pointer to the current element
|
|
StackElem* curRow = fStack[index-1];
|
|
|
|
// Search the map at this level for the passed prefix
|
|
for (XMLSize_t mapIndex = 0; mapIndex < curRow->fMapCount; mapIndex++)
|
|
{
|
|
if (curRow->fMap[mapIndex].fPrefId == prefixId)
|
|
return curRow->fMap[mapIndex].fURIId;
|
|
}
|
|
}
|
|
// If the prefix wasn't found, try in the global namespaces
|
|
if(fGlobalNamespaces)
|
|
{
|
|
for (XMLSize_t mapIndex = 0; mapIndex < fGlobalNamespaces->fMapCount; mapIndex++)
|
|
{
|
|
if (fGlobalNamespaces->fMap[mapIndex].fPrefId == prefixId)
|
|
return fGlobalNamespaces->fMap[mapIndex].fURIId;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the prefix is an empty string, then we will return the special
|
|
// global namespace id. This can be overridden, but no one has or we
|
|
// would have not gotten here.
|
|
//
|
|
if (!*prefixToMap)
|
|
return fEmptyNamespaceId;
|
|
|
|
// Oh well, don't have a clue so return the unknown id
|
|
unknown = true;
|
|
return fUnknownNamespaceId;
|
|
}
|
|
|
|
|
|
ValueVectorOf<PrefMapElem*>* ElemStack::getNamespaceMap() const
|
|
{
|
|
fNamespaceMap->removeAllElements();
|
|
|
|
// Start at the stack top and work backwards until we come to some
|
|
// element that mapped this prefix.
|
|
for (XMLSize_t index = fStackTop; index > 0; index--)
|
|
{
|
|
// Get a convenience pointer to the current element
|
|
StackElem* curRow = fStack[index-1];
|
|
|
|
// If no prefixes mapped at this level, then go the next one
|
|
if (!curRow->fMapCount)
|
|
continue;
|
|
|
|
// Search the map at this level for the passed prefix
|
|
for (XMLSize_t mapIndex = 0; mapIndex < curRow->fMapCount; mapIndex++)
|
|
fNamespaceMap->addElement(&(curRow->fMap[mapIndex]));
|
|
}
|
|
// Add the global namespaces
|
|
if(fGlobalNamespaces)
|
|
{
|
|
for (XMLSize_t mapIndex = 0; mapIndex < fGlobalNamespaces->fMapCount; mapIndex++)
|
|
fNamespaceMap->addElement(&(fGlobalNamespaces->fMap[mapIndex]));
|
|
}
|
|
|
|
return fNamespaceMap;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Miscellaneous methods
|
|
// ---------------------------------------------------------------------------
|
|
void ElemStack::reset( const unsigned int emptyId
|
|
, const unsigned int unknownId
|
|
, const unsigned int xmlId
|
|
, const unsigned int xmlNSId)
|
|
{
|
|
if(fGlobalNamespaces)
|
|
{
|
|
fMemoryManager->deallocate(fGlobalNamespaces->fMap);
|
|
delete fGlobalNamespaces;
|
|
fGlobalNamespaces = 0;
|
|
}
|
|
|
|
// Reset the stack top to clear the stack
|
|
fStackTop = 0;
|
|
|
|
// if first time, put in the standard prefixes
|
|
if (fXMLPoolId == 0) {
|
|
|
|
fGlobalPoolId = fPrefixPool.addOrFind(XMLUni::fgZeroLenString);
|
|
fXMLPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLString);
|
|
fXMLNSPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLNSString);
|
|
}
|
|
|
|
// And store the new special URI ids
|
|
fEmptyNamespaceId = emptyId;
|
|
fUnknownNamespaceId = unknownId;
|
|
fXMLNamespaceId = xmlId;
|
|
fXMLNSNamespaceId = xmlNSId;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ElemStack: Private helpers
|
|
// ---------------------------------------------------------------------------
|
|
void ElemStack::expandMap(StackElem* const toExpand)
|
|
{
|
|
// For convenience get the old map size
|
|
const XMLSize_t oldCap = toExpand->fMapCapacity;
|
|
|
|
//
|
|
// Expand the capacity by 25%, or initialize it to 16 if its currently
|
|
// empty. Then allocate a new temp buffer.
|
|
//
|
|
const XMLSize_t newCapacity = oldCap ?
|
|
(XMLSize_t )(oldCap * 1.25) : 16;
|
|
PrefMapElem* newMap = (PrefMapElem*) fMemoryManager->allocate
|
|
(
|
|
newCapacity * sizeof(PrefMapElem)
|
|
);//new PrefMapElem[newCapacity];
|
|
|
|
//
|
|
// Copy over the old stuff. We DON'T have to zero out the new stuff
|
|
// since this is a by value map and the current map index controls what
|
|
// is relevant.
|
|
//
|
|
memcpy(newMap, toExpand->fMap, oldCap * sizeof(PrefMapElem));
|
|
|
|
// Delete the old map and store the new stuff
|
|
fMemoryManager->deallocate(toExpand->fMap);//delete [] toExpand->fMap;
|
|
toExpand->fMap = newMap;
|
|
toExpand->fMapCapacity = newCapacity;
|
|
}
|
|
|
|
void ElemStack::expandStack()
|
|
{
|
|
// Expand the capacity by 25% and allocate a new buffer
|
|
const XMLSize_t newCapacity = (XMLSize_t)(fStackCapacity * 1.25);
|
|
StackElem** newStack = (StackElem**) fMemoryManager->allocate
|
|
(
|
|
newCapacity * sizeof(StackElem*)
|
|
);//new StackElem*[newCapacity];
|
|
|
|
// Copy over the old stuff
|
|
memcpy(newStack, fStack, fStackCapacity * sizeof(StackElem*));
|
|
|
|
//
|
|
// And zero out the new stuff. Though we use a stack top, we reuse old
|
|
// stack contents so we need to know if elements have been initially
|
|
// allocated or not as we push new stuff onto the stack.
|
|
//
|
|
memset
|
|
(
|
|
&newStack[fStackCapacity]
|
|
, 0
|
|
, (newCapacity - fStackCapacity) * sizeof(StackElem*)
|
|
);
|
|
|
|
// Delete the old array and update our members
|
|
fMemoryManager->deallocate(fStack);//delete [] fStack;
|
|
fStack = newStack;
|
|
fStackCapacity = newCapacity;
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Constructors and Destructor
|
|
// ---------------------------------------------------------------------------
|
|
WFElemStack::WFElemStack(MemoryManager* const manager) :
|
|
|
|
fEmptyNamespaceId(0)
|
|
, fGlobalPoolId(0)
|
|
, fStackCapacity(32)
|
|
, fStackTop(0)
|
|
, fUnknownNamespaceId(0)
|
|
, fXMLNamespaceId(0)
|
|
, fXMLPoolId(0)
|
|
, fXMLNSNamespaceId(0)
|
|
, fXMLNSPoolId(0)
|
|
, fMapCapacity(0)
|
|
, fMap(0)
|
|
, fStack(0)
|
|
, fPrefixPool(109, manager)
|
|
, fMemoryManager(manager)
|
|
{
|
|
// Do an initial allocation of the stack and zero it out
|
|
fStack = (StackElem**) fMemoryManager->allocate
|
|
(
|
|
fStackCapacity * sizeof(StackElem*)
|
|
);//new StackElem*[fStackCapacity];
|
|
memset(fStack, 0, fStackCapacity * sizeof(StackElem*));
|
|
}
|
|
|
|
WFElemStack::~WFElemStack()
|
|
{
|
|
//
|
|
// Start working from the bottom of the stack and clear it out as we
|
|
// go up. Once we hit an uninitialized one, we can break out.
|
|
//
|
|
for (XMLSize_t stackInd = 0; stackInd < fStackCapacity; stackInd++)
|
|
{
|
|
// If this entry has been set, then lets clean it up
|
|
if (!fStack[stackInd])
|
|
break;
|
|
|
|
fMemoryManager->deallocate(fStack[stackInd]->fThisElement);//delete [] fStack[stackInd]->fThisElement;
|
|
delete fStack[stackInd];
|
|
}
|
|
|
|
if (fMap)
|
|
fMemoryManager->deallocate(fMap);//delete [] fMap;
|
|
|
|
// Delete the stack array itself now
|
|
fMemoryManager->deallocate(fStack);//delete [] fStack;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Stack access
|
|
// ---------------------------------------------------------------------------
|
|
XMLSize_t WFElemStack::addLevel()
|
|
{
|
|
// See if we need to expand the stack
|
|
if (fStackTop == fStackCapacity)
|
|
expandStack();
|
|
|
|
|
|
// If this element has not been initialized yet, then initialize it
|
|
if (!fStack[fStackTop])
|
|
{
|
|
fStack[fStackTop] = new (fMemoryManager) StackElem;
|
|
fStack[fStackTop]->fThisElement = 0;
|
|
fStack[fStackTop]->fElemMaxLength = 0;
|
|
}
|
|
|
|
// Set up the new top row
|
|
fStack[fStackTop]->fReaderNum = 0xFFFFFFFF;
|
|
fStack[fStackTop]->fCurrentURI = fUnknownNamespaceId;
|
|
fStack[fStackTop]->fTopPrefix = -1;
|
|
|
|
if (fStackTop != 0)
|
|
fStack[fStackTop]->fTopPrefix = fStack[fStackTop - 1]->fTopPrefix;
|
|
|
|
// Bump the top of stack
|
|
fStackTop++;
|
|
|
|
return fStackTop-1;
|
|
}
|
|
|
|
|
|
XMLSize_t
|
|
WFElemStack::addLevel(const XMLCh* const toSet,
|
|
const unsigned int toSetLen,
|
|
const unsigned int readerNum)
|
|
{
|
|
// See if we need to expand the stack
|
|
if (fStackTop == fStackCapacity)
|
|
expandStack();
|
|
|
|
// If this element has not been initialized yet, then initialize it
|
|
if (!fStack[fStackTop])
|
|
{
|
|
fStack[fStackTop] = new (fMemoryManager) StackElem;
|
|
fStack[fStackTop]->fThisElement = 0;
|
|
fStack[fStackTop]->fElemMaxLength = 0;
|
|
}
|
|
|
|
// Set up the new top row
|
|
fStack[fStackTop]->fCurrentURI = fUnknownNamespaceId;
|
|
fStack[fStackTop]->fTopPrefix = -1;
|
|
|
|
// And store the new stuff
|
|
if (toSetLen > fStack[fStackTop]->fElemMaxLength) {
|
|
|
|
fMemoryManager->deallocate(fStack[fStackTop]->fThisElement);//delete [] fStack[fStackTop]->fThisElement;
|
|
fStack[fStackTop]->fElemMaxLength = toSetLen;
|
|
fStack[fStackTop]->fThisElement = (XMLCh*) fMemoryManager->allocate
|
|
(
|
|
(toSetLen + 1) * sizeof(XMLCh)
|
|
);//new XMLCh[toSetLen + 1];
|
|
}
|
|
|
|
XMLString::moveChars(fStack[fStackTop]->fThisElement, toSet, toSetLen + 1);
|
|
fStack[fStackTop]->fReaderNum = readerNum;
|
|
|
|
if (fStackTop != 0)
|
|
fStack[fStackTop]->fTopPrefix = fStack[fStackTop - 1]->fTopPrefix;
|
|
|
|
// Bump the top of stack
|
|
fStackTop++;
|
|
|
|
return fStackTop-1;
|
|
}
|
|
|
|
|
|
|
|
const WFElemStack::StackElem* WFElemStack::popTop()
|
|
{
|
|
// Watch for an underflow error
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_StackUnderflow, fMemoryManager);
|
|
|
|
fStackTop--;
|
|
return fStack[fStackTop];
|
|
}
|
|
|
|
|
|
void
|
|
WFElemStack::setElement(const XMLCh* const toSet,
|
|
const unsigned int toSetLen,
|
|
const unsigned int readerNum)
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
if (toSetLen > fStack[fStackTop - 1]->fElemMaxLength) {
|
|
|
|
fMemoryManager->deallocate(fStack[fStackTop - 1]->fThisElement);//delete [] fStack[fStackTop - 1]->fThisElement;
|
|
fStack[fStackTop - 1]->fElemMaxLength = toSetLen;
|
|
fStack[fStackTop - 1]->fThisElement = (XMLCh*) fMemoryManager->allocate
|
|
(
|
|
(toSetLen + 1) * sizeof(XMLCh)
|
|
);//new XMLCh[toSetLen + 1];
|
|
}
|
|
|
|
XMLString::moveChars(fStack[fStackTop - 1]->fThisElement, toSet, toSetLen + 1);
|
|
fStack[fStackTop - 1]->fReaderNum = readerNum;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Stack top access
|
|
// ---------------------------------------------------------------------------
|
|
const WFElemStack::StackElem* WFElemStack::topElement() const
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
return fStack[fStackTop - 1];
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Prefix map methods
|
|
// ---------------------------------------------------------------------------
|
|
void WFElemStack::addPrefix( const XMLCh* const prefixToAdd
|
|
, const unsigned int uriId)
|
|
{
|
|
if (!fStackTop)
|
|
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
|
|
|
|
// Get a convenience pointer to the stack top row
|
|
StackElem* curRow = fStack[fStackTop - 1];
|
|
|
|
// Map the prefix to its unique id
|
|
const unsigned int prefId = fPrefixPool.addOrFind(prefixToAdd);
|
|
|
|
//
|
|
// Add a new element to the prefix map for this element. If its full,
|
|
// then expand it out.
|
|
//
|
|
if ((unsigned int)curRow->fTopPrefix + 1 == fMapCapacity)
|
|
expandMap();
|
|
|
|
//
|
|
// And now add a new element for this prefix. Watch for the special case
|
|
// of xmlns=="", and force it to ""=[globalid]
|
|
//
|
|
fMap[curRow->fTopPrefix + 1].fPrefId = prefId;
|
|
if ((prefId == fGlobalPoolId) && (uriId == fEmptyNamespaceId))
|
|
fMap[curRow->fTopPrefix + 1].fURIId = fEmptyNamespaceId;
|
|
else
|
|
fMap[curRow->fTopPrefix + 1].fURIId = uriId;
|
|
|
|
// Bump the map count now
|
|
curRow->fTopPrefix++;
|
|
}
|
|
|
|
|
|
unsigned int WFElemStack::mapPrefixToURI( const XMLCh* const prefixToMap
|
|
, bool& unknown) const
|
|
{
|
|
// Assume we find it
|
|
unknown = false;
|
|
|
|
//
|
|
// Map the prefix to its unique id, from the prefix string pool. If its
|
|
// not a valid prefix, then its a failure.
|
|
//
|
|
unsigned int prefixId = fPrefixPool.getId(prefixToMap);
|
|
if (!prefixId)
|
|
{
|
|
unknown = true;
|
|
return fUnknownNamespaceId;
|
|
}
|
|
|
|
//
|
|
// Check for the special prefixes 'xml' and 'xmlns' since they cannot
|
|
// be overridden.
|
|
//
|
|
if (prefixId == fXMLPoolId)
|
|
return fXMLNamespaceId;
|
|
else if (prefixId == fXMLNSPoolId)
|
|
return fXMLNSNamespaceId;
|
|
|
|
//
|
|
// Start at the stack top and work backwards until we come to some
|
|
// element that mapped this prefix.
|
|
//
|
|
// Get a convenience pointer to the stack top row
|
|
StackElem* curRow = fStack[fStackTop - 1];
|
|
for (int mapIndex = curRow->fTopPrefix; mapIndex >=0; mapIndex--)
|
|
{
|
|
if (fMap[mapIndex].fPrefId == prefixId)
|
|
return fMap[mapIndex].fURIId;
|
|
}
|
|
|
|
//
|
|
// If the prefix is an empty string, then we will return the special
|
|
// global namespace id. This can be overridden, but no one has or we
|
|
// would have not gotten here.
|
|
//
|
|
if (!*prefixToMap)
|
|
return fEmptyNamespaceId;
|
|
|
|
// Oh well, don't have a clue so return the unknown id
|
|
unknown = true;
|
|
return fUnknownNamespaceId;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Miscellaneous methods
|
|
// ---------------------------------------------------------------------------
|
|
void WFElemStack::reset( const unsigned int emptyId
|
|
, const unsigned int unknownId
|
|
, const unsigned int xmlId
|
|
, const unsigned int xmlNSId)
|
|
{
|
|
// Reset the stack top to clear the stack
|
|
fStackTop = 0;
|
|
|
|
// if first time, put in the standard prefixes
|
|
if (fXMLPoolId == 0) {
|
|
|
|
fGlobalPoolId = fPrefixPool.addOrFind(XMLUni::fgZeroLenString);
|
|
fXMLPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLString);
|
|
fXMLNSPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLNSString);
|
|
}
|
|
|
|
// And store the new special URI ids
|
|
fEmptyNamespaceId = emptyId;
|
|
fUnknownNamespaceId = unknownId;
|
|
fXMLNamespaceId = xmlId;
|
|
fXMLNSNamespaceId = xmlNSId;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WFElemStack: Private helpers
|
|
// ---------------------------------------------------------------------------
|
|
void WFElemStack::expandMap()
|
|
{
|
|
//
|
|
// Expand the capacity by 25%, or initialize it to 16 if its currently
|
|
// empty. Then allocate a new temp buffer.
|
|
//
|
|
const XMLSize_t newCapacity = fMapCapacity ?
|
|
(XMLSize_t)(fMapCapacity * 1.25) : 16;
|
|
PrefMapElem* newMap = (PrefMapElem*) fMemoryManager->allocate
|
|
(
|
|
newCapacity * sizeof(PrefMapElem)
|
|
);//new PrefMapElem[newCapacity];
|
|
|
|
//
|
|
// Copy over the old stuff. We DON'T have to zero out the new stuff
|
|
// since this is a by value map and the current map index controls what
|
|
// is relevant.
|
|
//
|
|
if (fMapCapacity) {
|
|
|
|
memcpy(newMap, fMap, fMapCapacity * sizeof(PrefMapElem));
|
|
fMemoryManager->deallocate(fMap);//delete [] fMap;
|
|
}
|
|
|
|
fMap = newMap;
|
|
fMapCapacity = newCapacity;
|
|
}
|
|
|
|
void WFElemStack::expandStack()
|
|
{
|
|
// Expand the capacity by 25% and allocate a new buffer
|
|
const XMLSize_t newCapacity = (XMLSize_t)(fStackCapacity * 1.25);
|
|
StackElem** newStack = (StackElem**) fMemoryManager->allocate
|
|
(
|
|
newCapacity * sizeof(StackElem*)
|
|
);//new StackElem*[newCapacity];
|
|
|
|
// Copy over the old stuff
|
|
memcpy(newStack, fStack, fStackCapacity * sizeof(StackElem*));
|
|
|
|
//
|
|
// And zero out the new stuff. Though we use a stack top, we reuse old
|
|
// stack contents so we need to know if elements have been initially
|
|
// allocated or not as we push new stuff onto the stack.
|
|
//
|
|
memset
|
|
(
|
|
&newStack[fStackCapacity]
|
|
, 0
|
|
, (newCapacity - fStackCapacity) * sizeof(StackElem*)
|
|
);
|
|
|
|
// Delete the old array and update our members
|
|
fMemoryManager->deallocate(fStack);//delete [] fStack;
|
|
fStack = newStack;
|
|
fStackCapacity = newCapacity;
|
|
}
|
|
|
|
|
|
XERCES_CPP_NAMESPACE_END
|