/*
* 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.
*/
/**
* This file contains code to build the DOM tree. It registers a document
* handler with the scanner. In these handler methods, appropriate DOM nodes
* are created and added to the DOM tree.
*
* $Id$
*
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/parsers/AbstractDOMParser.hpp>
#include <xercesc/internal/XMLScannerResolver.hpp>
#include <xercesc/internal/ElemStack.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/framework/XMLNotationDecl.hpp>
#include <xercesc/framework/XMLValidator.hpp>
#include <xercesc/framework/psvi/PSVIElement.hpp>
#include <xercesc/framework/psvi/PSVIAttribute.hpp>
#include <xercesc/framework/psvi/PSVIAttributeList.hpp>
#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
#include <xercesc/util/IOException.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationRegistry.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/impl/DOMAttrImpl.hpp>
#include <xercesc/dom/impl/DOMAttrNSImpl.hpp>
#include <xercesc/dom/impl/DOMTypeInfoImpl.hpp>
#include <xercesc/dom/impl/DOMCDATASectionImpl.hpp>
#include <xercesc/dom/DOMComment.hpp>
#include <xercesc/dom/impl/DOMTextImpl.hpp>
#include <xercesc/dom/impl/DOMDocumentImpl.hpp>
#include <xercesc/dom/impl/DOMDocumentTypeImpl.hpp>
#include <xercesc/dom/DOMDocumentType.hpp>
#include <xercesc/dom/impl/DOMElementNSImpl.hpp>
#include <xercesc/dom/impl/DOMEntityImpl.hpp>
#include <xercesc/dom/impl/DOMEntityReferenceImpl.hpp>
#include <xercesc/dom/impl/DOMNotationImpl.hpp>
#include <xercesc/dom/DOMNamedNodeMap.hpp>
#include <xercesc/dom/DOMProcessingInstruction.hpp>
#include <xercesc/dom/impl/DOMProcessingInstructionImpl.hpp>
#include <xercesc/dom/impl/DOMNodeIDMap.hpp>
#include <xercesc/dom/impl/DOMCasts.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
#include <xercesc/validators/common/GrammarResolver.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
#include <xercesc/xinclude/XIncludeUtils.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// AbstractDOMParser: Constructors and Destructor
// ---------------------------------------------------------------------------
typedef JanitorMemFunCall<AbstractDOMParser> CleanupType;
typedef JanitorMemFunCall<AbstractDOMParser> ResetInProgressType;
AbstractDOMParser::AbstractDOMParser( XMLValidator* const valToAdopt
, MemoryManager* const manager
, XMLGrammarPool* const gramPool) :
fCreateEntityReferenceNodes(true)
, fIncludeIgnorableWhitespace(true)
, fWithinElement(false)
, fParseInProgress(false)
, fCreateCommentNodes(true)
, fDocumentAdoptedByUser(false)
, fCreateSchemaInfo(false)
, fDoXInclude(false)
, fScanner(0)
, fImplementationFeatures(0)
, fCurrentParent(0)
, fCurrentNode(0)
, fCurrentEntity(0)
, fDocument(0)
, fDocumentType(0)
, fDocumentVector(0)
, fGrammarResolver(0)
, fURIStringPool(0)
, fValidator(valToAdopt)
, fMemoryManager(manager)
, fGrammarPool(gramPool)
, fBufMgr(manager)
, fInternalSubset(fBufMgr.bidOnBuffer())
, fPSVIHandler(0)
{
CleanupType cleanup(this, &AbstractDOMParser::cleanUp);
try
{
initialize();
}
catch(const OutOfMemoryException&)
{
// Don't cleanup when out of memory, since executing the
// code can cause problems.
cleanup.release();
throw;
}
cleanup.release();
}
AbstractDOMParser::~AbstractDOMParser()
{
cleanUp();
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Initialize/CleanUp methods
// ---------------------------------------------------------------------------
void AbstractDOMParser::initialize()
{
// Create grammar resolver and string pool to pass to the scanner
fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
fURIStringPool = fGrammarResolver->getStringPool();
// Create a scanner and tell it what validator to use. Then set us
// as the document event handler so we can fill the DOM document.
fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fGrammarResolver, fMemoryManager);
fScanner->setDocHandler(this);
fScanner->setDocTypeHandler(this);
fScanner->setURIStringPool(fURIStringPool);
this->reset();
}
void AbstractDOMParser::cleanUp()
{
if (fDocumentVector)
delete fDocumentVector;
if (!fDocumentAdoptedByUser && fDocument)
fDocument->release();
delete fScanner;
delete fGrammarResolver;
// grammar pool *always* owns this
//delete fURIStringPool;
fMemoryManager->deallocate(fImplementationFeatures);
if (fValidator)
delete fValidator;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Utilities
// ---------------------------------------------------------------------------
void AbstractDOMParser::reset()
{
// if fDocument exists already, store the old pointer in the vector for deletion later
if (fDocument && !fDocumentAdoptedByUser) {
if (!fDocumentVector) {
// allocate the vector if not exists yet
fDocumentVector = new (fMemoryManager) RefVectorOf<DOMDocumentImpl>(10, true, fMemoryManager) ;
}
fDocumentVector->addElement(fDocument);
}
fDocument = 0;
resetDocType();
fCurrentParent = 0;
fCurrentNode = 0;
fCurrentEntity = 0;
fWithinElement = false;
fDocumentAdoptedByUser = false;
fInternalSubset.reset();
}
void AbstractDOMParser::resetInProgress()
{
fParseInProgress = false;
}
void AbstractDOMParser::resetPool()
{
// We cannot enter here while a regular parse is in progress.
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
if (fDocumentVector)
fDocumentVector->removeAllElements();
if (!fDocumentAdoptedByUser && fDocument)
fDocument->release();
fDocument = 0;
}
bool AbstractDOMParser::isDocumentAdopted() const
{
return fDocumentAdoptedByUser;
}
DOMDocument* AbstractDOMParser::adoptDocument()
{
fDocumentAdoptedByUser = true;
return fDocument;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Getter methods
// ---------------------------------------------------------------------------
DOMDocument* AbstractDOMParser::getDocument()
{
return fDocument;
}
const XMLValidator& AbstractDOMParser::getValidator() const
{
return *fScanner->getValidator();
}
bool AbstractDOMParser::getDoNamespaces() const
{
return fScanner->getDoNamespaces();
}
bool AbstractDOMParser::getGenerateSyntheticAnnotations() const
{
return fScanner->getGenerateSyntheticAnnotations();
}
bool AbstractDOMParser::getValidateAnnotations() const
{
return fScanner->getValidateAnnotations();
}
bool AbstractDOMParser::getExitOnFirstFatalError() const
{
return fScanner->getExitOnFirstFatal();
}
bool AbstractDOMParser::getValidationConstraintFatal() const
{
return fScanner->getValidationConstraintFatal();
}
AbstractDOMParser::ValSchemes AbstractDOMParser::getValidationScheme() const
{
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
if (scheme == XMLScanner::Val_Always)
return Val_Always;
else if (scheme == XMLScanner::Val_Never)
return Val_Never;
return Val_Auto;
}
bool AbstractDOMParser::getDoSchema() const
{
return fScanner->getDoSchema();
}
bool AbstractDOMParser::getValidationSchemaFullChecking() const
{
return fScanner->getValidationSchemaFullChecking();
}
bool AbstractDOMParser::getIdentityConstraintChecking() const
{
return fScanner->getIdentityConstraintChecking();
}
XMLSize_t AbstractDOMParser::getErrorCount() const
{
return fScanner->getErrorCount();
}
XMLCh* AbstractDOMParser::getExternalSchemaLocation() const
{
return fScanner->getExternalSchemaLocation();
}
XMLCh* AbstractDOMParser::getExternalNoNamespaceSchemaLocation() const
{
return fScanner->getExternalNoNamespaceSchemaLocation();
}
SecurityManager* AbstractDOMParser::getSecurityManager() const
{
return fScanner->getSecurityManager();
}
// Return it as a reference so that we cn return as void* from getParameter.
//
const XMLSize_t& AbstractDOMParser::getLowWaterMark() const
{
return fScanner->getLowWaterMark();
}
bool AbstractDOMParser::getLoadExternalDTD() const
{
return fScanner->getLoadExternalDTD();
}
bool AbstractDOMParser::getLoadSchema() const
{
return fScanner->getLoadSchema();
}
bool AbstractDOMParser::getCalculateSrcOfs() const
{
return fScanner->getCalculateSrcOfs();
}
bool AbstractDOMParser::getStandardUriConformant() const
{
return fScanner->getStandardUriConformant();
}
bool AbstractDOMParser::getIgnoreAnnotations() const
{
return fScanner->getIgnoreAnnotations();
}
bool AbstractDOMParser::getDisableDefaultEntityResolution() const
{
return fScanner->getDisableDefaultEntityResolution();
}
bool AbstractDOMParser::getSkipDTDValidation() const
{
return fScanner->getSkipDTDValidation();
}
bool AbstractDOMParser::getHandleMultipleImports() const
{
return fScanner->getHandleMultipleImports();
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Setter methods
// ---------------------------------------------------------------------------
void AbstractDOMParser::setPSVIHandler(PSVIHandler* const handler)
{
fPSVIHandler = handler;
if (fPSVIHandler) {
fScanner->setPSVIHandler(this);
}
else if(!fCreateSchemaInfo) {
fScanner->setPSVIHandler(0);
}
}
void AbstractDOMParser::setDoNamespaces(const bool newState)
{
fScanner->setDoNamespaces(newState);
}
void AbstractDOMParser::setGenerateSyntheticAnnotations(const bool newState)
{
fScanner->setGenerateSyntheticAnnotations(newState);
}
void AbstractDOMParser::setValidateAnnotations(const bool newState)
{
fScanner->setValidateAnnotations(newState);
}
void AbstractDOMParser::setExitOnFirstFatalError(const bool newState)
{
fScanner->setExitOnFirstFatal(newState);
}
void AbstractDOMParser::setValidationConstraintFatal(const bool newState)
{
fScanner->setValidationConstraintFatal(newState);
}
void AbstractDOMParser::setValidationScheme(const ValSchemes newScheme)
{
if (newScheme == Val_Never)
fScanner->setValidationScheme(XMLScanner::Val_Never);
else if (newScheme == Val_Always)
fScanner->setValidationScheme(XMLScanner::Val_Always);
else
fScanner->setValidationScheme(XMLScanner::Val_Auto);
}
void AbstractDOMParser::setDoSchema(const bool newState)
{
fScanner->setDoSchema(newState);
}
void AbstractDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
{
fScanner->setValidationSchemaFullChecking(schemaFullChecking);
}
void AbstractDOMParser::setIdentityConstraintChecking(const bool identityConstraintChecking)
{
fScanner->setIdentityConstraintChecking(identityConstraintChecking);
}
void AbstractDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
{
fScanner->setExternalSchemaLocation(schemaLocation);
}
void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
{
fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
}
void AbstractDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
{
fScanner->setExternalSchemaLocation(schemaLocation);
}
void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
{
fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
}
void AbstractDOMParser::setSecurityManager(SecurityManager* const securityManager)
{
// since this could impact various components, don't permit it to change
// during a parse
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
fScanner->setSecurityManager(securityManager);
}
void AbstractDOMParser::setLowWaterMark(XMLSize_t lwm)
{
fScanner->setLowWaterMark(lwm);
}
void AbstractDOMParser::setLoadExternalDTD(const bool newState)
{
fScanner->setLoadExternalDTD(newState);
}
void AbstractDOMParser::setLoadSchema(const bool newState)
{
fScanner->setLoadSchema(newState);
}
void AbstractDOMParser::setCalculateSrcOfs(const bool newState)
{
fScanner->setCalculateSrcOfs(newState);
}
void AbstractDOMParser::setStandardUriConformant(const bool newState)
{
fScanner->setStandardUriConformant(newState);
}
void AbstractDOMParser::useScanner(const XMLCh* const scannerName)
{
XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
(
scannerName
, fValidator
, fGrammarResolver
, fMemoryManager
);
if (tempScanner) {
tempScanner->setParseSettings(fScanner);
tempScanner->setURIStringPool(fURIStringPool);
delete fScanner;
fScanner = tempScanner;
}
}
void AbstractDOMParser::setCreateSchemaInfo(const bool create)
{
fCreateSchemaInfo = create;
if(fCreateSchemaInfo)
fScanner->setPSVIHandler(this);
else if(!fPSVIHandler)
fScanner->setPSVIHandler(0);
}
void AbstractDOMParser::setIgnoreAnnotations(const bool newValue)
{
fScanner->setIgnoreAnnotations(newValue);
}
void AbstractDOMParser::setDisableDefaultEntityResolution(const bool newValue)
{
fScanner->setDisableDefaultEntityResolution(newValue);
}
void AbstractDOMParser::setSkipDTDValidation(const bool newValue)
{
fScanner->setSkipDTDValidation(newValue);
}
void AbstractDOMParser::setHandleMultipleImports(const bool newValue)
{
fScanner->setHandleMultipleImports(newValue);
}
void AbstractDOMParser::setDocument(DOMDocument* toSet)
{
fDocument = (DOMDocumentImpl *)toSet;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Parsing methods
// ---------------------------------------------------------------------------
void AbstractDOMParser::parse(const InputSource& source)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
ResetInProgressType resetInProgress(this, &AbstractDOMParser::resetInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(source);
if (fDoXInclude && getErrorCount()==0){
DOMDocument *doc = getDocument();
// after XInclude, the document must be normalized
if(doc)
doc->normalizeDocument();
}
}
catch(const OutOfMemoryException&)
{
resetInProgress.release();
throw;
}
}
void AbstractDOMParser::parse(const XMLCh* const systemId)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
ResetInProgressType resetInProgress(this, &AbstractDOMParser::resetInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId);
if (fDoXInclude && getErrorCount()==0){
DOMDocument *doc = getDocument();
// after XInclude, the document must be normalized
if(doc)
doc->normalizeDocument();
}
}
catch(const OutOfMemoryException&)
{
resetInProgress.release();
throw;
}
}
void AbstractDOMParser::parse(const char* const systemId)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
ResetInProgressType resetInProgress(this, &AbstractDOMParser::resetInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId);
if (fDoXInclude && getErrorCount()==0){
DOMDocument *doc = getDocument();
// after XInclude, the document must be normalized
if(doc)
doc->normalizeDocument();
}
}
catch(const OutOfMemoryException&)
{
resetInProgress.release();
throw;
}
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Progressive parse methods
// ---------------------------------------------------------------------------
bool AbstractDOMParser::parseFirst( const XMLCh* const systemId
, XMLPScanToken& toFill)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
return fScanner->scanFirst(systemId, toFill);
}
bool AbstractDOMParser::parseFirst( const char* const systemId
, XMLPScanToken& toFill)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
return fScanner->scanFirst(systemId, toFill);
}
bool AbstractDOMParser::parseFirst( const InputSource& source
, XMLPScanToken& toFill)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
return fScanner->scanFirst(source, toFill);
}
bool AbstractDOMParser::parseNext(XMLPScanToken& token)
{
return fScanner->scanNext(token);
}
void AbstractDOMParser::parseReset(XMLPScanToken& token)
{
// Reset the scanner, and then reset the parser
fScanner->scanReset(token);
reset();
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Implementation of PSVIHandler interface
// ---------------------------------------------------------------------------
void AbstractDOMParser::handleElementPSVI(const XMLCh* const localName
, const XMLCh* const uri
, PSVIElement * elementInfo)
{
// associate the info now; if the user wants, she can override what we did
if(fCreateSchemaInfo)
{
DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, elementInfo->getValidity());
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, elementInfo->getValidationAttempted());
if(elementInfo->getTypeDefinition())
{
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, elementInfo->getTypeDefinition()->getTypeCategory());
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, elementInfo->getTypeDefinition()->getAnonymous());
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
fDocument->getPooledString(elementInfo->getTypeDefinition()->getNamespace()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
fDocument->getPooledString(elementInfo->getTypeDefinition()->getName()));
}
else if(elementInfo->getValidity()==PSVIItem::VALIDITY_VALID)
{
// if we are valid but we don't have a type validator, we are xs:anyType
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::COMPLEX_TYPE);
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgATTVAL_ANYTYPE);
}
if(elementInfo->getMemberTypeDefinition())
{
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, elementInfo->getMemberTypeDefinition()->getAnonymous());
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getNamespace()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getName()));
}
if(elementInfo->getElementDeclaration())
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Nil, elementInfo->getElementDeclaration()->getNillable());
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(elementInfo->getSchemaDefault()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(elementInfo->getSchemaNormalizedValue()));
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
((DOMElementNSImpl*)fCurrentParent)->setSchemaTypeInfo(typeInfo);
}
if(fPSVIHandler)
fPSVIHandler->handleElementPSVI(localName, uri, elementInfo);
}
void AbstractDOMParser::handlePartialElementPSVI(const XMLCh* const localName
, const XMLCh* const uri
, PSVIElement * elementInfo)
{
if(fPSVIHandler)
fPSVIHandler->handlePartialElementPSVI(localName, uri, elementInfo);
}
void AbstractDOMParser::handleAttributesPSVI( const XMLCh* const localName
, const XMLCh* const uri
, PSVIAttributeList * psviAttributes)
{
if(fCreateSchemaInfo)
{
for (XMLSize_t index=0; index < psviAttributes->getLength(); index++) {
XERCES_CPP_NAMESPACE_QUALIFIER PSVIAttribute *attrInfo=psviAttributes->getAttributePSVIAtIndex(index);
XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* pAttrNode=fCurrentNode->getAttributes()->getNamedItemNS(psviAttributes->getAttributeNamespaceAtIndex(index),
psviAttributes->getAttributeNameAtIndex(index));
if(pAttrNode!=NULL)
{
DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, attrInfo->getValidity());
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, attrInfo->getValidationAttempted());
if(attrInfo->getTypeDefinition())
{
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, attrInfo->getTypeDefinition()->getAnonymous());
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
fDocument->getPooledString(attrInfo->getTypeDefinition()->getNamespace()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
fDocument->getPooledString(attrInfo->getTypeDefinition()->getName()));
}
else if(attrInfo->getValidity()==PSVIItem::VALIDITY_VALID)
{
// if we are valid but we don't have a type validator, we are xs:anySimpleType
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgDT_ANYSIMPLETYPE);
}
if(attrInfo->getMemberTypeDefinition())
{
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, attrInfo->getMemberTypeDefinition()->getAnonymous());
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getNamespace()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getName()));
}
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(attrInfo->getSchemaDefault()));
typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(attrInfo->getSchemaNormalizedValue()));
typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
((DOMAttrImpl*)pAttrNode)->setSchemaTypeInfo(typeInfo);
}
}
}
// associate the info now; if the user wants, she can override what we did
if(fPSVIHandler)
fPSVIHandler->handleAttributesPSVI(localName, uri, psviAttributes);
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Implementation of XMLDocumentHandler interface
// ---------------------------------------------------------------------------
void AbstractDOMParser::docCharacters( const XMLCh* const chars
, const XMLSize_t length
, const bool cdataSection)
{
// Ignore chars outside of content
if (!fWithinElement)
return;
if (cdataSection == true)
{
DOMCDATASection *node = createCDATASection (chars, length);
castToParentImpl (fCurrentParent)->appendChildFast (node);
fCurrentNode = node;
}
else
{
if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
{
DOMTextImpl *node = (DOMTextImpl*)fCurrentNode;
node->appendData(chars, length);
}
else
{
DOMText *node = createText (chars, length);
castToParentImpl (fCurrentParent)->appendChildFast (node);
fCurrentNode = node;
}
}
}
void AbstractDOMParser::docComment(const XMLCh* const comment)
{
if (fCreateCommentNodes) {
DOMComment *dcom = fDocument->createComment(comment);
castToParentImpl (fCurrentParent)->appendChildFast (dcom);
fCurrentNode = dcom;
}
}
void AbstractDOMParser::docPI( const XMLCh* const target
, const XMLCh* const data)
{
DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
(
target
, data
);
castToParentImpl (fCurrentParent)->appendChildFast (pi);
fCurrentNode = pi;
}
void AbstractDOMParser::endEntityReference(const XMLEntityDecl&)
{
if (!fCreateEntityReferenceNodes)
return;
DOMEntityReferenceImpl *erImpl = 0;
if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE)
erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
fCurrentNode = fCurrentParent;
fCurrentParent = fCurrentNode->getParentNode ();
// When the document is invalid but we continue parsing, we may
// end up seeing more 'end' events than the 'start' ones.
//
if (fCurrentParent == 0 && fDocument != 0)
{
fCurrentNode = fDocument->getDocumentElement ();
fCurrentParent = fCurrentNode;
}
if (erImpl)
erImpl->setReadOnly(true, true);
}
void AbstractDOMParser::endElement( const XMLElementDecl&
, const unsigned int
, const bool
, const XMLCh* const)
{
fCurrentNode = fCurrentParent;
fCurrentParent = fCurrentNode->getParentNode ();
// When the document is invalid but we continue parsing, we may
// end up seeing more 'end' events than the 'start' ones.
//
if (fCurrentParent == 0 && fDocument != 0)
{
fCurrentNode = fDocument->getDocumentElement ();
fCurrentParent = fCurrentNode;
}
// If we've hit the end of content, clear the flag.
//
if (fCurrentParent == fDocument)
fWithinElement = false;
if(fDoXInclude &&
(XIncludeUtils::isXIIncludeDOMNode(fCurrentNode) ||
((XIncludeUtils::isXIFallbackDOMNode(fCurrentNode) &&
!XMLString::equals(fCurrentParent->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)))))
{
XIncludeUtils xiu((XMLErrorReporter *) this);
// process the XInclude node, then update the fCurrentNode with the new content
if(xiu.parseDOMNodeDoingXInclude(fCurrentNode, fDocument, getScanner()->getEntityHandler()))
fCurrentNode = fCurrentParent->getLastChild();
}
}
void AbstractDOMParser::ignorableWhitespace( const XMLCh* const chars
, const XMLSize_t length
, const bool)
{
// Ignore chars before the root element
if (!fWithinElement || !fIncludeIgnorableWhitespace)
return;
// revisit. Not safe to slam in a null like this.
XMLCh savedChar = chars[length];
XMLCh *ncChars = (XMLCh *)chars; // cast off const
ncChars[length] = chNull;
if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
{
DOMText *node = (DOMText *)fCurrentNode;
node->appendData(chars);
}
else
{
DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
node->setIgnorableWhitespace(true);
castToParentImpl (fCurrentParent)->appendChildFast (node);
fCurrentNode = node;
}
ncChars[length] = savedChar;
}
void AbstractDOMParser::resetDocument()
{
//
// The reset methods are called before a new parse event occurs.
// Reset this parsers state to clear out anything that may be left
// from a previous use, in particular the DOM document itself.
//
this->reset();
}
void AbstractDOMParser::startDocument()
{
if(fImplementationFeatures == 0)
fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument(fMemoryManager);
else
fDocument = (DOMDocumentImpl *)DOMImplementationRegistry::getDOMImplementation(fImplementationFeatures)->createDocument(fMemoryManager);
// Just set the document as the current parent and current node
fCurrentParent = fDocument;
fCurrentNode = fDocument;
// set DOM error checking off
fDocument->setErrorChecking(false);
fDocument->setDocumentURI(fScanner->getLocator()->getSystemId());
fDocument->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
}
void AbstractDOMParser::endDocument()
{
// set DOM error checking back on
fDocument->setErrorChecking(true);
// DOM L2 does not support editing DocumentType nodes
if (fDocumentType && fScanner -> getDoNamespaces())
fDocumentType->setReadOnly(true, true);
}
void AbstractDOMParser::startElement(const XMLElementDecl& elemDecl
, const unsigned int urlId
, const XMLCh* const elemPrefix
, const RefVectorOf<XMLAttr>& attrList
, const XMLSize_t attrCount
, const bool isEmpty
, const bool isRoot)
{
DOMElement *elem;
DOMElementImpl *elemImpl;
const XMLCh* namespaceURI = 0;
bool doNamespaces = fScanner->getDoNamespaces();
// Create the element name. Here we are going to bypass the
// DOMDocument::createElement() interface and instantiate the
// required types directly in order to avoid name checking
// overhead.
//
if (doNamespaces)
{
//DOM Level 2, doNamespaces on
//
const XMLCh* localName = elemDecl.getBaseName();
if (urlId != fScanner->getEmptyNamespaceId()) { //TagName has a prefix
namespaceURI = fScanner->getURIText(urlId); //get namespaceURI
if (elemPrefix && *elemPrefix)
{
XMLBufBid elemQName(&fBufMgr);
elemQName.set(elemPrefix);
elemQName.append(chColon);
elemQName.append(localName);
elem = createElementNS (
namespaceURI, elemPrefix, localName, elemQName.getRawBuffer());
}
else
elem = createElementNS (namespaceURI, 0, localName, localName);
}
else
elem = createElementNS (namespaceURI, 0, localName, localName);
}
else
{ //DOM Level 1
elem = createElement (elemDecl.getFullName());
}
elemImpl = (DOMElementImpl *) elem;
if (attrCount)
{
unsigned int xmlnsNSId = fScanner->getXMLNSNamespaceId();
unsigned int emptyNSId = fScanner->getEmptyNamespaceId();
DOMAttrMapImpl* map = elemImpl->fAttributes;
map->reserve (attrCount);
for (XMLSize_t index = 0; index < attrCount; ++index)
{
const XMLAttr* oneAttrib = attrList.elementAt(index);
DOMAttrImpl *attr = 0;
if (doNamespaces)
{
//DOM Level 2, doNamespaces on
//
unsigned int attrURIId = oneAttrib->getURIId();
const XMLCh* localName = oneAttrib->getName();
const XMLCh* prefix = oneAttrib->getPrefix();
namespaceURI = 0;
if ((prefix==0 || *prefix==0) && XMLString::equals(localName, XMLUni::fgXMLNSString))
{
// xmlns=...
attrURIId = xmlnsNSId;
}
if (attrURIId != emptyNSId)
{
//TagName has a prefix
namespaceURI = fScanner->getURIText(attrURIId);
}
attr = (DOMAttrImpl*) createAttrNS (namespaceURI,
prefix,
localName,
oneAttrib->getQName());
map->setNamedItemNSFast(attr);
}
else
{
attr = (DOMAttrImpl*) createAttr (oneAttrib->getName());
map->setNamedItemFast(attr);
}
attr->setValueFast(oneAttrib->getValue());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
// that is constructed for use by GetElementByID().
//
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (fDocument->fNodeIDMap == 0)
fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
fDocument->fNodeIDMap->add(attr);
attr->fNode.isIdAttr(true);
}
attr->setSpecified(oneAttrib->getSpecified());
// store DTD validation information
if(fCreateSchemaInfo)
{
switch(oneAttrib->getType())
{
case XMLAttDef::CData: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
case XMLAttDef::ID: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
case XMLAttDef::IDRef: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
case XMLAttDef::IDRefs: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
case XMLAttDef::Entity: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
case XMLAttDef::Entities: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
case XMLAttDef::NmToken: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
case XMLAttDef::NmTokens: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
case XMLAttDef::Notation: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
case XMLAttDef::Enumeration: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
default: attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
}
}
}
}
//Set up the default attributes if any.
//
if (elemDecl.hasAttDefs())
{
XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
XMLAttDef* attr = 0;
DOMAttrImpl * insertAttr = 0;
for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
{
attr = &defAttrs->getAttDef(i);
const XMLAttDef::DefAttTypes defType = attr->getDefaultType();
if ((defType == XMLAttDef::Default)
|| (defType == XMLAttDef::Fixed))
{
if (doNamespaces)
{
// DOM Level 2 wants all namespace declaration attributes
// to be bound to "http://www.w3.org/2000/xmlns/"
// So as long as the XML parser doesn't do it, it needs to
// be done here.
const XMLCh* qualifiedName = attr->getFullName();
XMLBufBid bbPrefixQName(&fBufMgr);
XMLBuffer& prefixBuf = bbPrefixQName.getBuffer();
int colonPos = -1;
unsigned int uriId = fScanner->resolveQName(qualifiedName, prefixBuf, ElemStack::Mode_Attribute, colonPos);
const XMLCh* namespaceURI = 0;
if (XMLString::equals(qualifiedName, XMLUni::fgXMLNSString)) //for xmlns=...
uriId = fScanner->getXMLNSNamespaceId();
if (uriId != fScanner->getEmptyNamespaceId()) { //TagName has a prefix
namespaceURI = fScanner->getURIText(uriId);
}
insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(namespaceURI, // NameSpaceURI
qualifiedName); // qualified name
DOMAttr* remAttr = elemImpl->setDefaultAttributeNodeNS(insertAttr);
if (remAttr)
remAttr->release();
}
else
{
// Namespaces is turned off...
insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
DOMNode* remAttr = elemImpl->setDefaultAttributeNode(insertAttr);
if (remAttr)
remAttr->release();
}
//need to do this before the get as otherwise we overwrite any value in the attr
if (attr->getValue() != 0)
{
insertAttr->setValueFast(attr->getValue());
insertAttr->setSpecified(false);
}
// store DTD validation information
if(fCreateSchemaInfo)
{
switch(attr->getType())
{
case XMLAttDef::CData: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
case XMLAttDef::ID: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
case XMLAttDef::IDRef: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
case XMLAttDef::IDRefs: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
case XMLAttDef::Entity: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
case XMLAttDef::Entities: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
case XMLAttDef::NmToken: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
case XMLAttDef::NmTokens: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
case XMLAttDef::Notation: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
case XMLAttDef::Enumeration: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
default: insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
}
}
}
insertAttr = 0;
attr->reset();
}
}
if (fCurrentParent != fDocument)
castToParentImpl (fCurrentParent)->appendChildFast (elem);
else
fCurrentParent->appendChild (elem);
fCurrentParent = elem;
fCurrentNode = elem;
fWithinElement = true;
// If an empty element, do end right now (no endElement() will be called)
if (isEmpty)
endElement(elemDecl, urlId, isRoot, elemPrefix);
}
void AbstractDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
{
const XMLCh * entName = entDecl.getName();
DOMNamedNodeMap *entities = fDocumentType->getEntities();
DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
if (entity)
entity->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
fCurrentEntity = entity;
// Following line has been moved up so that erImpl is only declared
// and used if create entity ref flag is true
if (fCreateEntityReferenceNodes == true) {
DOMEntityReference *er = fDocument->createEntityReferenceByParser(entName);
//set the readOnly flag to false before appending node, will be reset
// in endEntityReference
DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
erImpl->setReadOnly(false, true);
castToParentImpl (fCurrentParent)->appendChildFast (er);
fCurrentParent = er;
fCurrentNode = er;
// this entityRef needs to be stored in Entity map too.
// We'd decide later whether the entity nodes should be created by a
// separated method in parser or not. For now just stick it in if
// the ref nodes are created
if (entity)
entity->setEntityRef(er);
}
}
void AbstractDOMParser::XMLDecl(const XMLCh* const version
, const XMLCh* const encoding
, const XMLCh* const standalone
, const XMLCh* const actualEncStr)
{
fDocument->setXmlStandalone(XMLString::equals(XMLUni::fgYesString, standalone));
fDocument->setXmlVersion(version);
fDocument->setXmlEncoding(encoding);
fDocument->setInputEncoding(actualEncStr);
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Helper methods
// ---------------------------------------------------------------------------
//doctypehandler interfaces
void AbstractDOMParser::attDef
(
const DTDElementDecl& elemDecl
, const DTDAttDef& attDef
, const bool
)
{
if (fDocumentType->isIntSubsetReading())
{
if (elemDecl.hasAttDefs())
{
fInternalSubset.append(attDef.getFullName());
// Get the type and display it
const XMLAttDef::AttTypes type = attDef.getType();
switch(type)
{
case XMLAttDef::CData :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgCDATAString);
break;
case XMLAttDef::ID :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgIDString);
break;
case XMLAttDef::IDRef :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgIDRefString);
break;
case XMLAttDef::IDRefs :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgIDRefsString);
break;
case XMLAttDef::Entity :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgEntityString);
break;
case XMLAttDef::Entities :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgEntitiesString);
break;
case XMLAttDef::NmToken :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgNmTokenString);
break;
case XMLAttDef::NmTokens :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgNmTokensString);
break;
case XMLAttDef::Notation :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgNotationString);
break;
case XMLAttDef::Enumeration :
{
fInternalSubset.append(chSpace);
const XMLCh* enumString = attDef.getEnumeration();
XMLSize_t length = XMLString::stringLen(enumString);
if (length > 0) {
fInternalSubset.append(chOpenParen );
for(XMLSize_t i=0; i<length; i++) {
if (enumString[i] == chSpace)
fInternalSubset.append(chPipe);
else
fInternalSubset.append(enumString[i]);
}
fInternalSubset.append(chCloseParen);
}
}
break;
default:
// remaining types don't belong to a DTD
break;
}
//get te default types of the attlist
const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
switch(def)
{
case XMLAttDef::Required :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgRequiredString);
break;
case XMLAttDef::Implied :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgImpliedString);
break;
case XMLAttDef::Fixed :
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgFixedString);
break;
default:
// remaining types don't belong to a DTD
break;
}
const XMLCh* defaultValue = attDef.getValue();
if (defaultValue != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(defaultValue);
fInternalSubset.append(chDoubleQuote);
}
}
}
}
void AbstractDOMParser::doctypeComment
(
const XMLCh* const comment
)
{
if (fDocumentType->isIntSubsetReading())
{
if (comment != 0)
{
fInternalSubset.append(XMLUni::fgCommentString);
fInternalSubset.append(chSpace);
fInternalSubset.append(comment);
fInternalSubset.append(chSpace);
fInternalSubset.append(chDash);
fInternalSubset.append(chDash);
fInternalSubset.append(chCloseAngle);
}
}
}
void AbstractDOMParser::doctypeDecl
(
const DTDElementDecl& elemDecl
, const XMLCh* const publicId
, const XMLCh* const systemId
, const bool
, const bool
)
{
fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
fDocument->setDocumentType(fDocumentType);
}
void AbstractDOMParser::doctypePI
(
const XMLCh* const target
, const XMLCh* const data
)
{
if (fDocumentType->isIntSubsetReading())
{
//add these chars to internalSubset variable
fInternalSubset.append(chOpenAngle);
fInternalSubset.append(chQuestion);
fInternalSubset.append(target);
fInternalSubset.append(chSpace);
fInternalSubset.append(data);
fInternalSubset.append(chQuestion);
fInternalSubset.append(chCloseAngle);
}
}
void AbstractDOMParser::doctypeWhitespace
(
const XMLCh* const chars
, const XMLSize_t length
)
{
if (fDocumentType->isIntSubsetReading())
fInternalSubset.append(chars, length);
}
void AbstractDOMParser::elementDecl
(
const DTDElementDecl& decl
, const bool
)
{
if (fDocumentType->isIntSubsetReading())
{
fInternalSubset.append(chOpenAngle);
fInternalSubset.append(chBang);
fInternalSubset.append(XMLUni::fgElemString);
fInternalSubset.append(chSpace);
fInternalSubset.append(decl.getFullName());
//get the ContentSpec information
const XMLCh* contentModel = decl.getFormattedContentModel();
if (contentModel != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(contentModel);
}
fInternalSubset.append(chCloseAngle);
}
}
void AbstractDOMParser::endAttList
(
const DTDElementDecl& elemDecl
)
{
if (fDocumentType->isIntSubsetReading())
{
//print the closing angle
fInternalSubset.append(chCloseAngle);
}
// this section sets up default attributes.
// default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
// default attribute data attached to the document is used to conform to the
// DOM spec regarding creating element nodes & removing attributes with default values
// see DocumentTypeImpl
if (elemDecl.hasAttDefs())
{
XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
XMLAttDef* attr = 0;
DOMAttrImpl * insertAttr = 0;
DOMElement *elem = fDocument->createElement(elemDecl.getFullName());
DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
bool doNamespaces = fScanner->getDoNamespaces();
for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
{
attr = &defAttrs->getAttDef(i);
if (attr->getValue() != 0)
{
if (doNamespaces)
{
// DOM Level 2 wants all namespace declaration attributes
// to be bound to "http://www.w3.org/2000/xmlns/"
// So as long as the XML parser doesn't do it, it needs to
// done here.
const XMLCh* qualifiedName = attr->getFullName();
int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
XMLBufBid bbQName(&fBufMgr);
XMLBuffer& buf = bbQName.getBuffer();
static const XMLCh XMLNS[] = {
chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
if (index > 0) {
// there is prefix
// map to XML URI for all cases except when prefix == "xmlns"
XMLCh* prefix;
XMLCh temp[1000];
if (index > 999)
prefix = (XMLCh*) fMemoryManager->allocate
(
(index + 1) * sizeof(XMLCh)
);//new XMLCh[index+1];
else
prefix = temp;
XMLString::subString(prefix ,qualifiedName, 0, index, fMemoryManager);
if (XMLString::equals(prefix,XMLNS))
buf.append(XMLUni::fgXMLNSURIName);
else
buf.append(XMLUni::fgXMLURIName);
if (index > 999)
fMemoryManager->deallocate(prefix);//delete [] prefix;
}
else {
// No prefix
if (XMLString::equals(qualifiedName,XMLNS))
buf.append(XMLUni::fgXMLNSURIName);
}
insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
buf.getRawBuffer(), // NameSpaceURI
qualifiedName); // qualified name
DOMNode* remAttr = elemImpl->setAttributeNodeNS(insertAttr);
if (remAttr)
remAttr->release();
}
else
{
// Namespaces is turned off...
insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
DOMNode* remAttr = elemImpl->setAttributeNode(insertAttr);
if (remAttr)
remAttr->release();
}
insertAttr->setValueFast(attr->getValue());
insertAttr->setSpecified(false);
}
}
DOMNode* rem = fDocumentType->getElements()->setNamedItem(elemImpl);
if (rem)
rem->release();
}
}
void AbstractDOMParser::endIntSubset()
{
fDocumentType->setInternalSubset(fInternalSubset.getRawBuffer());
// the buffer shouldn't be released as it is reused in the next parse
// fBufMgr.releaseBuffer(fInternalSubset);
fDocumentType->fIntSubsetReading = false;
}
void AbstractDOMParser::endExtSubset()
{
}
void AbstractDOMParser::entityDecl
(
const DTDEntityDecl& entityDecl
, const bool
, const bool
)
{
DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
entity->setPublicId(entityDecl.getPublicId());
entity->setSystemId(entityDecl.getSystemId());
entity->setNotationName(entityDecl.getNotationName());
entity->setBaseURI(entityDecl.getBaseURI());
DOMEntityImpl *previousDef = (DOMEntityImpl *)
fDocumentType->getEntities()->setNamedItem( entity );
if (previousDef)
previousDef->release();
if (fDocumentType->isIntSubsetReading())
{
//add thes chars to internalSubset variable
fInternalSubset.append(chOpenAngle);
fInternalSubset.append(chBang);
fInternalSubset.append(XMLUni::fgEntityString);
fInternalSubset.append(chSpace);
fInternalSubset.append(entityDecl.getName());
const XMLCh* id = entity->getPublicId();
if (id != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgPubIDString);
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(id);
fInternalSubset.append(chDoubleQuote);
}
id = entity->getSystemId();
if (id != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgSysIDString);
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(id);
fInternalSubset.append(chDoubleQuote);
}
id = entity->getNotationName();
if (id != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgNDATAString);
fInternalSubset.append(chSpace);
fInternalSubset.append(id);
}
id = entityDecl.getValue();
if (id !=0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(id);
fInternalSubset.append(chDoubleQuote);
}
fInternalSubset.append(chCloseAngle);
}
}
void AbstractDOMParser::resetDocType()
{
fDocumentType = 0;
}
void AbstractDOMParser::notationDecl
(
const XMLNotationDecl& notDecl
, const bool
)
{
DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
notation->setPublicId(notDecl.getPublicId());
notation->setSystemId(notDecl.getSystemId());
notation->setBaseURI(notDecl.getBaseURI());
DOMNode* rem = fDocumentType->getNotations()->setNamedItem( notation );
if (rem)
rem->release();
if (fDocumentType->isIntSubsetReading())
{
//add thes chars to internalSubset variable
fInternalSubset.append(chOpenAngle);
fInternalSubset.append(chBang);
fInternalSubset.append(XMLUni::fgNotationString);
fInternalSubset.append(chSpace);
fInternalSubset.append(notDecl.getName());
const XMLCh* id = notation->getPublicId();
if (id != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgPubIDString);
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(id);
fInternalSubset.append(chDoubleQuote);
}
id = notation->getSystemId();
if (id != 0) {
fInternalSubset.append(chSpace);
fInternalSubset.append(XMLUni::fgSysIDString);
fInternalSubset.append(chSpace);
fInternalSubset.append(chDoubleQuote);
fInternalSubset.append(id);
fInternalSubset.append(chDoubleQuote);
}
fInternalSubset.append(chCloseAngle);
}
}
void AbstractDOMParser::startAttList
(
const DTDElementDecl& elemDecl
)
{
if (fDocumentType->isIntSubsetReading())
{
fInternalSubset.append(chOpenAngle);
fInternalSubset.append(chBang);
fInternalSubset.append(XMLUni::fgAttListString);
fInternalSubset.append(chSpace);
fInternalSubset.append(elemDecl.getFullName());
}
}
void AbstractDOMParser::startIntSubset()
{
fDocumentType->fIntSubsetReading = true;
}
void AbstractDOMParser::startExtSubset()
{
}
void AbstractDOMParser::TextDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
)
{
if (fCurrentEntity) {
fCurrentEntity->setXmlVersion(versionStr);
fCurrentEntity->setXmlEncoding(encodingStr);
}
}
DOMCDATASection* AbstractDOMParser::
createCDATASection (const XMLCh* s, XMLSize_t n)
{
return new (fDocument, DOMMemoryManager::CDATA_SECTION_OBJECT)
DOMCDATASectionImpl(fDocument, s, n);
}
DOMText* AbstractDOMParser::
createText (const XMLCh* s, XMLSize_t n)
{
return new (fDocument, DOMMemoryManager::TEXT_OBJECT)
DOMTextImpl(fDocument, s, n);
}
DOMElement* AbstractDOMParser::
createElement (const XMLCh* name)
{
return new (fDocument, DOMMemoryManager::ELEMENT_OBJECT)
DOMElementImpl(fDocument, name);
}
DOMElement* AbstractDOMParser::
createElementNS (const XMLCh* namespaceURI,
const XMLCh* elemPrefix,
const XMLCh* localName,
const XMLCh* qName)
{
return new (fDocument, DOMMemoryManager::ELEMENT_NS_OBJECT)
DOMElementNSImpl (fDocument,
namespaceURI,
elemPrefix,
localName,
qName);
}
DOMAttr* AbstractDOMParser::
createAttr (const XMLCh* name)
{
return new (fDocument, DOMMemoryManager::ATTR_OBJECT)
DOMAttrImpl(fDocument, name);
}
DOMAttr* AbstractDOMParser::
createAttrNS (const XMLCh* namespaceURI,
const XMLCh* elemPrefix,
const XMLCh* localName,
const XMLCh* qName)
{
return new (fDocument, DOMMemoryManager::ATTR_NS_OBJECT)
DOMAttrNSImpl (fDocument,
namespaceURI,
elemPrefix,
localName,
qName);
}
XERCES_CPP_NAMESPACE_END