/ATF2/control-software/epics-3.14.8/extensions/src/ChannelArchiver/ThirdParty/xerces-c-src2_4_0/src/xercesc/internal/WFXMLScanner.cpp
C++ | 1863 lines | 1233 code | 202 blank | 428 comment | 272 complexity | 0ef386fc20d60e24eb5ea78c005547f0 MD5 | raw file
Possible License(s): BSD-2-Clause, LGPL-2.0, IPL-1.0, BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
- /*
- * The Apache Software License, Version 1.1
- *
- * Copyright (c) 2002,2003 The Apache Software Foundation. All rights
- * reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * 3. The end-user documentation included with the redistribution,
- * if any, must include the following acknowledgment:
- * "This product includes software developed by the
- * Apache Software Foundation (http://www.apache.org/)."
- * Alternately, this acknowledgment may appear in the software itself,
- * if and wherever such third-party acknowledgments normally appear.
- *
- * 4. The names "Xerces" and "Apache Software Foundation" must
- * not be used to endorse or promote products derived from this
- * software without prior written permission. For written
- * permission, please contact apache\@apache.org.
- *
- * 5. Products derived from this software may not be called "Apache",
- * nor may "Apache" appear in their name, without prior written
- * permission of the Apache Software Foundation.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ====================================================================
- *
- * This software consists of voluntary contributions made by many
- * individuals on behalf of the Apache Software Foundation, and was
- * originally based on software copyright (c) 1999, International
- * Business Machines, Inc., http://www.ibm.com . For more information
- * on the Apache Software Foundation, please see
- * <http://www.apache.org/>.
- */
- /*
- * $Id: WFXMLScanner.cpp,v 1.1.1.1 2009/03/14 06:42:19 whitegr Exp $
- */
- // ---------------------------------------------------------------------------
- // Includes
- // ---------------------------------------------------------------------------
- #include <xercesc/internal/WFXMLScanner.hpp>
- #include <xercesc/util/Janitor.hpp>
- #include <xercesc/util/RuntimeException.hpp>
- #include <xercesc/util/UnexpectedEOFException.hpp>
- #include <xercesc/sax/InputSource.hpp>
- #include <xercesc/framework/XMLDocumentHandler.hpp>
- #include <xercesc/framework/XMLEntityHandler.hpp>
- #include <xercesc/framework/XMLPScanToken.hpp>
- #include <xercesc/framework/XMLValidityCodes.hpp>
- #include <xercesc/internal/EndOfEntityException.hpp>
- #include <xercesc/util/OutOfMemoryException.hpp>
- XERCES_CPP_NAMESPACE_BEGIN
- // ---------------------------------------------------------------------------
- // WFXMLScanner: Constructors and Destructor
- // ---------------------------------------------------------------------------
- WFXMLScanner::WFXMLScanner( XMLValidator* const valToAdopt
- , GrammarResolver* const grammarResolver
- , MemoryManager* const manager) :
- XMLScanner(valToAdopt, grammarResolver, manager)
- , fElementIndex(0)
- , fElements(0)
- , fEntityTable(0)
- , fAttrNameHashList(0)
- , fAttrNSList(0)
- , fElementLookup(0)
- {
- try
- {
- commonInit();
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- cleanUp();
- throw;
- }
- }
- WFXMLScanner::WFXMLScanner( XMLDocumentHandler* const docHandler
- , DocTypeHandler* const docTypeHandler
- , XMLEntityHandler* const entityHandler
- , XMLErrorReporter* const errHandler
- , XMLValidator* const valToAdopt
- , GrammarResolver* const grammarResolver
- , MemoryManager* const manager) :
- XMLScanner(docHandler, docTypeHandler, entityHandler, errHandler, valToAdopt, grammarResolver, manager)
- , fElementIndex(0)
- , fElements(0)
- , fEntityTable(0)
- , fAttrNameHashList(0)
- , fAttrNSList(0)
- , fElementLookup(0)
- {
- try
- {
- commonInit();
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- cleanUp();
- throw;
- }
- }
- WFXMLScanner::~WFXMLScanner()
- {
- cleanUp();
- }
- // ---------------------------------------------------------------------------
- // XMLScanner: Getter methods
- // ---------------------------------------------------------------------------
- NameIdPool<DTDEntityDecl>* WFXMLScanner::getEntityDeclPool()
- {
- return 0;
- }
- const NameIdPool<DTDEntityDecl>* WFXMLScanner::getEntityDeclPool() const
- {
- return 0;
- }
- // ---------------------------------------------------------------------------
- // WFXMLScanner: Main entry point to scan a document
- // ---------------------------------------------------------------------------
- void WFXMLScanner::scanDocument(const InputSource& src)
- {
- // Bump up the sequence id for this parser instance. This will invalidate
- // any previous progressive scan tokens.
- fSequenceId++;
- try
- {
- // Reset the scanner and its plugged in stuff for a new run. This
- // resets all the data structures, creates the initial reader and
- // pushes it on the stack, and sets up the base document path.
- scanReset(src);
- // If we have a document handler, then call the start document
- if (fDocHandler)
- fDocHandler->startDocument();
- // Scan the prolog part, which is everything before the root element
- // including the DTD subsets.
- scanProlog();
- // If we got to the end of input, then its not a valid XML file.
- // Else, go on to scan the content.
- if (fReaderMgr.atEOF())
- {
- emitError(XMLErrs::EmptyMainEntity);
- }
- else
- {
- // Scan content, and tell it its not an external entity
- if (scanContent(false))
- {
- // That went ok, so scan for any miscellaneous stuff
- if (!fReaderMgr.atEOF())
- scanMiscellaneous();
- }
- }
- // If we have a document handler, then call the end document
- if (fDocHandler)
- fDocHandler->endDocument();
- // Reset the reader manager to close all files, sockets, etc...
- fReaderMgr.reset();
- }
- // NOTE:
- //
- // In all of the error processing below, the emitError() call MUST come
- // before the flush of the reader mgr, or it will fail because it tries
- // to find out the position in the XML source of the error.
- catch(const XMLErrs::Codes)
- {
- // This is a 'first fatal error' type exit, so reset and fall through
- fReaderMgr.reset();
- }
- catch(const XMLValid::Codes)
- {
- // This is a 'first fatal error' type exit, so reset and fall through
- fReaderMgr.reset();
- }
- catch(const XMLException& excToCatch)
- {
- // Emit the error and catch any user exception thrown from here. Make
- // sure in all cases we flush the reader manager.
- fInException = true;
- try
- {
- if (excToCatch.getErrorType() == XMLErrorReporter::ErrType_Warning)
- emitError
- (
- XMLErrs::XMLException_Warning
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- else if (excToCatch.getErrorType() >= XMLErrorReporter::ErrType_Fatal)
- emitError
- (
- XMLErrs::XMLException_Fatal
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- else
- emitError
- (
- XMLErrs::XMLException_Error
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- // Flush the reader manager and rethrow user's error
- fReaderMgr.reset();
- throw;
- }
- // If it returned, then reset the reader manager and fall through
- fReaderMgr.reset();
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- // Reset and rethrow
- fReaderMgr.reset();
- throw;
- }
- }
- bool WFXMLScanner::scanNext(XMLPScanToken& token)
- {
- // Make sure this token is still legal
- if (!isLegalToken(token))
- ThrowXML(RuntimeException, XMLExcepts::Scan_BadPScanToken);
- // Find the next token and remember the reader id
- unsigned int orgReader;
- XMLTokens curToken;
- bool retVal = true;
- try
- {
- while (true)
- {
- // We have to handle any end of entity exceptions that happen here.
- // We could be at the end of X nested entities, each of which will
- // generate an end of entity exception as we try to move forward.
- try
- {
- curToken = senseNextToken(orgReader);
- break;
- }
- catch(const EndOfEntityException& toCatch)
- {
- // Send an end of entity reference event
- if (fDocHandler)
- fDocHandler->endEntityReference(toCatch.getEntity());
- }
- }
- if (curToken == Token_CharData)
- {
- scanCharData(fCDataBuf);
- }
- else if (curToken == Token_EOF)
- {
- if (!fElemStack.isEmpty())
- {
- const ElemStack::StackElem* topElem = fElemStack.popTop();
- emitError
- (
- XMLErrs::EndedWithTagsOnStack
- , topElem->fThisElement->getFullName()
- );
- }
- retVal = false;
- }
- else
- {
- // Its some sort of markup
- bool gotData = true;
- switch(curToken)
- {
- case Token_CData :
- // Make sure we are within content
- if (fElemStack.isEmpty())
- emitError(XMLErrs::CDATAOutsideOfContent);
- scanCDSection();
- break;
- case Token_Comment :
- scanComment();
- break;
- case Token_EndTag :
- scanEndTag(gotData);
- break;
- case Token_PI :
- scanPI();
- break;
- case Token_StartTag :
- if (fDoNamespaces)
- scanStartTagNS(gotData);
- else
- scanStartTag(gotData);
- break;
- default :
- fReaderMgr.skipToChar(chOpenAngle);
- break;
- }
- if (orgReader != fReaderMgr.getCurrentReaderNum())
- emitError(XMLErrs::PartialMarkupInEntity);
- // If we hit the end, then do the miscellaneous part
- if (!gotData)
- {
- // That went ok, so scan for any miscellaneous stuff
- scanMiscellaneous();
- if (fDocHandler)
- fDocHandler->endDocument();
- }
- }
- }
- // NOTE:
- //
- // In all of the error processing below, the emitError() call MUST come
- // before the flush of the reader mgr, or it will fail because it tries
- // to find out the position in the XML source of the error.
- catch(const XMLErrs::Codes)
- {
- // This is a 'first failure' exception, so reset and return failure
- fReaderMgr.reset();
- return false;
- }
- catch(const XMLValid::Codes)
- {
- // This is a 'first fatal error' type exit, so reset and reuturn failure
- fReaderMgr.reset();
- return false;
- }
- catch(const XMLException& excToCatch)
- {
- // Emit the error and catch any user exception thrown from here. Make
- // sure in all cases we flush the reader manager.
- fInException = true;
- try
- {
- if (excToCatch.getErrorType() == XMLErrorReporter::ErrType_Warning)
- emitError
- (
- XMLErrs::XMLException_Warning
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- else if (excToCatch.getErrorType() >= XMLErrorReporter::ErrType_Fatal)
- emitError
- (
- XMLErrs::XMLException_Fatal
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- else
- emitError
- (
- XMLErrs::XMLException_Error
- , excToCatch.getType()
- , excToCatch.getMessage()
- );
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- // Reset and rethrow user error
- fReaderMgr.reset();
- throw;
- }
- // Reset and return failure
- fReaderMgr.reset();
- return false;
- }
- catch(const OutOfMemoryException&)
- {
- throw;
- }
- catch(...)
- {
- // Reset and rethrow original error
- fReaderMgr.reset();
- throw;
- }
- // If we hit the end, then flush the reader manager
- if (!retVal)
- fReaderMgr.reset();
- return retVal;
- }
- // ---------------------------------------------------------------------------
- // WFXMLScanner: Private helper methods.
- // ---------------------------------------------------------------------------
- // This method handles the common initialization, to avoid having to do
- // it redundantly in multiple constructors.
- void WFXMLScanner::commonInit()
- {
- fEntityTable = new (fMemoryManager) ValueHashTableOf<XMLCh>(11, fMemoryManager);
- fAttrNameHashList = new (fMemoryManager)ValueVectorOf<unsigned int>(16, fMemoryManager);
- fAttrNSList = new (fMemoryManager) ValueVectorOf<XMLAttr*>(8, fMemoryManager);
- fElements = new (fMemoryManager) RefVectorOf<XMLElementDecl>(32, true, fMemoryManager);
- fElementLookup = new (fMemoryManager) RefHashTableOf<XMLElementDecl>(109, false, fMemoryManager);
- // Add the default entity entries for the character refs that must always
- // be present.
- fEntityTable->put((void*) XMLUni::fgAmp, chAmpersand);
- fEntityTable->put((void*) XMLUni::fgLT, chOpenAngle);
- fEntityTable->put((void*) XMLUni::fgGT, chCloseAngle);
- fEntityTable->put((void*) XMLUni::fgQuot, chDoubleQuote);
- fEntityTable->put((void*) XMLUni::fgApos, chSingleQuote);
- }
- void WFXMLScanner::cleanUp()
- {
- delete fEntityTable;
- delete fAttrNameHashList;
- delete fAttrNSList;
- delete fElementLookup;
- delete fElements;
- }
- unsigned int
- WFXMLScanner::resolvePrefix(const XMLCh* const prefix
- , const ElemStack::MapModes mode)
- {
- // Watch for the special namespace prefixes. We always map these to
- // special URIs. 'xml' gets mapped to the official URI that its defined
- // to map to by the NS spec. xmlns gets mapped to a special place holder
- // URI that we define (so that it maps to something checkable.)
- if (XMLString::equals(prefix, XMLUni::fgXMLNSString))
- return fXMLNSNamespaceId;
- else if (XMLString::equals(prefix, XMLUni::fgXMLString))
- return fXMLNamespaceId;
- // Ask the element stack to search up itself for a mapping for the
- // passed prefix.
- bool unknown;
- unsigned int uriId = fElemStack.mapPrefixToURI(prefix, mode, unknown);
- // If it was unknown, then the URI was faked in but we have to issue an error
- if (unknown)
- emitError(XMLErrs::UnknownPrefix, prefix);
- return uriId;
- }
- // This method will reset the scanner data structures, and related plugged
- // in stuff, for a new scan session. We get the input source for the primary
- // XML entity, create the reader for it, and push it on the stack so that
- // upon successful return from here we are ready to go.
- void WFXMLScanner::scanReset(const InputSource& src)
- {
- // For all installed handlers, send reset events. This gives them
- // a chance to flush any cached data.
- if (fDocHandler)
- fDocHandler->resetDocument();
- if (fEntityHandler)
- fEntityHandler->resetEntities();
- if (fErrorReporter)
- fErrorReporter->resetErrors();
- // Reset the element stack, and give it the latest ids for the special
- // URIs it has to know about.
- fElemStack.reset
- (
- fEmptyNamespaceId
- , fUnknownNamespaceId
- , fXMLNamespaceId
- , fXMLNSNamespaceId
- );
- // Reset some status flags
- fInException = false;
- fStandalone = false;
- fErrorCount = 0;
- fHasNoDTD = true;
- fElementIndex = 0;
- // Reset elements lookup table
- fElementLookup->removeAll();
- // Handle the creation of the XML reader object for this input source.
- // This will provide us with transcoding and basic lexing services.
- XMLReader* newReader = fReaderMgr.createReader
- (
- src
- , true
- , XMLReader::RefFrom_NonLiteral
- , XMLReader::Type_General
- , XMLReader::Source_External
- , fCalculateSrcOfs
- );
- if (!newReader) {
- if (src.getIssueFatalErrorIfNotFound())
- ThrowXML1(RuntimeException, XMLExcepts::Scan_CouldNotOpenSource, src.getSystemId());
- else
- ThrowXML1(RuntimeException, XMLExcepts::Scan_CouldNotOpenSource_Warning, src.getSystemId());
- }
- // Push this read onto the reader manager
- fReaderMgr.pushReader(newReader, 0);
- // and reset security-related things if necessary:
- if(fSecurityManager != 0)
- {
- fEntityExpansionLimit = fSecurityManager->getEntityExpansionLimit();
- fEntityExpansionCount = 0;
- }
- }
- // This method is called between markup in content. It scans for character
- // data that is sent to the document handler. It watches for any markup
- // characters that would indicate that the character data has ended. It also
- // handles expansion of general and character entities.
- //
- // sendData() is a local static helper for this method which handles some
- // code that must be done in three different places here.
- void WFXMLScanner::sendCharData(XMLBuffer& toSend)
- {
- // If no data in the buffer, then nothing to do
- if (toSend.isEmpty())
- return;
- // Always assume its just char data if not validating
- if (fDocHandler)
- fDocHandler->docCharacters(toSend.getRawBuffer(), toSend.getLen(), false);
- // Reset buffer
- toSend.reset();
- }
- // ---------------------------------------------------------------------------
- // WFXMLScanner: Private scanning methods
- // ---------------------------------------------------------------------------
- // This method will kick off the scanning of the primary content of the
- // document, i.e. the elements.
- bool WFXMLScanner::scanContent(const bool extEntity)
- {
- // Go into a loop until we hit the end of the root element, or we fall
- // out because there is no root element.
- //
- // We have to do kind of a deeply nested double loop here in order to
- // avoid doing the setup/teardown of the exception handler on each
- // round. Doing it this way we only do it when an exception actually
- // occurs.
- bool gotData = true;
- bool inMarkup = false;
- while (gotData)
- {
- try
- {
- while (gotData)
- {
- // Sense what the next top level token is. According to what
- // this tells us, we will call something to handle that kind
- // of thing.
- unsigned int orgReader;
- const XMLTokens curToken = senseNextToken(orgReader);
- // Handle character data and end of file specially. Char data
- // is not markup so we don't want to handle it in the loop
- // below.
- if (curToken == Token_CharData)
- {
- // Scan the character data and call appropriate events. Let
- // him use our local character data buffer for efficiency.
- scanCharData(fCDataBuf);
- continue;
- }
- else if (curToken == Token_EOF)
- {
- // The element stack better be empty at this point or we
- // ended prematurely before all elements were closed.
- if (!fElemStack.isEmpty())
- {
- const ElemStack::StackElem* topElem = fElemStack.popTop();
- emitError
- (
- XMLErrs::EndedWithTagsOnStack
- , topElem->fThisElement->getFullName()
- );
- }
- // Its the end of file, so clear the got data flag
- gotData = false;
- continue;
- }
- // We are in some sort of markup now
- inMarkup = true;
- // According to the token we got, call the appropriate
- // scanning method.
- switch(curToken)
- {
- case Token_CData :
- // Make sure we are within content
- if (fElemStack.isEmpty())
- emitError(XMLErrs::CDATAOutsideOfContent);
- scanCDSection();
- break;
- case Token_Comment :
- scanComment();
- break;
- case Token_EndTag :
- scanEndTag(gotData);
- break;
- case Token_PI :
- scanPI();
- break;
- case Token_StartTag :
- if (fDoNamespaces)
- scanStartTagNS(gotData);
- else
- scanStartTag(gotData);
- break;
- default :
- fReaderMgr.skipToChar(chOpenAngle);
- break;
- }
- if (orgReader != fReaderMgr.getCurrentReaderNum())
- emitError(XMLErrs::PartialMarkupInEntity);
- // And we are back out of markup again
- inMarkup = false;
- }
- }
- catch(const EndOfEntityException& toCatch)
- {
- // If we were in some markup when this happened, then its a
- // partial markup error.
- if (inMarkup)
- emitError(XMLErrs::PartialMarkupInEntity);
- // Send an end of entity reference event
- if (fDocHandler)
- fDocHandler->endEntityReference(toCatch.getEntity());
- inMarkup = false;
- }
- }
- // It went ok, so return success
- return true;
- }
- void WFXMLScanner::scanEndTag(bool& gotData)
- {
- // Assume we will still have data until proven otherwise. It will only
- // ever be false if this is the end of the root element.
- gotData = true;
- // Check if the element stack is empty. If so, then this is an unbalanced
- // element (i.e. more ends than starts, perhaps because of bad text
- // causing one to be skipped.)
- if (fElemStack.isEmpty())
- {
- emitError(XMLErrs::MoreEndThanStartTags);
- fReaderMgr.skipPastChar(chCloseAngle);
- ThrowXML(RuntimeException, XMLExcepts::Scan_UnbalancedStartEnd);
- }
- // Pop the stack of the element we are supposed to be ending. Remember
- // that we don't own this. The stack just keeps them and reuses them.
- unsigned int uriId = (fDoNamespaces)
- ? fElemStack.getCurrentURI() : fEmptyNamespaceId;
- const ElemStack::StackElem* topElem = fElemStack.popTop();
- // See if it was the root element, to avoid multiple calls below
- const bool isRoot = fElemStack.isEmpty();
- // Make sure that its the end of the element that we expect
- if (!fReaderMgr.skippedString(topElem->fThisElement->getFullName()))
- {
- emitError
- (
- XMLErrs::ExpectedEndOfTagX
- , topElem->fThisElement->getFullName()
- );
- fReaderMgr.skipPastChar(chCloseAngle);
- return;
- }
- // Make sure we are back on the same reader as where we started
- if (topElem->fReaderNum != fReaderMgr.getCurrentReaderNum())
- emitError(XMLErrs::PartialTagMarkupError);
- // Skip optional whitespace
- fReaderMgr.skipPastSpaces();
- // Make sure we find the closing bracket
- if (!fReaderMgr.skippedChar(chCloseAngle))
- {
- emitError
- (
- XMLErrs::UnterminatedEndTag
- , topElem->fThisElement->getFullName()
- );
- }
- // If we have a doc handler, tell it about the end tag
- if (fDocHandler)
- {
- fDocHandler->endElement
- (
- *topElem->fThisElement
- , uriId
- , isRoot
- , topElem->fThisElement->getElementName()->getPrefix()
- );
- }
- // If this was the root, then done with content
- gotData = !isRoot;
- }
- void WFXMLScanner::scanDocTypeDecl()
- {
- // Just skips over it
- // REVISIT: Should we issue a warning
- static const XMLCh doctypeIE[] =
- {
- chOpenSquare, chCloseAngle, chNull
- };
- XMLCh nextCh = fReaderMgr.skipUntilIn(doctypeIE);
- if (nextCh == chOpenSquare)
- fReaderMgr.skipPastChar(chCloseSquare);
- fReaderMgr.skipPastChar(chCloseAngle);
- }
- bool WFXMLScanner::scanStartTag(bool& gotData)
- {
- // Assume we will still have data until proven otherwise. It will only
- // ever be false if this is the root and its empty.
- gotData = true;
- // Get the QName. In this case, we are not doing namespaces, so we just
- // use it as is and don't have to break it into parts.
- if (!fReaderMgr.getName(fQNameBuf))
- {
- emitError(XMLErrs::ExpectedElementName);
- fReaderMgr.skipToChar(chOpenAngle);
- return false;
- }
- // Assume it won't be an empty tag
- bool isEmpty = false;
- // See if its the root element
- const bool isRoot = fElemStack.isEmpty();
- // Lets try to look up the element
- const XMLCh* qnameRawBuf = fQNameBuf.getRawBuffer();
- XMLElementDecl* elemDecl = fElementLookup->get(qnameRawBuf);
- if (!elemDecl) {
- if (fElementIndex < fElements->size()) {
- elemDecl = fElements->elementAt(fElementIndex);
- }
- else {
- elemDecl = new (fGrammarPoolMemoryManager) DTDElementDecl
- (
- fGrammarPoolMemoryManager
- );
- fElements->addElement(elemDecl);
- }
- elemDecl->setElementName(XMLUni::fgZeroLenString, qnameRawBuf, fEmptyNamespaceId);
- fElementLookup->put((void*)elemDecl->getFullName(), elemDecl);
- fElementIndex++;
- }
- // Expand the element stack and add the new element
- fElemStack.addLevel(elemDecl, fReaderMgr.getCurrentReaderNum());
- // Skip any whitespace after the name
- fReaderMgr.skipPastSpaces();
- // We loop until we either see a /> or >, handling attribute/value
- // pairs until we get there.
- unsigned int attCount = 0;
- unsigned int curAttListSize = fAttrList->size();
- while (true)
- {
- // And get the next non-space character
- XMLCh nextCh = fReaderMgr.peekNextChar();
- // If the next character is not a slash or closed angle bracket,
- // then it must be whitespace, since whitespace is required
- // between the end of the last attribute and the name of the next
- // one.
- if (attCount)
- {
- if ((nextCh != chForwardSlash) && (nextCh != chCloseAngle))
- {
- if (fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
- {
- // Ok, skip by them and peek another char
- fReaderMgr.skipPastSpaces();
- nextCh = fReaderMgr.peekNextChar();
- }
- else
- {
- // Emit the error but keep on going
- emitError(XMLErrs::ExpectedWhitespace);
- }
- }
- }
- // Ok, here we first check for any of the special case characters.
- // If its not one, then we do the normal case processing, which
- // assumes that we've hit an attribute value, Otherwise, we do all
- // the special case checks.
- if (!fReaderMgr.getCurrentReader()->isSpecialStartTagChar(nextCh))
- {
- // Assume its going to be an attribute, so get a name from
- // the input.
- if (!fReaderMgr.getName(fAttNameBuf))
- {
- emitError(XMLErrs::ExpectedAttrName);
- fReaderMgr.skipPastChar(chCloseAngle);
- return false;
- }
- // And next must be an equal sign
- if (!scanEq())
- {
- static const XMLCh tmpList[] =
- {
- chSingleQuote, chDoubleQuote, chCloseAngle
- , chOpenAngle, chForwardSlash, chNull
- };
- emitError(XMLErrs::ExpectedEqSign);
- // Try to sync back up by skipping forward until we either
- // hit something meaningful.
- const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
- if ((chFound == chCloseAngle) || (chFound == chForwardSlash))
- {
- // Jump back to top for normal processing of these
- continue;
- }
- else if ((chFound == chSingleQuote)
- || (chFound == chDoubleQuote)
- || fReaderMgr.getCurrentReader()->isWhitespace(chFound))
- {
- // Just fall through assuming that the value is to follow
- }
- else if (chFound == chOpenAngle)
- {
- // Assume a malformed tag and that new one is starting
- emitError(XMLErrs::UnterminatedStartTag, qnameRawBuf);
- return false;
- }
- else
- {
- // Something went really wrong
- return false;
- }
- }
- // See if this attribute is declared more than one for this element.
- const XMLCh* attNameRawBuf = fAttNameBuf.getRawBuffer();
- unsigned int attNameHash = XMLString::hash(attNameRawBuf, 109);
- if (attCount) {
- for (unsigned int k=0; k < attCount; k++) {
- if (fAttrNameHashList->elementAt(k) == attNameHash) {
- if (
- XMLString::equals
- (
- fAttrList->elementAt(k)->getName()
- , attNameRawBuf
- )
- )
- {
- emitError
- (
- XMLErrs::AttrAlreadyUsedInSTag
- , attNameRawBuf
- , qnameRawBuf
- );
- break;
- }
- }
- }
- }
- // Skip any whitespace before the value and then scan the att
- // value. This will come back normalized with entity refs and
- // char refs expanded.
- fReaderMgr.skipPastSpaces();
- if (!scanAttValue(attNameRawBuf, fAttValueBuf))
- {
- static const XMLCh tmpList[] =
- {
- chCloseAngle, chOpenAngle, chForwardSlash, chNull
- };
- emitError(XMLErrs::ExpectedAttrValue);
- // It failed, so lets try to get synced back up. We skip
- // forward until we find some whitespace or one of the
- // chars in our list.
- const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
- if ((chFound == chCloseAngle)
- || (chFound == chForwardSlash)
- || fReaderMgr.getCurrentReader()->isWhitespace(chFound))
- {
- // Just fall through and process this attribute, though
- // the value will be "".
- }
- else if (chFound == chOpenAngle)
- {
- // Assume a malformed tag and that new one is starting
- emitError(XMLErrs::UnterminatedStartTag, qnameRawBuf);
- return false;
- }
- else
- {
- // Something went really wrong
- return false;
- }
- }
- // Add this attribute to the attribute list that we use to
- // pass them to the handler. We reuse its existing elements
- // but expand it as required.
- XMLAttr* curAtt;
- if (attCount >= curAttListSize)
- {
- curAtt = new (fMemoryManager) XMLAttr
- (
- -1
- , attNameRawBuf
- , XMLUni::fgZeroLenString
- , fAttValueBuf.getRawBuffer()
- , XMLAttDef::CData
- , true
- , fMemoryManager
- );
- fAttrList->addElement(curAtt);
- fAttrNameHashList->addElement(attNameHash);
- }
- else
- {
- curAtt = fAttrList->elementAt(attCount);
- curAtt->set
- (
- -1
- , attNameRawBuf
- , XMLUni::fgZeroLenString
- , fAttValueBuf.getRawBuffer()
- );
- curAtt->setSpecified(true);
- fAttrNameHashList->setElementAt(attNameHash, attCount);
- }
- attCount++;
- // And jump back to the top of the loop
- continue;
- }
- // It was some special case character so do all of the checks and
- // deal with it.
- if (!nextCh)
- ThrowXML(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF);
- if (nextCh == chForwardSlash)
- {
- fReaderMgr.getNextChar();
- isEmpty = true;
- if (!fReaderMgr.skippedChar(chCloseAngle))
- emitError(XMLErrs::UnterminatedStartTag, qnameRawBuf);
- break;
- }
- else if (nextCh == chCloseAngle)
- {
- fReaderMgr.getNextChar();
- break;
- }
- else if (nextCh == chOpenAngle)
- {
- // Check for this one specially, since its going to be common
- // and it is kind of auto-recovering since we've already hit the
- // next open bracket, which is what we would have seeked to (and
- // skipped this whole tag.)
- emitError(XMLErrs::UnterminatedStartTag, elemDecl->getFullName());
- break;
- }
- else if ((nextCh == chSingleQuote) || (nextCh == chDoubleQuote))
- {
- // Check for this one specially, which is probably a missing
- // attribute name, e.g. ="value". Just issue expected name
- // error and eat the quoted string, then jump back to the
- // top again.
- emitError(XMLErrs::ExpectedAttrName);
- fReaderMgr.getNextChar();
- fReaderMgr.skipQuotedString(nextCh);
- fReaderMgr.skipPastSpaces();
- continue;
- }
- }
- // If empty, validate content right now if we are validating and then
- // pop the element stack top. Else, we have to update the current stack
- // top's namespace mapping elements.
- if (isEmpty)
- {
- // Pop the element stack back off since it'll never be used now
- fElemStack.popTop();
- // If the elem stack is empty, then it was an empty root
- if (isRoot)
- gotData = false;
- }
- // If we have a document handler, then tell it about this start tag. We
- // don't have any URI id to send along, so send fEmptyNamespaceId. We also do not send
- // any prefix since its just one big name if we are not doing namespaces.
- if (fDocHandler)
- {
- fDocHandler->startElement
- (
- *elemDecl
- , fEmptyNamespaceId
- , 0
- , *fAttrList
- , attCount
- , isEmpty
- , isRoot
- );
- }
- return true;
- }
- // This method is called to scan a start tag when we are processing
- // namespaces. There are two different versions of this method, one for
- // namespace aware processing an done for non-namespace aware processing.
- //
- // This method is called after we've scanned the < of a start tag. So we
- // have to get the element name, then scan the attributes, after which
- // we are either going to see >, />, or attributes followed by one of those
- // sequences.
- bool WFXMLScanner::scanStartTagNS(bool& gotData)
- {
- // Assume we will still have data until proven otherwise. It will only
- // ever be false if this is the root and its empty.
- gotData = true;
- // The current position is after the open bracket, so we need to read in
- // in the element name.
- if (!fReaderMgr.getName(fQNameBuf))
- {
- emitError(XMLErrs::ExpectedElementName);
- fReaderMgr.skipToChar(chOpenAngle);
- return false;
- }
- // See if its the root element
- const bool isRoot = fElemStack.isEmpty();
- // Assume it won't be an empty tag
- bool isEmpty = false;
- // Skip any whitespace after the name
- fReaderMgr.skipPastSpaces();
- // Lets try to look up the element
- const XMLCh* qnameRawBuf = fQNameBuf.getRawBuffer();
- XMLElementDecl* elemDecl = fElementLookup->get(qnameRawBuf);
- if (!elemDecl) {
- if (!XMLString::compareNString(qnameRawBuf, XMLUni::fgXMLNSColonString, 6))
- emitError(XMLErrs::NoXMLNSAsElementPrefix, qnameRawBuf);
- if (fElementIndex < fElements->size()) {
- elemDecl = fElements->elementAt(fElementIndex);
- }
- else {
- elemDecl = new (fGrammarPoolMemoryManager) DTDElementDecl
- (
- fGrammarPoolMemoryManager
- );
- fElements->addElement(elemDecl);
- }
- elemDecl->setElementName(qnameRawBuf, fEmptyNamespaceId);
- fElementLookup->put((void*)elemDecl->getFullName(), elemDecl);
- fElementIndex++;
- }
- // Expand the element stack and add the new element
- fElemStack.addLevel(elemDecl, fReaderMgr.getCurrentReaderNum());
- // reset NS attribute list
- fAttrNSList->removeAllElements();
- // We loop until we either see a /> or >, handling attribute/value
- // pairs until we get there.
- unsigned int attCount = 0;
- unsigned int curAttListSize = fAttrList->size();
- while (true)
- {
- // And get the next non-space character
- XMLCh nextCh = fReaderMgr.peekNextChar();
- // If the next character is not a slash or closed angle bracket,
- // then it must be whitespace, since whitespace is required
- // between the end of the last attribute and the name of the next
- // one.
- if (attCount)
- {
- if ((nextCh != chForwardSlash) && (nextCh != chCloseAngle))
- {
- if (fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
- {
- // Ok, skip by them and peek another char
- fReaderMgr.skipPastSpaces();
- nextCh = fReaderMgr.peekNextChar();
- }
- else
- {
- // Emit the error but keep on going
- emitError(XMLErrs::ExpectedWhitespace);
- }
- }
- }
- // Ok, here we first check for any of the special case characters.
- // If its not one, then we do the normal case processing, which
- // assumes that we've hit an attribute value, Otherwise, we do all
- // the special case checks.
- if (!fReaderMgr.getCurrentReader()->isSpecialStartTagChar(nextCh))
- {
- // Assume its going to be an attribute, so get a name from
- // the input.
- if (!fReaderMgr.getName(fAttNameBuf))
- {
- emitError(XMLErrs::ExpectedAttrName);
- fReaderMgr.skipPastChar(chCloseAngle);
- return false;
- }
- // And next must be an equal sign
- if (!scanEq())
- {
- static const XMLCh tmpList[] =
- {
- chSingleQuote, chDoubleQuote, chCloseAngle
- , chOpenAngle, chForwardSlash, chNull
- };
- emitError(XMLErrs::ExpectedEqSign);
- // Try to sync back up by skipping forward until we either
- // hit something meaningful.
- const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
- if ((chFound == chCloseAngle) || (chFound == chForwardSlash))
- {
- // Jump back to top for normal processing of these
- continue;
- }
- else if ((chFound == chSingleQuote)
- || (chFound == chDoubleQuote)
- || fReaderMgr.getCurrentReader()->isWhitespace(chFound))
- {
- // Just fall through assuming that the value is to follow
- }
- else if (chFound == chOpenAngle)
- {
- // Assume a malformed tag and that new one is starting
- emitError(XMLErrs::UnterminatedStartTag, qnameRawBuf);
- return false;
- }
- else
- {
- // Something went really wrong
- return false;
- }
- }
- // See if this attribute is declared more than one for this element.
- const XMLCh* attNameRawBuf = fAttNameBuf.getRawBuffer();
- unsigned int attNameHash = XMLString::hash(attNameRawBuf, 109);
- if (attCount) {
- for (unsigned int k=0; k < attCount; k++) {
- if (fAttrNameHashList->elementAt(k) == attNameHash) {
- if (XMLString::equals(
- fAttrList->elementAt(k)->getQName()
- , attNameRawBuf))
- {
- emitError
- (
- XMLErrs::AttrAlreadyUsedInSTag
- , attNameRawBuf
- , qnameRawBuf
- );
- break;
- }
- }
- }
- }
- // Skip any whitespace before the value and then scan the att
- // value. This will come back normalized with entity refs and
- // char refs expanded.
- fReaderMgr.skipPastSpaces();
- if (!scanAttValue(attNameRawBuf, fAttValueBuf))
- {
- static const XMLCh tmpList[] =
- {
- chCloseAngle, chOpenAngle, chForwardSlash, chNull
- };
- emitError(XMLErrs::ExpectedAttrValue);
- // It failed, so lets try to get synced back up. We skip
- // forward until we find some whitespace or one of the
- // chars in our list.
- const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
- if ((chFound == chCloseAngle)
- || (chFound == chForwardSlash)
- || fReaderMgr.getCurrentReader()->isWhitespace(chFound))
- {
- // Just fall through and process this attribute, though
- // the value will be "".
- }
- else if (chFound == chOpenAngle)
- {
- // Assume a malformed tag and that new one is starting
- emitError(XMLErrs::UnterminatedStartTag, qnameRawBuf);
- return false;
- }
- else
- {
- // Something went really wrong
- return false;
- }
- }
- // Add this attribute to the attribute list that we use to
- // pass them to the handler. We reuse its existing elements
- // but expand it as required.
- const XMLCh* attValueRawBuf = fAttValueBuf.getRawBuffer();
- XMLAttr* curAtt = 0;
- if (attCount >= curAttListSize)
- {
- curAtt = new (fMemoryManager) XMLAttr
- (
- fEmptyNamespaceId
- , attNameRawBuf
- , attValueRawBuf
- , XMLAttDef::CData
- , true
- , fMemoryManager
- );
- fAttrList->addElement(curAtt);
- fAttrNameHashList->addElement(attNameHash);
- }
- else
- {
- curAtt = fAttrList->elementAt(attCount);
- curAtt->set
- (
- fEmptyNamespaceId
- , attNameRawBuf
- , attValueRawBuf
- );
- curAtt->setSpecified(true);
- fAttrNameHashList->setElementAt(attNameHash, attCount);
- }
- // Make sure that the name is basically well formed for namespace
- // enabled rules. It either has no colons, or it has one which
- // is neither the first or last char.
- const int colonFirst = XMLString::indexOf(attNameRawBuf, chColon);
- if (colonFirst != -1)
- {
- const int colonLast = XMLString::lastIndexOf(attNameRawBuf, chColon);
- if (colonFirst != colonLast)
- {
- emitError(XMLErrs::TooManyColonsInName);
- continue;
- }
- else if ((colonFirst == 0)
- || (colonLast == (int)fAttNameBuf.getLen() - 1))
- {
- emitError(XMLErrs::InvalidColonPos);
- continue;
- }
- }
- // Map prefix to namespace
- const XMLCh* attPrefix = curAtt->getPrefix();
- const XMLCh* attLocalName = curAtt->getName();
- const XMLCh* namespaceURI = fAttValueBuf.getRawBuffer();
- if (attPrefix && *attPrefix) {
- if (XMLString::equals(attPrefix, XMLUni::fgXMLString)) {
- curAtt->setURIId(fXMLNamespaceId);
- }
- else if (XMLString::equals(attPrefix, XMLUni::fgXMLNSString)) {
- if (XMLString::equals(attLocalName, XMLUni::fgXMLNSString))
- emitError(XMLErrs::NoUseOfxmlnsAsPrefix);
- else if (XMLString::equals(attLocalName, XMLUni::fgXMLString)) {
- if (!XMLString::equals(namespaceURI, XMLUni::fgXMLURIName))
- emitError(XMLErrs::PrefixXMLNotMatchXMLURI);
- }
- if (!namespaceURI)
- emitError(XMLErrs::NoEmptyStrNamespace, attNameRawBuf);
- else if(!*namespaceURI && fXMLVersion == XMLReader::XMLV1_0)
- emitError(XMLErrs::NoEmptyStrNamespace, attNameRawBuf);
- fElemStack.addPrefix
- (
- attLocalName
- , fURIStringPool->addOrFind(namespaceURI)
- );
- curAtt->setURIId(fXMLNSNamespaceId);
- }
- else {
- fAttrNSList->addElement(curAtt);
- }
- }
- else {
- if (XMLString::equals(XMLUni::fgXMLNSString, attLocalName)) {
- if (XMLString::equals(namespaceURI, XMLUni::fgXMLNSURIName))
- emitError(XMLErrs::NoUseOfxmlnsURI);
- else if (XMLString::equals(namespaceURI, XMLUni::fgXML…
Large files files are truncated, but you can click here to view the full file