/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999-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
* 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) 2002, International
* Business Machines, Inc., http://www.apache.org. For more
* information on the Apache Software Foundation, please see
*/
/**
* The scanner acts as the source for the document
* information which is communicated to the document handler.
*
* This class scans an XML document, checks if document has a DTD, and if
* DTD is not found the scanner will remove the DTD Validator from the pipeline and perform
* namespace binding.
*
* Note: This scanner should only be used when the namespace processing is on!
*
* <p>
* This component requires the following features and properties from the
* component manager that uses it:
* <ul>
* <li>http://xml.org/sax/features/namespaces {true} -- if the value of this
* feature is set to false this scanner must not be used.</li>
* <li>http://xml.org/sax/features/validation</li>
* </ul>
*
* @xerces.internal
*
* @author Elena Litani, IBM
* @author Michael Glavassevich, IBM
* @author Sunitha Reddy, Sun Microsystems
*/
/**
* If is true, the dtd validator is no longer in the pipeline
* and the scanner should bind namespaces
*/
protected boolean fBindNamespaces;
/**
* If validating parser, make sure we report an error in the
* scanner if DTD grammar is missing.
*/
protected boolean fPerformValidation;
// private data
//
/** DTD validator */
/**
* Saw spaces after element name or between attributes.
*
* This is reserved for the case where scanning of a start element spans
* several methods, as is the case when scanning the start of a root element
* where a DTD external subset may be read after scanning the element name.
*/
private boolean fSawSpace;
/**
* The scanner is responsible for removing DTD validator
* from the pipeline if it is not needed.
*
* @param validator the DTD validator from the pipeline
*/
}
/**
* Scans a start element. This method will handle the binding of
* namespace information and notifying the handler of the start
* of the element.
* <p>
* <pre>
* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
* [40] STag ::= '<' Name (S Attribute)* S? '>'
* </pre>
* <p>
* <strong>Note:</strong> This method assumes that the leading
* '<' character has been consumed.
* <p>
* <strong>Note:</strong> This method uses the fElementQName and
* fAttributes variables. The contents of these variables will be
* destroyed. The caller should copy important information out of
* these variables before calling this method.
*
* @return True if element is empty. (i.e. It matches
* production [44].
*/
// Note: namespace processing is on by default
// REVISIT - [Q] Why do we need this local variable? -- mrglavas
if (fBindNamespaces) {
if (fScannerState == SCANNER_STATE_ROOT_ELEMENT) {
if (fPerformValidation) {
"MSG_GRAMMAR_NOT_FOUND",
if (fDoctypeName == null
"RootElementTypeMustMatchDoctypedecl",
}
}
}
}
// push element stack
// attributes
boolean empty = false;
do {
// spaces
// end tag?
int c = fEntityScanner.peekChar();
if (c == '>') {
break;
} else if (c == '/') {
"ElementUnterminated",
}
empty = true;
break;
} else if (!isValidNameStartChar(c) || !sawSpace) {
// Second chance. Check if this character is a high
// surrogate of a valid name start character.
if (!isValidNameStartHighSurrogate(c) || !sawSpace) {
"ElementUnterminated",
}
}
// attributes
"ElementAttributeLimit",
}
} while (true);
if (fBindNamespaces) {
// REVISIT: is it required? forbit xmlns prefix for element
"ElementXMLNSPrefix",
}
// bind the element
// assign uri to the element
// make sure that object in the element stack is updated as well
// making sure that the object in the element stack is updated too.
}
"ElementPrefixUnbound",
new Object[] {
}
// bind attributes (xmlns are already bound bellow)
for (int i = 0; i < length; i++) {
// REVISIT: try removing the first "if" and see if it is faster.
//
continue;
}
"AttributePrefixUnbound",
new Object[] {
aprefix },
}
}
}
if (length > 1) {
"AttributeNSNotUnique",
new Object[] {
} else {
"AttributeNotUnique",
new Object[] {
}
}
}
}
// call handler
if (empty) {
//decrease the markup depth..
fMarkupDepth--;
// check that this element was opened in the same entity
"ElementEntityMismatch",
}
/*if (fBindNamespaces) {
fNamespaceContext.popContext();
}*/
fScanEndElement = true;
//pop the element off the stack..
} else {
if(dtdGrammarUtil != null)
if (fDocumentHandler != null)
}
return empty;
} // scanStartElement():boolean
/**
* Scans the name of an element in a start or empty tag.
*
* @see #scanStartElement()
*/
protected void scanStartElementName ()
throws IOException, XNIException {
// Note: namespace processing is on by default
// Must skip spaces here because the DTD scanner
// would consume them at the end of the external subset.
} // scanStartElementName()
/**
* Scans the remainder of a start or empty tag after the element name.
*
* @see #scanStartElement
* @return True if element is empty.
*/
protected boolean scanStartElementAfterName()
throws IOException, XNIException {
// REVISIT - [Q] Why do we need this local variable? -- mrglavas
if (fBindNamespaces) {
if (fScannerState == SCANNER_STATE_ROOT_ELEMENT) {
if (fPerformValidation) {
"MSG_GRAMMAR_NOT_FOUND",
if (fDoctypeName == null
"RootElementTypeMustMatchDoctypedecl",
}
}
}
}
// push element stack
// attributes
boolean empty = false;
do {
// end tag?
int c = fEntityScanner.peekChar();
if (c == '>') {
break;
} else if (c == '/') {
"ElementUnterminated",
}
empty = true;
break;
} else if (!isValidNameStartChar(c) || !fSawSpace) {
// Second chance. Check if this character is a high
// surrogate of a valid name start character.
if (!isValidNameStartHighSurrogate(c) || !fSawSpace) {
"ElementUnterminated",
}
}
// attributes
// spaces
} while (true);
if (fBindNamespaces) {
// REVISIT: is it required? forbit xmlns prefix for element
"ElementXMLNSPrefix",
}
// bind the element
// assign uri to the element
// make sure that object in the element stack is updated as well
// making sure that the object in the element stack is updated too.
}
"ElementPrefixUnbound",
new Object[] {
}
// bind attributes (xmlns are already bound bellow)
for (int i = 0; i < length; i++) {
// REVISIT: try removing the first "if" and see if it is faster.
//
continue;
}
"AttributePrefixUnbound",
new Object[] {
aprefix },
}
}
}
if (length > 1) {
"AttributeNSNotUnique",
new Object[] {
} else {
"AttributeNotUnique",
new Object[] {
}
}
}
}
// call handler
if (fDocumentHandler != null) {
if (empty) {
//decrease the markup depth..
fMarkupDepth--;
// check that this element was opened in the same entity
"ElementEntityMismatch",
}
if (fBindNamespaces) {
}
//pop the element off the stack..
} else {
}
}
return empty;
} // scanStartElementAfterName()
/**
* Scans an attribute.
* <p>
* <pre>
* [41] Attribute ::= Name Eq AttValue
* </pre>
* <p>
* <strong>Note:</strong> This method assumes that the next
* character on the stream is the first character of the attribute
* name.
* <p>
* <strong>Note:</strong> This method uses the fAttributeQName and
* fQName variables. The contents of these variables will be
* destroyed.
*
* @param attributes The attributes list for the scanned attribute.
*/
throws IOException, XNIException {
// name
// equals
"EqRequiredInAttribute",
new Object[] {
}
// content
int attrIndex;
if (fBindNamespaces) {
null);
} else {
null);
// WFC: Unique Att Spec
"AttributeNotUnique",
new Object[] {
}
}
//REVISIT: one more case needs to be included: external PE and standalone is no
// REVISIT: it seems that this function should not take attributes, and length
this.fTempString,
isVC,
// record namespace declarations if any.
if (fBindNamespaces) {
// when it's of form xmlns="..." or xmlns:prefix="...",
// it's a namespace declaration. but prefix:xmlns="..." isn't.
// get the internalized value of this attribute
// 1. "xmlns" can't be bound to any namespace
"CantBindXMLNS",
new Object[] { fAttributeQName },
}
// 2. the namespace for "xmlns" can't be bound to any prefix
"CantBindXMLNS",
new Object[] { fAttributeQName },
}
// 3. "xml" can't be bound to any other namespace than it's own
"CantBindXML",
new Object[] { fAttributeQName },
}
}
// 4. the namespace for "xml" can't be bound to any other prefix
else {
"CantBindXML",
new Object[] { fAttributeQName },
}
}
prefix =
// Declare prefix in context. Removing the association between a prefix and a
// namespace name is permitted in XML 1.1, so if the uri value is the empty string,
// the prefix is being unbound. -- mrglavas
// bind namespace attribute to a namespace
} else {
// attempt to bind attribute
}
}
}
} // scanAttribute(XMLAttributes)
/**
* Scans an end element.
* <p>
* <pre>
* [42] ETag ::= '</' Name S? '>'
* </pre>
* <p>
* <strong>Note:</strong> This method uses the fElementQName variable.
* The contents of this variable will be destroyed. The caller should
* copy the needed information out of this variable before calling
* this method.
*
* @return The element depth.
*/
// pop context
// Take advantage of the fact that next string _should_ be "fElementQName.rawName",
//In scanners most of the time is consumed on checks done for XML characters, we can
// optimize on it and avoid the checks done for endElement,
//we will also avoid symbol table lookup - neeraj.bajaj@sun.com
// this should work both for namespace processing true or false...
//REVISIT: if the string is not the same as expected.. we need to do better error handling..
//We can skip this for now... In any case if the string doesn't match -- document is not well formed.
"ETagRequired",
}
// end
"ETagUnterminated",
}
fMarkupDepth--;
//we have increased the depth for two markup "<" characters
fMarkupDepth--;
// check that this element was opened in the same entity
"ElementEntityMismatch",
}
// call handler
if (fDocumentHandler != null) {
/*if (fBindNamespaces) {
fNamespaceContext.popContext();
}*/
}
if(dtdGrammarUtil != null)
return fMarkupDepth;
} // scanEndElement():int
throws XMLConfigurationException {
super.reset(componentManager);
fPerformValidation = false;
fBindNamespaces = false;
}
/** Creates a content Driver. */
return new NS11ContentDriver();
} // createContentDriver():Driver
/** return the next state on the input
*
* @return int
*/
//since namespace context should still be valid when the parser is at the end element state therefore
//we pop the context only when next() has been called after the end element state was encountered. - nb.
fScannerLastState = -1;
}
return fScannerLastState = super.next();
}
/**
* Driver to handle content scanning.
*/
/**
* Scan for root element hook. This method is a hook for
* subclasses to add code that handles scanning for the root
* element. This method will also attempt to remove DTD validator
* from the pipeline, if there is no DTD grammar. If DTD validator
* is no longer in the pipeline bind namespaces in the scanner.
*
*
* @return True if the caller should stop and return true which
* allows the scanner to switch to a new scanning
* Driver. A return value of false indicates that
* the content Driver should continue as normal.
*/
protected boolean scanRootElementHook()
throws IOException, XNIException {
if (scanStartElementAfterName()) {
return true;
}
}
else {
if (scanStartElement()) {
return true;
}
}
return false;
} // scanRootElementHook():boolean
/**
* Re-configures pipeline by removing the DTD validator
* if no DTD grammar exists. If no validator exists in the
* pipeline or there is no DTD grammar, namespace binding
* is performed by the scanner in the enclosing class.
*/
private void reconfigurePipeline() {
if (fDTDValidator == null) {
fBindNamespaces = true;
}
else if (!fDTDValidator.hasGrammar()) {
fBindNamespaces = true;
// re-configure pipeline
}
} // reconfigurePipeline()
}
}