| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999,2000 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.apache.org. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package org.apache.xerces.framework; |
| |
| import org.apache.xerces.readers.XMLEntityHandler; |
| import org.apache.xerces.readers.DefaultEntityHandler; |
| import org.apache.xerces.utils.QName; |
| import org.apache.xerces.utils.StringPool; |
| import org.apache.xerces.utils.XMLCharacterProperties; |
| import org.apache.xerces.utils.XMLMessages; |
| import org.apache.xerces.validators.common.Grammar; |
| import org.apache.xerces.validators.common.GrammarResolver; |
| import org.apache.xerces.validators.common.XMLAttributeDecl; |
| import org.apache.xerces.validators.common.XMLElementDecl; |
| import org.apache.xerces.validators.dtd.DTDGrammar; |
| |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXParseException; |
| |
| import java.util.StringTokenizer; |
| /** |
| * Default implementation of an XML DTD scanner. |
| * <p> |
| * Clients who wish to scan a DTD should implement |
| * XMLDTDScanner.EventHandler to provide the desired behavior |
| * when various DTD components are encountered. |
| * <p> |
| * To process the DTD, the client application should follow the |
| * following sequence: |
| * <ol> |
| * <li>call scanDocTypeDecl() to scan the DOCTYPE declaration |
| * <li>call getReadingExternalEntity() to determine if scanDocTypeDecl found an |
| * external subset |
| * <li>if scanning an external subset, call scanDecls(true) to process the external subset |
| * </ol> |
| * |
| * @see XMLDTDScanner.EventHandler |
| * @version $Id$ |
| */ |
| public final class XMLDTDScanner { |
| // |
| // Constants |
| // |
| // |
| // [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") |
| // |
| private static final char[] version_string = { 'v','e','r','s','i','o','n' }; |
| // |
| // [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' |
| // |
| private static final char[] element_string = { 'E','L','E','M','E','N','T' }; |
| // |
| // [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children |
| // |
| private static final char[] empty_string = { 'E','M','P','T','Y' }; |
| private static final char[] any_string = { 'A','N','Y' }; |
| // |
| // [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
| // | '(' S? '#PCDATA' S? ')' |
| // |
| private static final char[] pcdata_string = { '#','P','C','D','A','T','A' }; |
| // |
| // [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' |
| // |
| private static final char[] attlist_string = { 'A','T','T','L','I','S','T' }; |
| // |
| // [55] StringType ::= 'CDATA' |
| // |
| private static final char[] cdata_string = { 'C','D','A','T','A' }; |
| // |
| // [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' |
| // | 'NMTOKEN' | 'NMTOKENS' |
| // |
| // Note: We search for common substrings always trying to move forward |
| // |
| // 'ID' - Common prefix of ID, IDREF and IDREFS |
| // 'REF' - Common substring of IDREF and IDREFS after matching ID prefix |
| // 'ENTIT' - Common prefix of ENTITY and ENTITIES |
| // 'IES' - Suffix of ENTITIES |
| // 'NMTOKEN' - Common prefix of NMTOKEN and NMTOKENS |
| // |
| private static final char[] id_string = { 'I','D' }; |
| private static final char[] ref_string = { 'R','E','F' }; |
| private static final char[] entit_string = { 'E','N','T','I','T' }; |
| private static final char[] ies_string = { 'I','E','S' }; |
| private static final char[] nmtoken_string = { 'N','M','T','O','K','E','N' }; |
| // |
| // [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' |
| // [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' |
| // |
| private static final char[] notation_string = { 'N','O','T','A','T','I','O','N' }; |
| // |
| // [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) |
| // |
| private static final char[] required_string = { '#','R','E','Q','U','I','R','E','D' }; |
| private static final char[] implied_string = { '#','I','M','P','L','I','E','D' }; |
| private static final char[] fixed_string = { '#','F','I','X','E','D' }; |
| // |
| // [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' |
| // |
| private static final char[] include_string = { 'I','N','C','L','U','D','E' }; |
| // |
| // [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>' |
| // |
| private static final char[] ignore_string = { 'I','G','N','O','R','E' }; |
| // |
| // [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' |
| // [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' |
| // |
| private static final char[] entity_string = { 'E','N','T','I','T','Y' }; |
| // |
| // [75] ExternalID ::= 'SYSTEM' S SystemLiteral |
| // | 'PUBLIC' S PubidLiteral S SystemLiteral |
| // [83] PublicID ::= 'PUBLIC' S PubidLiteral |
| // |
| private static final char[] system_string = { 'S','Y','S','T','E','M' }; |
| private static final char[] public_string = { 'P','U','B','L','I','C' }; |
| // |
| // [76] NDataDecl ::= S 'NDATA' S Name |
| // |
| private static final char[] ndata_string = { 'N','D','A','T','A' }; |
| // |
| // [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" ) |
| // |
| private static final char[] encoding_string = { 'e','n','c','o','d','i','n','g' }; |
| // |
| // Instance Variables |
| // |
| private DTDGrammar fDTDGrammar = null; |
| private GrammarResolver fGrammarResolver = null; |
| private boolean fNamespacesEnabled = false; |
| private boolean fValidationEnabled = false; |
| private XMLElementDecl fTempElementDecl = new XMLElementDecl(); |
| private XMLAttributeDecl fTempAttributeDecl = new XMLAttributeDecl(); |
| private QName fElementQName = new QName(); |
| private QName fAttributeQName = new QName(); |
| private QName fElementRefQName = new QName(); |
| private EventHandler fEventHandler = null; |
| private XMLDocumentHandler.DTDHandler fDTDHandler = null; |
| private StringPool fStringPool = null; |
| private XMLErrorReporter fErrorReporter = null; |
| private XMLEntityHandler fEntityHandler = null; |
| private XMLEntityHandler.EntityReader fEntityReader = null; |
| private XMLEntityHandler.CharBuffer fLiteralData = null; |
| private int fReaderId = -1; |
| private int fSystemLiteral = -1; |
| private int fPubidLiteral = -1; |
| private int[] fOpStack = null; |
| private int[] fNodeIndexStack = null; |
| private int[] fPrevNodeIndexStack = null; |
| private int fScannerState = SCANNER_STATE_INVALID; |
| private int fIncludeSectDepth = 0; |
| private int fDoctypeReader = -1; |
| private int fExternalSubsetReader = -1; |
| private int fDefaultAttValueReader = -1; |
| private int fDefaultAttValueElementType = -1; |
| private int fDefaultAttValueAttrName = -1; |
| private int fDefaultAttValueOffset = -1; |
| private int fDefaultAttValueMark = -1; |
| private int fEntityValueReader = -1; |
| private int fEntityValueMark = -1; |
| private int fXMLSymbol = -1; |
| private int fXMLNamespace = -1; |
| private int fXMLSpace = -1; |
| private int fDefault = -1; |
| private int fPreserve = -1; |
| private int fScannerMarkupDepth = 0; |
| private int fScannerParenDepth = 0; |
| // |
| // Constructors |
| // |
| public XMLDTDScanner(StringPool stringPool, |
| XMLErrorReporter errorReporter, |
| XMLEntityHandler entityHandler, |
| XMLEntityHandler.CharBuffer literalData) { |
| fStringPool = stringPool; |
| fErrorReporter = errorReporter; |
| fEntityHandler = entityHandler; |
| fLiteralData = literalData; |
| init(); |
| } |
| |
| /** |
| * Set the event handler |
| * |
| * @param eventHandler The place to send our callbacks. |
| */ |
| public void setEventHandler(XMLDTDScanner.EventHandler eventHandler) { |
| fEventHandler = eventHandler; |
| } |
| |
| /** Set the DTD handler. */ |
| public void setDTDHandler(XMLDocumentHandler.DTDHandler dtdHandler) { |
| fDTDHandler = dtdHandler; |
| } |
| |
| /** Sets the grammar resolver. */ |
| public void setGrammarResolver(GrammarResolver resolver) { |
| fGrammarResolver = resolver; |
| } |
| |
| /** set fNamespacesEnabled **/ |
| public void setNamespacesEnabled(boolean enabled) { |
| fNamespacesEnabled = enabled; |
| } |
| |
| /** set fValidationEnabled **/ |
| public void setValidationEnabled(boolean enabled) { |
| fValidationEnabled = enabled; |
| } |
| |
| /** |
| * Is the XMLDTDScanner reading from an external entity? |
| * |
| * This will be true, in particular if there was an external subset |
| * |
| * @return true if the XMLDTDScanner is reading from an external entity. |
| */ |
| public boolean getReadingExternalEntity() { |
| return fReaderId != fDoctypeReader; |
| } |
| /** |
| * Is the scanner reading a ContentSpec? |
| * |
| * @return true if the scanner is reading a ContentSpec |
| */ |
| public boolean getReadingContentSpec() { |
| return getScannerState() == SCANNER_STATE_CONTENTSPEC; |
| } |
| /** |
| * Report the markup nesting depth. This allows a client to |
| * perform validation checks for correct markup nesting. This keeps |
| * scanning and validation separate. |
| * |
| * @return the markup nesting depth |
| */ |
| public int markupDepth() { |
| return fScannerMarkupDepth; |
| } |
| private int increaseMarkupDepth() { |
| return fScannerMarkupDepth++; |
| } |
| private int decreaseMarkupDepth() { |
| return fScannerMarkupDepth--; |
| } |
| /** |
| * Report the parenthesis nesting depth. This allows a client to |
| * perform validation checks for correct parenthesis balancing. This keeps |
| * scanning and validation separate. |
| * |
| * @return the parenthesis depth |
| */ |
| public int parenDepth() { |
| return fScannerParenDepth; |
| } |
| private void setParenDepth(int parenDepth) { |
| fScannerParenDepth = parenDepth; |
| } |
| private void increaseParenDepth() { |
| fScannerParenDepth++; |
| } |
| private void decreaseParenDepth() { |
| fScannerParenDepth--; |
| } |
| // |
| // |
| // |
| /** |
| * Allow XMLDTDScanner to be reused. This method is called from an |
| * XMLParser reset method, which passes the StringPool to be used |
| * by the reset DTD scanner instance. |
| * |
| * @param stringPool the string pool to be used by XMLDTDScanner. |
| */ |
| public void reset(StringPool stringPool, XMLEntityHandler.CharBuffer literalData) throws Exception { |
| fStringPool = stringPool; |
| fLiteralData = literalData; |
| fEntityReader = null; |
| fReaderId = -1; |
| fSystemLiteral = -1; |
| fPubidLiteral = -1; |
| fOpStack = null; |
| fNodeIndexStack = null; |
| fPrevNodeIndexStack = null; |
| fScannerState = SCANNER_STATE_INVALID; |
| fIncludeSectDepth = 0; |
| fDoctypeReader = -1; |
| fExternalSubsetReader = -1; |
| fDefaultAttValueReader = -1; |
| fDefaultAttValueElementType = -1; |
| fDefaultAttValueAttrName = -1; |
| fDefaultAttValueOffset = -1; |
| fDefaultAttValueMark = -1; |
| fEntityValueReader = -1; |
| fEntityValueMark = -1; |
| fScannerMarkupDepth = 0; |
| fScannerParenDepth = 0; |
| init(); |
| } |
| private void init() { |
| fXMLSymbol = fStringPool.addSymbol("xml"); |
| fXMLNamespace = fStringPool.addSymbol("http://www.w3.org/XML/1998/namespace"); |
| |
| fXMLSpace = fStringPool.addSymbol("xml:space"); |
| fDefault = fStringPool.addSymbol("default"); |
| fPreserve = fStringPool.addSymbol("preserve"); |
| } |
| |
| // |
| // Interfaces |
| // |
| |
| /** |
| * This interface must be implemented by the users of the XMLDTDScanner class. |
| * These methods form the abstraction between the implementation semantics and the |
| * more generic task of scanning the DTD-specific XML grammar. |
| */ |
| public interface EventHandler { |
| |
| /** Start of DTD. */ |
| public void callStartDTD() throws Exception; |
| |
| /** End of DTD. */ |
| public void callEndDTD() throws Exception; |
| |
| /** |
| * Signal the Text declaration of an external entity. |
| * |
| * @param version the handle in the string pool for the version number |
| * @param encoding the handle in the string pool for the encoding |
| * @exception java.lang.Exception |
| */ |
| public void callTextDecl(int version, int encoding) throws Exception; |
| /** |
| * Called when the doctype decl is scanned |
| * |
| * @param rootElementType handle of the rootElement |
| * @param publicId StringPool handle of the public id |
| * @param systemId StringPool handle of the system id |
| * @exception java.lang.Exception |
| */ |
| public void doctypeDecl(QName rootElement, int publicId, int systemId) throws Exception; |
| /** |
| * Called when the DTDScanner starts reading from the external subset |
| * |
| * @param publicId StringPool handle of the public id |
| * @param systemId StringPool handle of the system id |
| * @exception java.lang.Exception |
| */ |
| public void startReadingFromExternalSubset(int publicId, int systemId) throws Exception; |
| /** |
| * Called when the DTDScanner stop reading from the external subset |
| * |
| * @exception java.lang.Exception |
| */ |
| public void stopReadingFromExternalSubset() throws Exception; |
| /** |
| * Add an element declaration (forward reference) |
| * |
| * @param handle to the name of the element being declared |
| * @return handle to the element whose declaration was added |
| * @exception java.lang.Exception |
| */ |
| public int addElementDecl(QName elementDecl) throws Exception; |
| /** |
| * Add an element declaration |
| * |
| * @param handle to the name of the element being declared |
| * @param contentSpecType handle to the type name of the content spec |
| * @param ContentSpec handle to the content spec node for the contentSpecType |
| * @return handle to the element declaration that was added |
| * @exception java.lang.Exception |
| */ |
| public int addElementDecl(QName elementDecl, int contentSpecType, int contentSpec, boolean isExternal) throws Exception; |
| /** |
| * Add an attribute definition |
| * |
| * @param handle to the element whose attribute is being declared |
| * @param attName StringPool handle to the attribute name being declared |
| * @param attType type of the attribute |
| * @param enumeration StringPool handle of the attribute's enumeration list (if any) |
| * @param attDefaultType an integer value denoting the DefaultDecl value |
| * @param attDefaultValue StringPool handle of this attribute's default value |
| * @return handle to the attribute definition |
| * @exception java.lang.Exception |
| */ |
| public int addAttDef(QName elementDecl, QName attributeDecl, |
| int attType, boolean attList, int enumeration, |
| int attDefaultType, int attDefaultValue, boolean isExternal) throws Exception; |
| /** |
| * create an XMLContentSpec for a leaf |
| * |
| * @param nameIndex StringPool handle to the name (Element) for the node |
| * @return handle to the newly create XMLContentSpec |
| * @exception java.lang.Exception |
| */ |
| public int addUniqueLeafNode(int nameIndex) throws Exception; |
| /** |
| * Create an XMLContentSpec for a single non-leaf |
| * |
| * @param nodeType the type of XMLContentSpec to create - from XMLContentSpec.CONTENTSPECNODE_* |
| * @param nodeValue handle to an XMLContentSpec |
| * @return handle to the newly create XMLContentSpec |
| * @exception java.lang.Exception |
| */ |
| public int addContentSpecNode(int nodeType, int nodeValue) throws Exception; |
| /** |
| * Create an XMLContentSpec for a two child leaf |
| * |
| * @param nodeType the type of XMLContentSpec to create - from XMLContentSpec.CONTENTSPECNODE_* |
| * @param leftNodeIndex handle to an XMLContentSpec |
| * @param rightNodeIndex handle to an XMLContentSpec |
| * @return handle to the newly create XMLContentSpec |
| * @exception java.lang.Exception |
| */ |
| public int addContentSpecNode(int nodeType, int leftNodeIndex, int rightNodeIndex) throws Exception; |
| /** |
| * Create a string representation of an XMLContentSpec tree |
| * |
| * @param handle to an XMLContentSpec |
| * @return String representation of the content spec tree |
| * @exception java.lang.Exception |
| */ |
| public String getContentSpecNodeAsString(int nodeIndex) throws Exception; |
| /** |
| * Start the scope of an entity declaration. |
| * |
| * @return <code>true</code> on success; otherwise |
| * <code>false</code> if the entity declaration is recursive. |
| * @exception java.lang.Exception |
| */ |
| public boolean startEntityDecl(boolean isPE, int entityName) throws Exception; |
| /** |
| * End the scope of an entity declaration. |
| * @exception java.lang.Exception |
| */ |
| public void endEntityDecl() throws Exception; |
| /** |
| * Add a declaration for an internal parameter entity |
| * |
| * @param name StringPool handle of the parameter entity name |
| * @param value StringPool handle of the parameter entity value |
| * @return handle to the parameter entity declaration |
| * @exception java.lang.Exception |
| */ |
| public int addInternalPEDecl(int name, int value) throws Exception; |
| /** |
| * Add a declaration for an external parameter entity |
| * |
| * @param name StringPool handle of the parameter entity name |
| * @param publicId StringPool handle of the publicId |
| * @param systemId StringPool handle of the systemId |
| * @return handle to the parameter entity declaration |
| * @exception java.lang.Exception |
| */ |
| public int addExternalPEDecl(int name, int publicId, int systemId) throws Exception; |
| /** |
| * Add a declaration for an internal entity |
| * |
| * @param name StringPool handle of the entity name |
| * @param value StringPool handle of the entity value |
| * @return handle to the entity declaration |
| * @exception java.lang.Exception |
| */ |
| public int addInternalEntityDecl(int name, int value) throws Exception; |
| /** |
| * Add a declaration for an entity |
| * |
| * @param name StringPool handle of the entity name |
| * @param publicId StringPool handle of the publicId |
| * @param systemId StringPool handle of the systemId |
| * @return handle to the entity declaration |
| * @exception java.lang.Exception |
| */ |
| public int addExternalEntityDecl(int name, int publicId, int systemId) throws Exception; |
| /** |
| * Add a declaration for an unparsed entity |
| * |
| * @param name StringPool handle of the entity name |
| * @param publicId StringPool handle of the publicId |
| * @param systemId StringPool handle of the systemId |
| * @param notationName StringPool handle of the notationName |
| * @return handle to the entity declaration |
| * @exception java.lang.Exception |
| */ |
| public int addUnparsedEntityDecl(int name, int publicId, int systemId, int notationName) throws Exception; |
| /** |
| * Called when the scanner start scanning an enumeration |
| * @return StringPool handle to a string list that will hold the enumeration names |
| * @exception java.lang.Exception |
| */ |
| public int startEnumeration() throws Exception; |
| /** |
| * Add a name to an enumeration |
| * @param enumIndex StringPool handle to the string list for the enumeration |
| * @param elementType handle to the element that owns the attribute with the enumeration |
| * @param attrName StringPool handle to the name of the attribut with the enumeration |
| * @param nameIndex StringPool handle to the name to be added to the enumeration |
| * @param isNotationType true if the enumeration is an enumeration of NOTATION names |
| * @exception java.lang.Exception |
| */ |
| public void addNameToEnumeration(int enumIndex, int elementType, int attrName, int nameIndex, boolean isNotationType) throws Exception; |
| /** |
| * Finish processing an enumeration |
| * |
| * @param enumIndex handle to the string list which holds the enumeration to be finshed. |
| * @exception java.lang.Exception |
| */ |
| public void endEnumeration(int enumIndex) throws Exception; |
| /** |
| * Add a declaration for a notation |
| * |
| * @param notationName |
| * @param publicId |
| * @param systemId |
| * @return handle to the notation declaration |
| * @exception java.lang.Exception |
| */ |
| public int addNotationDecl(int notationName, int publicId, int systemId) throws Exception; |
| /** |
| * Called when a comment has been scanned |
| * |
| * @param data StringPool handle of the comment text |
| * @exception java.lang.Exception |
| */ |
| public void callComment(int data) throws Exception; |
| /** |
| * Called when a processing instruction has been scanned |
| * @param piTarget StringPool handle of the PI target |
| * @param piData StringPool handle of the PI data |
| * @exception java.lang.Exception |
| */ |
| public void callProcessingInstruction(int piTarget, int piData) throws Exception; |
| /** |
| * Supports DOM Level 2 internalSubset additions. |
| * Called when the internal subset is completely scanned. |
| */ |
| public void internalSubset(int internalSubset) throws Exception; |
| } |
| // |
| // |
| // |
| |
| /** Report a recoverable xml error. */ |
| protected void reportRecoverableXMLError(int majorCode, int minorCode, |
| int stringIndex1) |
| throws Exception { |
| |
| Object[] args = { fStringPool.toString(stringIndex1) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| |
| } // reportRecoverableXMLError(int,int,int) |
| |
| /** Report a recoverable xml error. */ |
| protected void reportRecoverableXMLError(int majorCode, int minorCode, |
| String string1) throws Exception { |
| |
| Object[] args = { string1 }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| |
| } // reportRecoverableXMLError(int,int,String) |
| |
| /** Report a recoverable xml error. */ |
| protected void reportRecoverableXMLError(int majorCode, int minorCode, |
| String string1, String string2) |
| throws Exception { |
| |
| Object[] args = { string1, string2 }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| |
| } // reportRecoverableXMLError(int,int,String,String) |
| |
| |
| private void reportFatalXMLError(int majorCode, int minorCode) throws Exception { |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| null, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void reportFatalXMLError(int majorCode, int minorCode, int stringIndex1) throws Exception { |
| Object[] args = { fStringPool.toString(stringIndex1) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void reportFatalXMLError(int majorCode, int minorCode, String string1) throws Exception { |
| Object[] args = { string1 }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void reportFatalXMLError(int majorCode, int minorCode, int stringIndex1, int stringIndex2) throws Exception { |
| Object[] args = { fStringPool.toString(stringIndex1), |
| fStringPool.toString(stringIndex2) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void reportFatalXMLError(int majorCode, int minorCode, String string1, String string2) throws Exception { |
| Object[] args = { string1, string2 }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void reportFatalXMLError(int majorCode, int minorCode, String string1, String string2, String string3) throws Exception { |
| Object[] args = { string1, string2, string3 }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| majorCode, |
| minorCode, |
| args, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| } |
| private void abortMarkup(int majorCode, int minorCode) throws Exception { |
| reportFatalXMLError(majorCode, minorCode); |
| skipPastEndOfCurrentMarkup(); |
| } |
| private void abortMarkup(int majorCode, int minorCode, int stringIndex1) throws Exception { |
| reportFatalXMLError(majorCode, minorCode, stringIndex1); |
| skipPastEndOfCurrentMarkup(); |
| } |
| private void abortMarkup(int majorCode, int minorCode, String string1) throws Exception { |
| reportFatalXMLError(majorCode, minorCode, string1); |
| skipPastEndOfCurrentMarkup(); |
| } |
| private void abortMarkup(int majorCode, int minorCode, int stringIndex1, int stringIndex2) throws Exception { |
| reportFatalXMLError(majorCode, minorCode, stringIndex1, stringIndex2); |
| skipPastEndOfCurrentMarkup(); |
| } |
| private void skipPastEndOfCurrentMarkup() throws Exception { |
| fEntityReader.skipToChar('>'); |
| if (fEntityReader.lookingAtChar('>', true)) |
| decreaseMarkupDepth(); |
| } |
| // |
| // |
| // |
| static private final int SCANNER_STATE_INVALID = -1; |
| static private final int SCANNER_STATE_END_OF_INPUT = 0; |
| static private final int SCANNER_STATE_DOCTYPEDECL = 50; |
| static private final int SCANNER_STATE_MARKUP_DECL = 51; |
| static private final int SCANNER_STATE_TEXTDECL = 53; |
| static private final int SCANNER_STATE_COMMENT = 54; |
| static private final int SCANNER_STATE_PI = 55; |
| static private final int SCANNER_STATE_DEFAULT_ATTRIBUTE_VALUE = 56; |
| static private final int SCANNER_STATE_CONTENTSPEC = 57; |
| static private final int SCANNER_STATE_ENTITY_VALUE = 58; |
| static private final int SCANNER_STATE_SYSTEMLITERAL = 59; |
| static private final int SCANNER_STATE_PUBIDLITERAL = 60; |
| |
| private int setScannerState(int scannerState) { |
| int prevState = fScannerState; |
| fScannerState = scannerState; |
| return prevState; |
| } |
| private int getScannerState() { |
| return fScannerState; |
| } |
| private void restoreScannerState(int scannerState) { |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) |
| fScannerState = scannerState; |
| } |
| /** |
| * Change readers |
| * |
| * @param nextReader the new reader that the scanner will use |
| * @param nextReaderId id of the reader to change to |
| * @exception throws java.lang.Exception |
| */ |
| public void readerChange(XMLEntityHandler.EntityReader nextReader, int nextReaderId) throws Exception { |
| fEntityReader = nextReader; |
| fReaderId = nextReaderId; |
| if (fScannerState == SCANNER_STATE_DEFAULT_ATTRIBUTE_VALUE) { |
| fDefaultAttValueOffset = fEntityReader.currentOffset(); |
| fDefaultAttValueMark = fDefaultAttValueOffset; |
| } else if (fScannerState == SCANNER_STATE_ENTITY_VALUE) { |
| fEntityValueMark = fEntityReader.currentOffset(); |
| } |
| } |
| /** |
| * Handle the end of input |
| * |
| * @param entityName the handle in the string pool of the name of the entity which has reached end of input |
| * @param moreToFollow if true, there is still input left to process in other readers |
| * @exception java.lang.Exception |
| */ |
| public void endOfInput(int entityNameIndex, boolean moreToFollow) throws Exception { |
| if (fValidationEnabled ) { |
| int readerDepth = fEntityHandler.getReaderDepth(); |
| if (getReadingContentSpec()) { |
| int parenDepth = parenDepth(); |
| if (readerDepth != parenDepth) { |
| reportRecoverableXMLError(XMLMessages.MSG_IMPROPER_GROUP_NESTING, |
| XMLMessages.VC_PROPER_GROUP_PE_NESTING, |
| entityNameIndex); |
| } |
| } else { |
| int markupDepth = markupDepth(); |
| if (readerDepth != markupDepth) { |
| reportRecoverableXMLError(XMLMessages.MSG_IMPROPER_DECLARATION_NESTING, |
| XMLMessages.VC_PROPER_DECLARATION_PE_NESTING, |
| entityNameIndex); |
| } |
| } |
| } |
| //REVISIT, why are we doing this? |
| moreToFollow = fReaderId != fExternalSubsetReader; |
| |
| // System.out.println("current Scanner state " + getScannerState() +","+ fScannerState + moreToFollow); |
| switch (fScannerState) { |
| case SCANNER_STATE_INVALID: |
| throw new RuntimeException("FWK004 XMLDTDScanner.endOfInput: cannot happen: 2"+"\n2"); |
| case SCANNER_STATE_END_OF_INPUT: |
| break; |
| case SCANNER_STATE_MARKUP_DECL: |
| if (!moreToFollow && fIncludeSectDepth > 0) { |
| reportFatalXMLError(XMLMessages.MSG_INCLUDESECT_UNTERMINATED, |
| XMLMessages.P62_UNTERMINATED); |
| } |
| break; |
| case SCANNER_STATE_DOCTYPEDECL: |
| throw new RuntimeException("FWK004 XMLDTDScanner.endOfInput: cannot happen: 2.5"+"\n2.5"); |
| // break; |
| case SCANNER_STATE_TEXTDECL: |
| // REVISIT reportFatalXMLError(XMLMessages.MSG_ATTVAL0); |
| break; |
| case SCANNER_STATE_SYSTEMLITERAL: |
| if (!moreToFollow) { |
| reportFatalXMLError(XMLMessages.MSG_SYSTEMID_UNTERMINATED, |
| XMLMessages.P11_UNTERMINATED); |
| } else { |
| // REVISIT reportFatalXMLError(XMLMessages.MSG_ATTVAL0); |
| } |
| break; |
| case SCANNER_STATE_PUBIDLITERAL: |
| if (!moreToFollow) { |
| reportFatalXMLError(XMLMessages.MSG_PUBLICID_UNTERMINATED, |
| XMLMessages.P12_UNTERMINATED); |
| } else { |
| // REVISIT reportFatalXMLError(XMLMessages.MSG_ATTVAL0); |
| } |
| break; |
| case SCANNER_STATE_COMMENT: |
| if (!moreToFollow && !getReadingExternalEntity()) { |
| reportFatalXMLError(XMLMessages.MSG_COMMENT_UNTERMINATED, |
| XMLMessages.P15_UNTERMINATED); |
| } else { |
| // |
| // REVISIT - HACK !!! code changed to pass incorrect OASIS test 'invalid--001' |
| // Uncomment the next line to conform to the spec... |
| // |
| //reportFatalXMLError(XMLMessages.MSG_COMMENT_NOT_IN_ONE_ENTITY, |
| // XMLMessages.P78_NOT_WELLFORMED); |
| } |
| break; |
| case SCANNER_STATE_PI: |
| if (!moreToFollow) { |
| reportFatalXMLError(XMLMessages.MSG_PI_UNTERMINATED, |
| XMLMessages.P16_UNTERMINATED); |
| } else { |
| reportFatalXMLError(XMLMessages.MSG_PI_NOT_IN_ONE_ENTITY, |
| XMLMessages.P78_NOT_WELLFORMED); |
| } |
| break; |
| case SCANNER_STATE_DEFAULT_ATTRIBUTE_VALUE: |
| if (!moreToFollow) { |
| reportFatalXMLError(XMLMessages.MSG_ATTRIBUTE_VALUE_UNTERMINATED, |
| XMLMessages.P10_UNTERMINATED, |
| fDefaultAttValueElementType, |
| fDefaultAttValueAttrName); |
| } else if (fReaderId == fDefaultAttValueReader) { |
| // REVISIT reportFatalXMLError(XMLMessages.MSG_ATTVAL0); |
| } else { |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| } |
| break; |
| case SCANNER_STATE_CONTENTSPEC: |
| break; |
| case SCANNER_STATE_ENTITY_VALUE: |
| if (fReaderId == fEntityValueReader) { |
| // REVISIT reportFatalXMLError(XMLMessages.MSG_ATTVAL0); |
| } else { |
| fEntityReader.append(fLiteralData, fEntityValueMark, fEntityReader.currentOffset() - fEntityValueMark); |
| } |
| break; |
| default: |
| throw new RuntimeException("FWK004 XMLDTDScanner.endOfInput: cannot happen: 3"+"\n3"); |
| } |
| if (!moreToFollow) { |
| setScannerState(SCANNER_STATE_END_OF_INPUT); |
| } |
| } |
| // |
| // [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' |
| // |
| private int scanCharRef() throws Exception { |
| int valueOffset = fEntityReader.currentOffset(); |
| boolean hex = fEntityReader.lookingAtChar('x', true); |
| int num = fEntityReader.scanCharRef(hex); |
| if (num < 0) { |
| switch (num) { |
| case XMLEntityHandler.CHARREF_RESULT_SEMICOLON_REQUIRED: |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_CHARREF, |
| XMLMessages.P66_SEMICOLON_REQUIRED); |
| return -1; |
| case XMLEntityHandler.CHARREF_RESULT_INVALID_CHAR: |
| int majorCode = hex ? XMLMessages.MSG_HEXDIGIT_REQUIRED_IN_CHARREF : |
| XMLMessages.MSG_DIGIT_REQUIRED_IN_CHARREF; |
| int minorCode = hex ? XMLMessages.P66_HEXDIGIT_REQUIRED : |
| XMLMessages.P66_DIGIT_REQUIRED; |
| reportFatalXMLError(majorCode, minorCode); |
| return -1; |
| case XMLEntityHandler.CHARREF_RESULT_OUT_OF_RANGE: |
| num = 0x110000; // this will cause the right error to be reported below... |
| break; |
| } |
| } |
| // |
| // [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] // any Unicode character, excluding the |
| // | [#xE000-#xFFFD] | [#x10000-#x10FFFF] // surrogate blocks, FFFE, and FFFF. |
| // |
| if (num < 0x20) { |
| if (num == 0x09 || num == 0x0A || num == 0x0D) { |
| return num; |
| } |
| } else if (num <= 0xD7FF || (num >= 0xE000 && (num <= 0xFFFD || (num >= 0x10000 && num <= 0x10FFFF)))) { |
| return num; |
| } |
| int valueLength = fEntityReader.currentOffset() - valueOffset; |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHARREF, |
| XMLMessages.WFC_LEGAL_CHARACTER, |
| fEntityReader.addString(valueOffset, valueLength)); |
| return -1; |
| } |
| // |
| // From the standard: |
| // |
| // [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' |
| // |
| // Called after scanning past '<!--' |
| // |
| private void scanComment() throws Exception |
| { |
| int commentOffset = fEntityReader.currentOffset(); |
| boolean sawDashDash = false; |
| int previousState = setScannerState(SCANNER_STATE_COMMENT); |
| while (fScannerState == SCANNER_STATE_COMMENT) { |
| if (fEntityReader.lookingAtChar('-', false)) { |
| int nextEndOffset = fEntityReader.currentOffset(); |
| int endOffset = 0; |
| fEntityReader.lookingAtChar('-', true); |
| int offset = fEntityReader.currentOffset(); |
| int count = 1; |
| while (fEntityReader.lookingAtChar('-', true)) { |
| count++; |
| endOffset = nextEndOffset; |
| nextEndOffset = offset; |
| offset = fEntityReader.currentOffset(); |
| } |
| if (count > 1) { |
| if (fEntityReader.lookingAtChar('>', true)) { |
| if (!sawDashDash && count > 2) { |
| reportFatalXMLError(XMLMessages.MSG_DASH_DASH_IN_COMMENT, |
| XMLMessages.P15_DASH_DASH); |
| sawDashDash = true; |
| } |
| decreaseMarkupDepth(); |
| int comment = fEntityReader.addString(commentOffset, endOffset - commentOffset); |
| fDTDGrammar.callComment(comment); |
| if (fDTDHandler != null) { |
| fDTDHandler.comment(comment); |
| } |
| restoreScannerState(previousState); |
| return; |
| } else if (!sawDashDash) { |
| reportFatalXMLError(XMLMessages.MSG_DASH_DASH_IN_COMMENT, |
| XMLMessages.P15_DASH_DASH); |
| sawDashDash = true; |
| } |
| } |
| } else { |
| if (!fEntityReader.lookingAtValidChar(true)) { |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) { |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_COMMENT, |
| XMLMessages.P15_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| } |
| } |
| } |
| } |
| restoreScannerState(previousState); |
| } |
| // |
| // From the standard: |
| // |
| // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' |
| // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) |
| // |
| private void scanPI(int piTarget) throws Exception |
| { |
| String piTargetString = fStringPool.toString(piTarget); |
| if (piTargetString.length() == 3 && |
| (piTargetString.charAt(0) == 'X' || piTargetString.charAt(0) == 'x') && |
| (piTargetString.charAt(1) == 'M' || piTargetString.charAt(1) == 'm') && |
| (piTargetString.charAt(2) == 'L' || piTargetString.charAt(2) == 'l')) { |
| abortMarkup(XMLMessages.MSG_RESERVED_PITARGET, |
| XMLMessages.P17_RESERVED_PITARGET); |
| return; |
| } |
| int prevState = setScannerState(SCANNER_STATE_PI); |
| int piDataOffset = -1; |
| int piDataLength = 0; |
| if (!fEntityReader.lookingAtSpace(true)) { |
| if (!fEntityReader.lookingAtChar('?', true) || !fEntityReader.lookingAtChar('>', true)) { |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_IN_PI, |
| XMLMessages.P16_WHITESPACE_REQUIRED); |
| restoreScannerState(prevState); |
| } |
| return; |
| } |
| decreaseMarkupDepth(); |
| restoreScannerState(prevState); |
| } else { |
| fEntityReader.skipPastSpaces(); |
| piDataOffset = fEntityReader.currentOffset(); |
| while (fScannerState == SCANNER_STATE_PI) { |
| while (fEntityReader.lookingAtChar('?', false)) { |
| int offset = fEntityReader.currentOffset(); |
| fEntityReader.lookingAtChar('?', true); |
| if (fEntityReader.lookingAtChar('>', true)) { |
| piDataLength = offset - piDataOffset; |
| decreaseMarkupDepth(); |
| restoreScannerState(prevState); |
| break; |
| } |
| } |
| if (fScannerState != SCANNER_STATE_PI) |
| break; |
| if (!fEntityReader.lookingAtValidChar(true)) { |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) { |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_PI, |
| XMLMessages.P16_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| skipPastEndOfCurrentMarkup(); |
| restoreScannerState(prevState); |
| } |
| return; |
| } |
| } |
| } |
| int piData = piDataLength == 0 ? |
| StringPool.EMPTY_STRING : fEntityReader.addString(piDataOffset, piDataLength); |
| fDTDGrammar.callProcessingInstruction(piTarget, piData); |
| if (fDTDHandler != null) { |
| fDTDHandler.processingInstruction(piTarget, piData); |
| } |
| } |
| // |
| // From the standard: |
| // |
| // [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? |
| // ('[' (markupdecl | PEReference | S)* ']' S?)? '>' |
| // [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
| // | NotationDecl | PI | Comment |
| // |
| // Called after scanning '<!DOCTYPE' |
| // |
| /** |
| * This routine is called after the <!DOCTYPE portion of a DOCTYPE |
| * line has been called. scanDocTypeDecl goes onto scan the rest of the DOCTYPE |
| * decl. If an internal DTD subset exists, it is scanned. If an external DTD |
| * subset exists, scanDocTypeDecl sets up the state necessary to process it. |
| * |
| * @return true if successful |
| * @exception java.lang.Exception |
| */ |
| public boolean scanDoctypeDecl() throws Exception |
| { |
| //System.out.println("XMLDTDScanner#scanDoctypeDecl()"); |
| |
| fDTDGrammar = new DTDGrammar(fStringPool); |
| fDTDGrammar.callStartDTD(); |
| increaseMarkupDepth(); |
| fEntityReader = fEntityHandler.getEntityReader(); |
| fReaderId = fEntityHandler.getReaderId(); |
| fDoctypeReader = fReaderId; |
| setScannerState(SCANNER_STATE_DOCTYPEDECL); |
| if (!fEntityReader.lookingAtSpace(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ROOT_ELEMENT_TYPE_IN_DOCTYPEDECL, |
| XMLMessages.P28_SPACE_REQUIRED); |
| return false; |
| } |
| fEntityReader.skipPastSpaces(); |
| scanElementType(fEntityReader, ' ', fElementQName); |
| if (fElementQName.rawname == -1) { |
| abortMarkup(XMLMessages.MSG_ROOT_ELEMENT_TYPE_REQUIRED, |
| XMLMessages.P28_ROOT_ELEMENT_TYPE_REQUIRED); |
| return false; |
| } |
| boolean lbrkt; |
| boolean scanExternalSubset = false; |
| int publicId = -1; |
| int systemId = -1; |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| if (!(lbrkt = fEntityReader.lookingAtChar('[', true)) && !fEntityReader.lookingAtChar('>', false)) { |
| if (!scanExternalID(false)) { |
| skipPastEndOfCurrentMarkup(); |
| return false; |
| } |
| scanExternalSubset = true; |
| publicId = fPubidLiteral; |
| systemId = fSystemLiteral; |
| fEntityReader.skipPastSpaces(); |
| lbrkt = fEntityReader.lookingAtChar('[', true); |
| } |
| } else |
| lbrkt = fEntityReader.lookingAtChar('[', true); |
| fDTDGrammar.doctypeDecl(fElementQName, publicId, systemId); |
| if (fDTDHandler != null) { |
| fDTDHandler.startDTD(fElementQName, publicId, systemId); |
| } |
| if (lbrkt) { |
| scanDecls(false); |
| fEntityReader.skipPastSpaces(); |
| } |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) { |
| abortMarkup(XMLMessages.MSG_DOCTYPEDECL_UNTERMINATED, |
| XMLMessages.P28_UNTERMINATED, |
| fElementQName.rawname); |
| } |
| return false; |
| } |
| |
| decreaseMarkupDepth(); |
| |
| //System.out.println(" scanExternalSubset: "+scanExternalSubset); |
| if (scanExternalSubset) { |
| ((DefaultEntityHandler) fEntityHandler).startReadingFromExternalSubset( fStringPool.toString(publicId), |
| fStringPool.toString(systemId), |
| markupDepth()); |
| fDTDGrammar.startReadingFromExternalSubset(publicId, systemId); |
| } |
| else { |
| fDTDGrammar.callEndDTD(); |
| if (fDTDHandler != null) { |
| fDTDHandler.endDTD(); |
| } |
| } |
| |
| fGrammarResolver.putGrammar("", fDTDGrammar); |
| |
| |
| return true; |
| } |
| // |
| // [75] ExternalID ::= 'SYSTEM' S SystemLiteral |
| // | 'PUBLIC' S PubidLiteral S SystemLiteral |
| // [83] PublicID ::= 'PUBLIC' S PubidLiteral |
| // |
| private boolean scanExternalID(boolean scanPublicID) throws Exception |
| { |
| fSystemLiteral = -1; |
| fPubidLiteral = -1; |
| int offset = fEntityReader.currentOffset(); |
| if (fEntityReader.skippedString(system_string)) { |
| if (!fEntityReader.lookingAtSpace(true)) { |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_SYSTEMLITERAL_IN_EXTERNALID, |
| XMLMessages.P75_SPACE_REQUIRED); |
| return false; |
| } |
| fEntityReader.skipPastSpaces(); |
| if( getReadingExternalEntity() == true ) { //Are we in external subset? |
| checkForPEReference(false);//If so Check for PE Ref |
| } |
| return scanSystemLiteral(); |
| } |
| if (fEntityReader.skippedString(public_string)) { |
| if (!fEntityReader.lookingAtSpace(true)) { |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_PUBIDLITERAL_IN_EXTERNALID, |
| XMLMessages.P75_SPACE_REQUIRED); |
| return false; |
| } |
| fEntityReader.skipPastSpaces(); |
| if (!scanPubidLiteral()) |
| return false; |
| if (scanPublicID) { |
| // |
| // [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' |
| // |
| if (!fEntityReader.lookingAtSpace(true)) |
| return true; // no S, not an ExternalID |
| fEntityReader.skipPastSpaces(); |
| if (fEntityReader.lookingAtChar('>', false)) // matches end of NotationDecl |
| return true; |
| } else { |
| if (!fEntityReader.lookingAtSpace(true)) { |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_AFTER_PUBIDLITERAL_IN_EXTERNALID, |
| XMLMessages.P75_SPACE_REQUIRED); |
| return false; |
| } |
| fEntityReader.skipPastSpaces(); |
| } |
| return scanSystemLiteral(); |
| } |
| reportFatalXMLError(XMLMessages.MSG_EXTERNALID_REQUIRED, |
| XMLMessages.P75_INVALID); |
| return false; |
| } |
| // |
| // [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") |
| // |
| // REVISIT - need to look into uri escape mechanism for non-ascii characters. |
| // |
| private boolean scanSystemLiteral() throws Exception |
| { |
| boolean single; |
| if (!(single = fEntityReader.lookingAtChar('\'', true)) && !fEntityReader.lookingAtChar('\"', true)) { |
| reportFatalXMLError(XMLMessages.MSG_QUOTE_REQUIRED_IN_SYSTEMID, |
| XMLMessages.P11_QUOTE_REQUIRED); |
| return false; |
| } |
| int prevState = setScannerState(SCANNER_STATE_SYSTEMLITERAL); |
| int offset = fEntityReader.currentOffset(); |
| char qchar = single ? '\'' : '\"'; |
| boolean dataok = true; |
| boolean fragment = false; |
| while (!fEntityReader.lookingAtChar(qchar, false)) { |
| //ericye |
| //System.out.println("XMLDTDScanner#scanDoctypeDecl() 3333333, "+fReaderId+", " + fScannerState+", " +fExternalSubsetReader); |
| if (fEntityReader.lookingAtChar('#', true)) { |
| fragment = true; |
| } else if (!fEntityReader.lookingAtValidChar(true)) { |
| //System.out.println("XMLDTDScanner#scanDoctypeDecl() 555555 scan state: " + fScannerState); |
| dataok = false; |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| return false; |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_SYSTEMID, |
| XMLMessages.P11_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| } |
| } |
| if (dataok) { |
| fSystemLiteral = fEntityReader.addString(offset, fEntityReader.currentOffset() - offset); |
| if (fragment) { |
| // NOTE: RECOVERABLE ERROR |
| Object[] args = { fStringPool.toString(fSystemLiteral) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_URI_FRAGMENT_IN_SYSTEMID, |
| XMLMessages.P11_URI_FRAGMENT, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| } |
| } |
| fEntityReader.lookingAtChar(qchar, true); |
| restoreScannerState(prevState); |
| return dataok; |
| } |
| // |
| // [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" |
| // [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] |
| // |
| private boolean scanPubidLiteral() throws Exception |
| { |
| boolean single; |
| if (!(single = fEntityReader.lookingAtChar('\'', true)) && !fEntityReader.lookingAtChar('\"', true)) { |
| reportFatalXMLError(XMLMessages.MSG_QUOTE_REQUIRED_IN_PUBLICID, |
| XMLMessages.P12_QUOTE_REQUIRED); |
| return false; |
| } |
| char qchar = single ? '\'' : '\"'; |
| int prevState = setScannerState(SCANNER_STATE_PUBIDLITERAL); |
| boolean dataok = true; |
| while (true) { |
| if (fEntityReader.lookingAtChar((char)0x09, true)) { |
| dataok = false; |
| reportFatalXMLError(XMLMessages.MSG_PUBIDCHAR_ILLEGAL, |
| XMLMessages.P12_INVALID_CHARACTER, "9"); |
| } |
| if (!fEntityReader.lookingAtSpace(true)) |
| break; |
| } |
| int offset = fEntityReader.currentOffset(); |
| int dataOffset = fLiteralData.length(); |
| int toCopy = offset; |
| while (true) { |
| if (fEntityReader.lookingAtChar(qchar, true)) { |
| if (dataok && offset - toCopy > 0) |
| fEntityReader.append(fLiteralData, toCopy, offset - toCopy); |
| break; |
| } |
| if (fEntityReader.lookingAtChar((char)0x09, true)) { |
| dataok = false; |
| reportFatalXMLError(XMLMessages.MSG_PUBIDCHAR_ILLEGAL, |
| XMLMessages.P12_INVALID_CHARACTER, "9"); |
| continue; |
| } |
| if (fEntityReader.lookingAtSpace(true)) { |
| if (dataok && offset - toCopy > 0) |
| fEntityReader.append(fLiteralData, toCopy, offset - toCopy); |
| while (true) { |
| if (fEntityReader.lookingAtChar((char)0x09, true)) { |
| dataok = false; |
| reportFatalXMLError(XMLMessages.MSG_PUBIDCHAR_ILLEGAL, |
| XMLMessages.P12_INVALID_CHARACTER, "9"); |
| break; |
| } else if (!fEntityReader.lookingAtSpace(true)) { |
| break; |
| } |
| } |
| if (fEntityReader.lookingAtChar(qchar, true)) |
| break; |
| if (dataok) { |
| fLiteralData.append(' '); |
| offset = fEntityReader.currentOffset(); |
| toCopy = offset; |
| } |
| continue; |
| } |
| if (!fEntityReader.lookingAtValidChar(true)) { |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| return false; |
| dataok = false; |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_PUBLICID, |
| XMLMessages.P12_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| } |
| if (dataok) |
| offset = fEntityReader.currentOffset(); |
| } |
| if (dataok) { |
| int dataLength = fLiteralData.length() - dataOffset; |
| fPubidLiteral = fLiteralData.addString(dataOffset, dataLength); |
| String publicId = fStringPool.toString(fPubidLiteral); |
| int invCharIndex = validPublicId(publicId); |
| if (invCharIndex >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_PUBIDCHAR_ILLEGAL, |
| XMLMessages.P12_INVALID_CHARACTER, |
| Integer.toHexString(publicId.charAt(invCharIndex))); |
| return false; |
| } |
| } |
| restoreScannerState(prevState); |
| return dataok; |
| } |
| // |
| // [??] intSubsetDecl = '[' (markupdecl | PEReference | S)* ']' |
| // |
| // [31] extSubsetDecl ::= ( markupdecl | conditionalSect | PEReference | S )* |
| // [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' |
| // |
| // [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
| // | NotationDecl | PI | Comment |
| // |
| // [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' |
| // |
| // [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' |
| // |
| // [70] EntityDecl ::= GEDecl | PEDecl |
| // [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' |
| // [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' |
| // |
| // [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' |
| // |
| // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' |
| // |
| // [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' |
| // |
| // [61] conditionalSect ::= includeSect | ignoreSect |
| // [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' |
| // [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>' |
| // [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)* |
| // [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*) |
| // |
| /** |
| * Scan markup declarations |
| * |
| * @param extSubset true if the scanner is scanning an external subset, false |
| * if it is scanning an internal subset |
| * @exception java.lang.Exception |
| */ |
| public void scanDecls(boolean extSubset) throws Exception |
| { |
| int subsetOffset = fEntityReader.currentOffset(); |
| if (extSubset) |
| fExternalSubsetReader = fReaderId; |
| fIncludeSectDepth = 0; |
| boolean parseTextDecl = extSubset; |
| int prevState = setScannerState(SCANNER_STATE_MARKUP_DECL); |
| while (fScannerState == SCANNER_STATE_MARKUP_DECL) { |
| |
| boolean newParseTextDecl = false; |
| if (!extSubset && fEntityReader.lookingAtChar(']', false)) { |
| int subsetLength = fEntityReader.currentOffset() - subsetOffset; |
| int internalSubset = fEntityReader.addString(subsetOffset, subsetLength); |
| fDTDGrammar.internalSubset(internalSubset); |
| if (fDTDHandler != null) { |
| fDTDHandler.internalSubset(internalSubset); |
| } |
| fEntityReader.lookingAtChar(']', true); |
| restoreScannerState(prevState); |
| return; |
| } |
| if (fEntityReader.lookingAtChar('<', true)) { |
| int olddepth = markupDepth(); |
| increaseMarkupDepth(); |
| if (fEntityReader.lookingAtChar('!', true)) { |
| if (fEntityReader.lookingAtChar('-', true)) { |
| if (fEntityReader.lookingAtChar('-', true)) { |
| scanComment(); |
| } else { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } |
| } else if (fEntityReader.lookingAtChar('[', true) && getReadingExternalEntity()) { |
| checkForPEReference(false); |
| if (fEntityReader.skippedString(include_string)) { |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('[', true)) { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } else { |
| fIncludeSectDepth++; |
| } |
| } else if (fEntityReader.skippedString(ignore_string)) { |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('[', true)) { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } else |
| scanIgnoreSectContents(); |
| } else { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } |
| } else if (fEntityReader.skippedString(element_string)) { |
| scanElementDecl(); |
| } |
| else if (fEntityReader.skippedString(attlist_string)) |
| scanAttlistDecl(); |
| else if (fEntityReader.skippedString(entity_string)) |
| scanEntityDecl(); |
| else if (fEntityReader.skippedString(notation_string)) |
| scanNotationDecl(); |
| else { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } |
| } else if (fEntityReader.lookingAtChar('?', true)) { |
| int piTarget = fEntityReader.scanName(' '); |
| if (piTarget == -1) { |
| abortMarkup(XMLMessages.MSG_PITARGET_REQUIRED, |
| XMLMessages.P16_REQUIRED); |
| } else if ("xml".equals(fStringPool.toString(piTarget))) { |
| if (fEntityReader.lookingAtSpace(true)) { |
| if (parseTextDecl) { // a TextDecl looks like a PI with the target 'xml' |
| scanTextDecl(); |
| } else { |
| abortMarkup(XMLMessages.MSG_TEXTDECL_MUST_BE_FIRST, |
| XMLMessages.P30_TEXTDECL_MUST_BE_FIRST); |
| } |
| } else { // a PI target matching 'xml' |
| abortMarkup(XMLMessages.MSG_RESERVED_PITARGET, |
| XMLMessages.P17_RESERVED_PITARGET); |
| } |
| } else // PI |
| scanPI(piTarget); |
| } else { |
| abortMarkup(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| } |
| } else if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| } else if (fEntityReader.lookingAtChar('%', true)) { |
| // |
| // [69] PEReference ::= '%' Name ';' |
| // |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_NAME_REQUIRED); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else { |
| int peNameIndex = fEntityReader.addSymbol(nameOffset, nameLength); |
| newParseTextDecl = fEntityHandler.startReadingFromEntity(peNameIndex, markupDepth(), XMLEntityHandler.ENTITYREF_IN_DTD_AS_MARKUP); |
| } |
| } else if (fIncludeSectDepth > 0 && fEntityReader.lookingAtChar(']', true)) { |
| if (!fEntityReader.lookingAtChar(']', true) || !fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_INCLUDESECT_UNTERMINATED, |
| XMLMessages.P62_UNTERMINATED); |
| } else |
| decreaseMarkupDepth(); |
| fIncludeSectDepth--; |
| } else { |
| if (!fEntityReader.lookingAtValidChar(false)) { |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| break; |
| if (invChar >= 0) { |
| if (!extSubset) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_INTERNAL_SUBSET, |
| XMLMessages.P28_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } else { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_EXTERNAL_SUBSET, |
| XMLMessages.P30_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| } |
| } else { |
| reportFatalXMLError(XMLMessages.MSG_MARKUP_NOT_RECOGNIZED_IN_DTD, |
| XMLMessages.P29_NOT_RECOGNIZED); |
| fEntityReader.lookingAtValidChar(true); |
| } |
| } |
| parseTextDecl = newParseTextDecl; |
| } |
| if (extSubset) { |
| |
| ((DefaultEntityHandler) fEntityHandler).stopReadingFromExternalSubset(); |
| |
| fDTDGrammar.stopReadingFromExternalSubset(); |
| fDTDGrammar.callEndDTD(); |
| if (fDTDHandler != null) { |
| fDTDHandler.endDTD(); |
| } |
| // REVISIT: What should the namspace URI of a DTD be? |
| fGrammarResolver.putGrammar("", fDTDGrammar); |
| } |
| } |
| // |
| // [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)* |
| // [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*) |
| // |
| private void scanIgnoreSectContents() throws Exception |
| { |
| int initialDepth = ++fIncludeSectDepth; |
| while (true) { |
| if (fEntityReader.lookingAtChar('<', true)) { |
| // |
| // These tests are split so that we handle cases like |
| // '<<![' and '<!<![' which we might otherwise miss. |
| // |
| if (fEntityReader.lookingAtChar('!', true) && fEntityReader.lookingAtChar('[', true)) |
| fIncludeSectDepth++; |
| } else if (fEntityReader.lookingAtChar(']', true)) { |
| // |
| // The same thing goes for ']<![' and '<]]>', etc. |
| // |
| if (fEntityReader.lookingAtChar(']', true)) { |
| while (fEntityReader.lookingAtChar(']', true)) { |
| /* empty loop body */ |
| } |
| if (fEntityReader.lookingAtChar('>', true)) { |
| if (fIncludeSectDepth-- == initialDepth) { |
| decreaseMarkupDepth(); |
| return; |
| } |
| } |
| } |
| } else if (!fEntityReader.lookingAtValidChar(true)) { |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| return; |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_IGNORESECT, |
| XMLMessages.P65_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| } |
| } |
| } |
| // |
| // From the standard: |
| // |
| // [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' |
| // [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") |
| // [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" ) |
| // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* |
| // |
| private void scanTextDecl() throws Exception { |
| int version = -1; |
| int encoding = -1; |
| final int TEXTDECL_START = 0; |
| final int TEXTDECL_VERSION = 1; |
| final int TEXTDECL_ENCODING = 2; |
| final int TEXTDECL_FINISHED = 3; |
| int prevState = setScannerState(SCANNER_STATE_TEXTDECL); |
| int state = TEXTDECL_START; |
| do { |
| fEntityReader.skipPastSpaces(); |
| int offset = fEntityReader.currentOffset(); |
| if (state == TEXTDECL_START && fEntityReader.skippedString(version_string)) { |
| state = TEXTDECL_VERSION; |
| } else if (fEntityReader.skippedString(encoding_string)) { |
| state = TEXTDECL_ENCODING; |
| } else { |
| abortMarkup(XMLMessages.MSG_ENCODINGDECL_REQUIRED, |
| XMLMessages.P77_ENCODINGDECL_REQUIRED); |
| restoreScannerState(prevState); |
| return; |
| } |
| int length = fEntityReader.currentOffset() - offset; |
| fEntityReader.skipPastSpaces(); |
| if (!fEntityReader.lookingAtChar('=', true)) { |
| int minorCode = state == TEXTDECL_VERSION ? |
| XMLMessages.P24_EQ_REQUIRED : |
| XMLMessages.P80_EQ_REQUIRED; |
| abortMarkup(XMLMessages.MSG_EQ_REQUIRED_IN_TEXTDECL, minorCode, |
| fEntityReader.addString(offset, length)); |
| restoreScannerState(prevState); |
| return; |
| } |
| fEntityReader.skipPastSpaces(); |
| int result = fEntityReader.scanStringLiteral(); |
| switch (result) { |
| case XMLEntityHandler.STRINGLIT_RESULT_QUOTE_REQUIRED: |
| { |
| int minorCode = state == TEXTDECL_VERSION ? |
| XMLMessages.P24_QUOTE_REQUIRED : |
| XMLMessages.P80_QUOTE_REQUIRED; |
| abortMarkup(XMLMessages.MSG_QUOTE_REQUIRED_IN_TEXTDECL, minorCode, |
| fEntityReader.addString(offset, length)); |
| restoreScannerState(prevState); |
| return; |
| } |
| case XMLEntityHandler.STRINGLIT_RESULT_INVALID_CHAR: |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState != SCANNER_STATE_END_OF_INPUT) { |
| if (invChar >= 0) { |
| int minorCode = state == TEXTDECL_VERSION ? |
| XMLMessages.P26_INVALID_CHARACTER : |
| XMLMessages.P81_INVALID_CHARACTER; |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_TEXTDECL, minorCode, |
| Integer.toHexString(invChar)); |
| } |
| skipPastEndOfCurrentMarkup(); |
| restoreScannerState(prevState); |
| } |
| return; |
| default: |
| break; |
| } |
| switch (state) { |
| case TEXTDECL_VERSION: |
| // |
| // version="..." |
| // |
| version = result; |
| String versionString = fStringPool.toString(version); |
| if (!"1.0".equals(versionString)) { |
| if (!validVersionNum(versionString)) { |
| abortMarkup(XMLMessages.MSG_VERSIONINFO_INVALID, |
| XMLMessages.P26_INVALID_VALUE, |
| versionString); |
| restoreScannerState(prevState); |
| return; |
| } |
| // NOTE: RECOVERABLE ERROR |
| Object[] args = { versionString }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_VERSION_NOT_SUPPORTED, |
| XMLMessages.P26_NOT_SUPPORTED, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| // REVISIT - hope it is a compatible version... |
| // skipPastEndOfCurrentMarkup(); |
| // return; |
| } |
| if (!fEntityReader.lookingAtSpace(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_IN_TEXTDECL, |
| XMLMessages.P80_WHITESPACE_REQUIRED); |
| restoreScannerState(prevState); |
| return; |
| } |
| break; |
| case TEXTDECL_ENCODING: |
| // |
| // encoding = "..." |
| // |
| encoding = result; |
| String encodingString = fStringPool.toString(encoding); |
| if (!validEncName(encodingString)) { |
| abortMarkup(XMLMessages.MSG_ENCODINGDECL_INVALID, |
| XMLMessages.P81_INVALID_VALUE, |
| encodingString); |
| restoreScannerState(prevState); |
| return; |
| } |
| fEntityReader.skipPastSpaces(); |
| state = TEXTDECL_FINISHED; |
| break; |
| } |
| } while (state != TEXTDECL_FINISHED); |
| if (!fEntityReader.lookingAtChar('?', true) || !fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_TEXTDECL_UNTERMINATED, |
| XMLMessages.P77_UNTERMINATED); |
| restoreScannerState(prevState); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.callTextDecl(version, encoding); |
| if (fDTDHandler != null) { |
| fDTDHandler.textDecl(version, encoding); |
| } |
| restoreScannerState(prevState); |
| } |
| |
| private QName fElementDeclQName = new QName(); |
| |
| /** |
| * Scans an element declaration. |
| * <pre> |
| * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' |
| * </pre> |
| */ |
| private void scanElementDecl() throws Exception { |
| |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ELEMENT_TYPE_IN_ELEMENTDECL, |
| XMLMessages.P45_SPACE_REQUIRED); |
| return; |
| } |
| checkForElementTypeWithPEReference(fEntityReader, ' ', fElementQName); |
| if (fElementQName.rawname == -1) { |
| abortMarkup(XMLMessages.MSG_ELEMENT_TYPE_REQUIRED_IN_ELEMENTDECL, |
| XMLMessages.P45_ELEMENT_TYPE_REQUIRED); |
| return; |
| } |
| if (fDTDHandler != null) { |
| fElementDeclQName.setValues(fElementQName); |
| } |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_CONTENTSPEC_IN_ELEMENTDECL, |
| XMLMessages.P45_SPACE_REQUIRED, |
| fElementQName.rawname); |
| return; |
| } |
| int contentSpecType = -1; |
| int contentSpec = -1; |
| if (fEntityReader.skippedString(empty_string)) { |
| contentSpecType = XMLElementDecl.TYPE_EMPTY; |
| } else if (fEntityReader.skippedString(any_string)) { |
| contentSpecType = XMLElementDecl.TYPE_ANY; |
| } else if (!fEntityReader.lookingAtChar('(', true)) { |
| abortMarkup(XMLMessages.MSG_CONTENTSPEC_REQUIRED_IN_ELEMENTDECL, |
| XMLMessages.P45_CONTENTSPEC_REQUIRED, |
| fElementQName.rawname); |
| return; |
| } else { |
| int contentSpecReader = fReaderId; |
| int contentSpecReaderDepth = fEntityHandler.getReaderDepth(); |
| int prevState = setScannerState(SCANNER_STATE_CONTENTSPEC); |
| int oldDepth = parenDepth(); |
| fEntityHandler.setReaderDepth(oldDepth); |
| increaseParenDepth(); |
| checkForPEReference(false); |
| boolean skippedPCDATA = fEntityReader.skippedString(pcdata_string); |
| if (skippedPCDATA) { |
| contentSpecType = XMLElementDecl.TYPE_MIXED; |
| // REVISIT: Validation. Should we pass in QName? |
| contentSpec = scanMixed(fElementQName); |
| } else { |
| contentSpecType = XMLElementDecl.TYPE_CHILDREN; |
| // REVISIT: Validation. Should we pass in QName? |
| contentSpec = scanChildren(fElementQName); |
| } |
| boolean success = contentSpec != -1; |
| restoreScannerState(prevState); |
| fEntityHandler.setReaderDepth(contentSpecReaderDepth); |
| if (!success) { |
| setParenDepth(oldDepth); |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } else { |
| if (parenDepth() != oldDepth) // REVISIT - should not be needed |
| // System.out.println("nesting depth mismatch"); |
| ; |
| } |
| } |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ELEMENTDECL_UNTERMINATED, |
| XMLMessages.P45_UNTERMINATED, |
| fElementQName.rawname); |
| return; |
| } |
| decreaseMarkupDepth(); |
| int elementIndex = fDTDGrammar.getElementDeclIndex(fElementQName, -1); |
| boolean elementDeclIsExternal = getReadingExternalEntity(); |
| if (elementIndex == -1) { |
| elementIndex = fDTDGrammar.addElementDecl(fElementQName, contentSpecType, contentSpec, elementDeclIsExternal); |
| //System.out.println("XMLDTDScanner#scanElementDecl->DTDGrammar#addElementDecl: "+elementIndex+" ("+fElementQName.localpart+","+fStringPool.toString(fElementQName.localpart)+')'); |
| } |
| else { |
| //now check if we already add this element Decl by foward reference |
| fDTDGrammar.getElementDecl(elementIndex, fTempElementDecl); |
| if (fTempElementDecl.type == -1) { |
| fTempElementDecl.type = contentSpecType; |
| fTempElementDecl.contentSpecIndex = contentSpec; |
| fDTDGrammar.setElementDeclDTD(elementIndex, fTempElementDecl); |
| fDTDGrammar.setElementDeclIsExternal(elementIndex, elementDeclIsExternal); |
| } |
| else { |
| //REVISIT, valiate VC duplicate element type. |
| if ( fValidationEnabled ) |
| //&& |
| // (elemenetDeclIsExternal==fDTDGrammar.getElementDeclIsExternal(elementIndex) |
| { |
| |
| reportRecoverableXMLError( |
| XMLMessages.MSG_ELEMENT_ALREADY_DECLARED, |
| XMLMessages.VC_UNIQUE_ELEMENT_TYPE_DECLARATION, |
| fStringPool.toString(fElementQName.rawname) |
| ); |
| } |
| } |
| } |
| if (fDTDHandler != null) { |
| fDTDGrammar.getElementDecl(elementIndex, fTempElementDecl); |
| fDTDHandler.elementDecl(fElementDeclQName, contentSpecType, contentSpec, fDTDGrammar); |
| } |
| |
| } // scanElementDecl() |
| |
| |
| /** |
| * Scans mixed content model. Called after scanning past '(' S? '#PCDATA' |
| * <pre> |
| * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | '(' S? '#PCDATA' S? ')' |
| * </pre> |
| */ |
| private int scanMixed(QName element) throws Exception { |
| |
| int valueIndex = -1; // -1 is special value for #PCDATA |
| int prevNodeIndex = -1; |
| boolean starRequired = false; |
| int[] valueSeen = new int[32]; |
| int valueCount = 0; |
| boolean dupAttrType = false; |
| int nodeIndex = -1; |
| |
| while (true) { |
| if (fValidationEnabled) { |
| for (int i=0; i<valueCount;i++) { |
| if ( valueSeen[i] == valueIndex) { |
| dupAttrType = true; |
| break; |
| } |
| } |
| } |
| if (dupAttrType && fValidationEnabled) { |
| reportRecoverableXMLError(XMLMessages.MSG_DUPLICATE_TYPE_IN_MIXED_CONTENT, |
| XMLMessages.VC_NO_DUPLICATE_TYPES, |
| valueIndex); |
| dupAttrType = false; |
| |
| } |
| else { |
| try { |
| valueSeen[valueCount] = valueIndex; |
| } |
| catch (ArrayIndexOutOfBoundsException ae) { |
| int[] newArray = new int[valueSeen.length*2]; |
| System.arraycopy(valueSeen,0,newArray,0,valueSeen.length); |
| valueSeen = newArray; |
| valueSeen[valueCount] = valueIndex; |
| } |
| valueCount++; |
| |
| nodeIndex = fDTDGrammar.addUniqueLeafNode(valueIndex); |
| } |
| |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('|', true)) { |
| if (!fEntityReader.lookingAtChar(')', true)) { |
| reportFatalXMLError(XMLMessages.MSG_CLOSE_PAREN_REQUIRED_IN_MIXED, |
| XMLMessages.P51_CLOSE_PAREN_REQUIRED, |
| element.rawname); |
| return -1; |
| } |
| decreaseParenDepth(); |
| if (nodeIndex == -1) { |
| nodeIndex = prevNodeIndex; |
| } else if (prevNodeIndex != -1) { |
| nodeIndex = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_CHOICE, prevNodeIndex, nodeIndex); |
| } |
| if (fEntityReader.lookingAtChar('*', true)) { |
| nodeIndex = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE, nodeIndex); |
| } else if (starRequired) { |
| reportFatalXMLError(XMLMessages.MSG_MIXED_CONTENT_UNTERMINATED, |
| XMLMessages.P51_UNTERMINATED, |
| fStringPool.toString(element.rawname), |
| fDTDGrammar.getContentSpecNodeAsString(nodeIndex)); |
| return -1; |
| } |
| return nodeIndex; |
| } |
| if (nodeIndex != -1) { |
| if (prevNodeIndex != -1) { |
| nodeIndex = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_CHOICE, prevNodeIndex, nodeIndex); |
| } |
| prevNodeIndex = nodeIndex; |
| } |
| starRequired = true; |
| checkForPEReference(false); |
| checkForElementTypeWithPEReference(fEntityReader, ')', fElementRefQName); |
| valueIndex = fElementRefQName.rawname; |
| if (valueIndex == -1) { |
| reportFatalXMLError(XMLMessages.MSG_ELEMENT_TYPE_REQUIRED_IN_MIXED_CONTENT, |
| XMLMessages.P51_ELEMENT_TYPE_REQUIRED, |
| element.rawname); |
| return -1; |
| } |
| } |
| |
| } // scanMixed(QName):int |
| |
| /** |
| * Scans a children content model. |
| * <pre> |
| * [47] children ::= (choice | seq) ('?' | '*' | '+')? |
| * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' |
| * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' |
| * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? |
| * </pre> |
| */ |
| private int scanChildren(QName element) throws Exception { |
| |
| int depth = 1; |
| initializeContentModelStack(depth); |
| while (true) { |
| if (fEntityReader.lookingAtChar('(', true)) { |
| increaseParenDepth(); |
| checkForPEReference(false); |
| depth++; |
| initializeContentModelStack(depth); |
| continue; |
| } |
| checkForElementTypeWithPEReference(fEntityReader, ')', fElementRefQName); |
| int valueIndex = fElementRefQName.rawname; |
| if (valueIndex == -1) { |
| reportFatalXMLError(XMLMessages.MSG_OPEN_PAREN_OR_ELEMENT_TYPE_REQUIRED_IN_CHILDREN, |
| XMLMessages.P47_OPEN_PAREN_OR_ELEMENT_TYPE_REQUIRED, |
| element.rawname); |
| return -1; |
| } |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_LEAF, valueIndex); |
| if (fEntityReader.lookingAtChar('?', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE, fNodeIndexStack[depth]); |
| } else if (fEntityReader.lookingAtChar('*', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE, fNodeIndexStack[depth]); |
| } else if (fEntityReader.lookingAtChar('+', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE, fNodeIndexStack[depth]); |
| } |
| while (true) { |
| checkForPEReference(false); |
| if (fOpStack[depth] != XMLContentSpec.CONTENTSPECNODE_SEQ && fEntityReader.lookingAtChar('|', true)) { |
| if (fPrevNodeIndexStack[depth] != -1) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(fOpStack[depth], fPrevNodeIndexStack[depth], fNodeIndexStack[depth]); |
| } |
| fPrevNodeIndexStack[depth] = fNodeIndexStack[depth]; |
| fOpStack[depth] = XMLContentSpec.CONTENTSPECNODE_CHOICE; |
| break; |
| } else if (fOpStack[depth] != XMLContentSpec.CONTENTSPECNODE_CHOICE && fEntityReader.lookingAtChar(',', true)) { |
| if (fPrevNodeIndexStack[depth] != -1) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(fOpStack[depth], fPrevNodeIndexStack[depth], fNodeIndexStack[depth]); |
| } |
| fPrevNodeIndexStack[depth] = fNodeIndexStack[depth]; |
| fOpStack[depth] = XMLContentSpec.CONTENTSPECNODE_SEQ; |
| break; |
| } else { |
| if (!fEntityReader.lookingAtChar(')', true)) { |
| reportFatalXMLError(XMLMessages.MSG_CLOSE_PAREN_REQUIRED_IN_CHILDREN, |
| XMLMessages.P47_CLOSE_PAREN_REQUIRED, |
| element.rawname); |
| } |
| decreaseParenDepth(); |
| if (fPrevNodeIndexStack[depth] != -1) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(fOpStack[depth], fPrevNodeIndexStack[depth], fNodeIndexStack[depth]); |
| } |
| int nodeIndex = fNodeIndexStack[depth--]; |
| fNodeIndexStack[depth] = nodeIndex; |
| if (fEntityReader.lookingAtChar('?', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE, fNodeIndexStack[depth]); |
| } else if (fEntityReader.lookingAtChar('*', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE, fNodeIndexStack[depth]); |
| } else if (fEntityReader.lookingAtChar('+', true)) { |
| fNodeIndexStack[depth] = fDTDGrammar.addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE, fNodeIndexStack[depth]); |
| } |
| if (depth == 0) { |
| return fNodeIndexStack[0]; |
| } |
| } |
| } |
| checkForPEReference(false); |
| } |
| |
| } // scanChildren(QName):int |
| |
| // |
| // [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' |
| // [53] AttDef ::= S Name S AttType S DefaultDecl |
| // [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) |
| // |
| private void scanAttlistDecl() throws Exception |
| { |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ELEMENT_TYPE_IN_ATTLISTDECL, |
| XMLMessages.P52_SPACE_REQUIRED); |
| return; |
| } |
| checkForElementTypeWithPEReference(fEntityReader, ' ', fElementQName); |
| int elementTypeIndex = fElementQName.rawname; |
| if (elementTypeIndex == -1) { |
| abortMarkup(XMLMessages.MSG_ELEMENT_TYPE_REQUIRED_IN_ATTLISTDECL, |
| XMLMessages.P52_ELEMENT_TYPE_REQUIRED); |
| return; |
| } |
| int elementIndex = fDTDGrammar.getElementDeclIndex(fElementQName, -1); |
| if (elementIndex == -1) { |
| elementIndex = fDTDGrammar.addElementDecl(fElementQName); |
| //System.out.println("XMLDTDScanner#scanAttListDecl->DTDGrammar#addElementDecl: "+elementIndex+" ("+fElementQName.localpart+","+fStringPool.toString(fElementQName.localpart)+')'); |
| } |
| boolean sawSpace = checkForPEReference(true); |
| if (fEntityReader.lookingAtChar('>', true)) { |
| decreaseMarkupDepth(); |
| return; |
| } |
| // REVISIT - review this code... |
| if (!sawSpace) { |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| } else |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ATTRIBUTE_NAME_IN_ATTDEF, |
| XMLMessages.P53_SPACE_REQUIRED); |
| } else { |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| } |
| } |
| if (fEntityReader.lookingAtChar('>', true)) { |
| decreaseMarkupDepth(); |
| return; |
| } |
| while (true) { |
| checkForAttributeNameWithPEReference(fEntityReader, ' ', fAttributeQName); |
| int attDefName = fAttributeQName.rawname; |
| if (attDefName == -1) { |
| abortMarkup(XMLMessages.MSG_ATTRIBUTE_NAME_REQUIRED_IN_ATTDEF, |
| XMLMessages.P53_NAME_REQUIRED, |
| fElementQName.rawname); |
| return; |
| } |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ATTTYPE_IN_ATTDEF, |
| XMLMessages.P53_SPACE_REQUIRED); |
| return; |
| } |
| int attDefType = -1; |
| boolean attDefList = false; |
| int attDefEnumeration = -1; |
| if (fEntityReader.skippedString(cdata_string)) { |
| attDefType = XMLAttributeDecl.TYPE_CDATA; |
| } else if (fEntityReader.skippedString(id_string)) { |
| if (!fEntityReader.skippedString(ref_string)) { |
| attDefType = XMLAttributeDecl.TYPE_ID; |
| } else if (!fEntityReader.lookingAtChar('S', true)) { |
| attDefType = XMLAttributeDecl.TYPE_IDREF; |
| } else { |
| attDefType = XMLAttributeDecl.TYPE_IDREF; |
| attDefList = true; |
| } |
| } else if (fEntityReader.skippedString(entit_string)) { |
| if (fEntityReader.lookingAtChar('Y', true)) { |
| attDefType = XMLAttributeDecl.TYPE_ENTITY; |
| } else if (fEntityReader.skippedString(ies_string)) { |
| attDefType = XMLAttributeDecl.TYPE_ENTITY; |
| attDefList = true; |
| } else { |
| abortMarkup(XMLMessages.MSG_ATTTYPE_REQUIRED_IN_ATTDEF, |
| XMLMessages.P53_ATTTYPE_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| } else if (fEntityReader.skippedString(nmtoken_string)) { |
| if (fEntityReader.lookingAtChar('S', true)) { |
| attDefType = XMLAttributeDecl.TYPE_NMTOKEN; |
| attDefList = true; |
| } else { |
| attDefType = XMLAttributeDecl.TYPE_NMTOKEN; |
| } |
| } else if (fEntityReader.skippedString(notation_string)) { |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_AFTER_NOTATION_IN_NOTATIONTYPE, |
| XMLMessages.P58_SPACE_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| if (!fEntityReader.lookingAtChar('(', true)) { |
| abortMarkup(XMLMessages.MSG_OPEN_PAREN_REQUIRED_IN_NOTATIONTYPE, |
| XMLMessages.P58_OPEN_PAREN_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| increaseParenDepth(); |
| attDefType = XMLAttributeDecl.TYPE_NOTATION; |
| attDefEnumeration = scanEnumeration(elementTypeIndex, attDefName, true); |
| if (attDefEnumeration == -1) { |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } |
| } else if (fEntityReader.lookingAtChar('(', true)) { |
| increaseParenDepth(); |
| attDefType = XMLAttributeDecl.TYPE_ENUMERATION; |
| attDefEnumeration = scanEnumeration(elementTypeIndex, attDefName, false); |
| if (attDefEnumeration == -1) { |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } |
| } else { |
| abortMarkup(XMLMessages.MSG_ATTTYPE_REQUIRED_IN_ATTDEF, |
| XMLMessages.P53_ATTTYPE_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_DEFAULTDECL_IN_ATTDEF, |
| XMLMessages.P53_SPACE_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| int attDefDefaultType = -1; |
| int attDefDefaultValue = -1; |
| if (fEntityReader.skippedString(required_string)) { |
| attDefDefaultType = XMLAttributeDecl.DEFAULT_TYPE_REQUIRED; |
| } else if (fEntityReader.skippedString(implied_string)) { |
| attDefDefaultType = XMLAttributeDecl.DEFAULT_TYPE_IMPLIED; |
| } else { |
| if (fEntityReader.skippedString(fixed_string)) { |
| if (!fEntityReader.lookingAtSpace(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_AFTER_FIXED_IN_DEFAULTDECL, |
| XMLMessages.P60_SPACE_REQUIRED, |
| elementTypeIndex, attDefName); |
| return; |
| } |
| fEntityReader.skipPastSpaces(); |
| attDefDefaultType = XMLAttributeDecl.DEFAULT_TYPE_FIXED; |
| } else |
| attDefDefaultType = XMLAttributeDecl.DEFAULT_TYPE_DEFAULT; |
| |
| //fElementQName.setValues(-1, elementTypeIndex, elementTypeIndex); |
| |
| // if attribute name has a prefix "xml", bind it to the XML Namespace. |
| // since this is the only pre-defined namespace. |
| /*** |
| if (fAttributeQName.prefix == fXMLSymbol) { |
| fAttributeQName.uri = fXMLNamespace; |
| } |
| else |
| fAttributeQName.setValues(-1, attDefName, attDefName); |
| ****/ |
| |
| attDefDefaultValue = scanDefaultAttValue(fElementQName, fAttributeQName, |
| attDefType, |
| attDefEnumeration); |
| |
| //normalize and check VC: Attribute Default Legal |
| if (attDefDefaultValue != -1 && attDefType != XMLAttributeDecl.TYPE_CDATA ) { |
| attDefDefaultValue = normalizeDefaultAttValue( fAttributeQName, attDefDefaultValue, |
| attDefType, attDefEnumeration, |
| attDefList); |
| } |
| |
| if (attDefDefaultValue == -1) { |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } |
| } |
| if (attDefName == fXMLSpace) { |
| boolean ok = false; |
| if (attDefType == XMLAttributeDecl.TYPE_ENUMERATION) { |
| int index = attDefEnumeration; |
| if (index != -1) { |
| ok = (fStringPool.stringListLength(index) == 1 && |
| (fStringPool.stringInList(index, fDefault) || |
| fStringPool.stringInList(index, fPreserve))) || |
| (fStringPool.stringListLength(index) == 2 && |
| fStringPool.stringInList(index, fDefault) && |
| fStringPool.stringInList(index, fPreserve)); |
| } |
| } |
| if (!ok) { |
| reportFatalXMLError(XMLMessages.MSG_XML_SPACE_DECLARATION_ILLEGAL, |
| XMLMessages.S2_10_DECLARATION_ILLEGAL, |
| elementTypeIndex); |
| } |
| } |
| sawSpace = checkForPEReference(true); |
| |
| // if attribute name has a prefix "xml", bind it to the XML Namespace. |
| // since this is the only pre-defined namespace. |
| if (fAttributeQName.prefix == fXMLSymbol) { |
| fAttributeQName.uri = fXMLNamespace; |
| } |
| |
| if (fEntityReader.lookingAtChar('>', true)) { |
| int attDefIndex = addAttDef(fElementQName, fAttributeQName, |
| attDefType, attDefList, attDefEnumeration, |
| attDefDefaultType, attDefDefaultValue, |
| getReadingExternalEntity()); |
| //System.out.println("XMLDTDScanner#scanAttlistDecl->DTDGrammar#addAttDef: "+attDefIndex+ |
| // " ("+fElementQName.localpart+","+fStringPool.toString(fElementQName.rawname)+')'+ |
| // " ("+fAttributeQName.localpart+","+fStringPool.toString(fAttributeQName.rawname)+')'); |
| decreaseMarkupDepth(); |
| return; |
| } |
| // REVISIT - review this code... |
| if (!sawSpace) { |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| } else |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ATTRIBUTE_NAME_IN_ATTDEF, |
| XMLMessages.P53_SPACE_REQUIRED); |
| } else { |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| } |
| } |
| if (fEntityReader.lookingAtChar('>', true)) { |
| int attDefIndex = addAttDef(fElementQName, fAttributeQName, |
| attDefType, attDefList, attDefEnumeration, |
| attDefDefaultType, attDefDefaultValue, |
| getReadingExternalEntity() ); |
| //System.out.println("XMLDTDScanner#scanAttlistDecl->DTDGrammar#addAttDef: "+attDefIndex+ |
| // " ("+fElementQName.localpart+","+fStringPool.toString(fElementQName.rawname)+')'+ |
| // " ("+fAttributeQName.localpart+","+fStringPool.toString(fAttributeQName.rawname)+')'); |
| decreaseMarkupDepth(); |
| return; |
| } |
| int attDefIndex = addAttDef(fElementQName, fAttributeQName, |
| attDefType, attDefList, attDefEnumeration, |
| attDefDefaultType, attDefDefaultValue, |
| getReadingExternalEntity()); |
| //System.out.println("XMLDTDScanner#scanAttlistDecl->DTDGrammar#addAttDef: "+attDefIndex+ |
| // " ("+fElementQName.localpart+","+fStringPool.toString(fElementQName.rawname)+')'+ |
| // " ("+fAttributeQName.localpart+","+fStringPool.toString(fAttributeQName.rawname)+')'); |
| } |
| } |
| |
| private int addAttDef(QName element, QName attribute, |
| int attDefType, boolean attDefList, int attDefEnumeration, |
| int attDefDefaultType, int attDefDefaultValue, |
| boolean isExternal ) throws Exception { |
| |
| if (fDTDHandler != null) { |
| String enumString = attDefEnumeration != -1 ? fStringPool.stringListAsString(attDefEnumeration) : null; |
| fDTDHandler.attlistDecl(element, attribute, |
| attDefType, attDefList, |
| enumString, |
| attDefDefaultType, attDefDefaultValue); |
| } |
| int elementIndex = fDTDGrammar.getElementDeclIndex(element, -1); |
| if (elementIndex == -1) { |
| // REPORT Internal error here |
| } |
| else { |
| int attlistIndex = fDTDGrammar.getFirstAttributeDeclIndex(elementIndex); |
| int dupID = -1; |
| int dupNotation = -1; |
| while (attlistIndex != -1) { |
| fDTDGrammar.getAttributeDecl(attlistIndex, fTempAttributeDecl); |
| |
| // REVISIT: Validation. Attributes are also tuples. |
| if (fStringPool.equalNames(fTempAttributeDecl.name.rawname, attribute.rawname)) { |
| /****** |
| if (fWarningOnDuplicateAttDef) { |
| Object[] args = { fStringPool.toString(fElementType[elemChunk][elemIndex]), |
| fStringPool.toString(attributeDecl.rawname) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_DUPLICATE_ATTDEF, |
| XMLMessages.P53_DUPLICATE, |
| args, |
| XMLErrorReporter.ERRORTYPE_WARNING); |
| } |
| ******/ |
| return -1; |
| } |
| |
| if (fValidationEnabled) { |
| if (attDefType == XMLAttributeDecl.TYPE_ID && |
| fTempAttributeDecl.type == XMLAttributeDecl.TYPE_ID ) { |
| dupID = fTempAttributeDecl.name.rawname; |
| } |
| if (attDefType == XMLAttributeDecl.TYPE_NOTATION |
| && fTempAttributeDecl.type == XMLAttributeDecl.TYPE_NOTATION) { |
| dupNotation = fTempAttributeDecl.name.rawname; |
| } |
| } |
| attlistIndex = fDTDGrammar.getNextAttributeDeclIndex(attlistIndex); |
| } |
| if (fValidationEnabled) { |
| if (dupID != -1) { |
| Object[] args = { fStringPool.toString(element.rawname), |
| fStringPool.toString(dupID), |
| fStringPool.toString(attribute.rawname) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_MORE_THAN_ONE_ID_ATTRIBUTE, |
| XMLMessages.VC_ONE_ID_PER_ELEMENT_TYPE, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| return -1; |
| } |
| if (dupNotation != -1) { |
| Object[] args = { fStringPool.toString(element.rawname), |
| fStringPool.toString(dupNotation), |
| fStringPool.toString(attribute.rawname) }; |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_MORE_THAN_ONE_NOTATION_ATTRIBUTE, |
| XMLMessages.VC_ONE_NOTATION_PER_ELEMENT_TYPE, |
| args, |
| XMLErrorReporter.ERRORTYPE_RECOVERABLE_ERROR); |
| return -1; |
| } |
| } |
| } |
| return fDTDGrammar.addAttDef(element, attribute, |
| attDefType, attDefList, attDefEnumeration, |
| attDefDefaultType, attDefDefaultValue, |
| isExternal); |
| |
| } |
| // |
| // [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' |
| // [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')' |
| // |
| private int scanEnumeration(int elementType, int attrName, boolean isNotationType) throws Exception |
| { |
| int enumIndex = fDTDGrammar.startEnumeration(); |
| while (true) { |
| checkForPEReference(false); |
| int nameIndex = isNotationType ? |
| checkForNameWithPEReference(fEntityReader, ')') : |
| checkForNmtokenWithPEReference(fEntityReader, ')'); |
| if (nameIndex == -1) { |
| if (isNotationType) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_NOTATIONTYPE, |
| XMLMessages.P58_NAME_REQUIRED, |
| elementType, |
| attrName); |
| } else { |
| reportFatalXMLError(XMLMessages.MSG_NMTOKEN_REQUIRED_IN_ENUMERATION, |
| XMLMessages.P59_NMTOKEN_REQUIRED, |
| elementType, |
| attrName); |
| } |
| fDTDGrammar.endEnumeration(enumIndex); |
| return -1; |
| } |
| fDTDGrammar.addNameToEnumeration(enumIndex, elementType, attrName, nameIndex, isNotationType); |
| /*****/ |
| if (isNotationType && !((DefaultEntityHandler)fEntityHandler).isNotationDeclared(nameIndex)) { |
| Object[] args = { fStringPool.toString(elementType), |
| fStringPool.toString(attrName), |
| fStringPool.toString(nameIndex) }; |
| ((DefaultEntityHandler)fEntityHandler).addRequiredNotation(nameIndex, |
| fErrorReporter.getLocator(), |
| XMLMessages.MSG_NOTATION_NOT_DECLARED_FOR_NOTATIONTYPE_ATTRIBUTE, |
| XMLMessages.VC_NOTATION_DECLARED, |
| args); |
| } |
| /*****/ |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('|', true)) { |
| fDTDGrammar.endEnumeration(enumIndex); |
| if (!fEntityReader.lookingAtChar(')', true)) { |
| if (isNotationType) { |
| reportFatalXMLError(XMLMessages.MSG_NOTATIONTYPE_UNTERMINATED, |
| XMLMessages.P58_UNTERMINATED, |
| elementType, |
| attrName); |
| } else { |
| reportFatalXMLError(XMLMessages.MSG_ENUMERATION_UNTERMINATED, |
| XMLMessages.P59_UNTERMINATED, |
| elementType, |
| attrName); |
| } |
| return -1; |
| } |
| decreaseParenDepth(); |
| return enumIndex; |
| } |
| } |
| } |
| // |
| // [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
| // | "'" ([^<&'] | Reference)* "'" |
| // |
| /** |
| * Scan the default value in an attribute declaration |
| * |
| * @param elementType handle to the element that owns the attribute |
| * @param attrName handle in the string pool for the attribute name |
| * @return handle in the string pool for the default attribute value |
| * @exception java.lang.Exception |
| */ |
| public int scanDefaultAttValue(QName element, QName attribute) throws Exception |
| { |
| boolean single; |
| if (!(single = fEntityReader.lookingAtChar('\'', true)) && !fEntityReader.lookingAtChar('\"', true)) { |
| reportFatalXMLError(XMLMessages.MSG_QUOTE_REQUIRED_IN_ATTVALUE, |
| XMLMessages.P10_QUOTE_REQUIRED, |
| element.rawname, |
| attribute.rawname); |
| return -1; |
| } |
| int previousState = setScannerState(SCANNER_STATE_DEFAULT_ATTRIBUTE_VALUE); |
| char qchar = single ? '\'' : '\"'; |
| fDefaultAttValueReader = fReaderId; |
| fDefaultAttValueElementType = element.rawname; |
| fDefaultAttValueAttrName = attribute.rawname; |
| boolean setMark = true; |
| int dataOffset = fLiteralData.length(); |
| while (true) { |
| fDefaultAttValueOffset = fEntityReader.currentOffset(); |
| if (setMark) { |
| fDefaultAttValueMark = fDefaultAttValueOffset; |
| setMark = false; |
| } |
| if (fEntityReader.lookingAtChar(qchar, true)) { |
| if (fReaderId == fDefaultAttValueReader) |
| break; |
| continue; |
| } |
| if (fEntityReader.lookingAtChar(' ', true)) { |
| continue; |
| } |
| boolean skippedCR; |
| if ((skippedCR = fEntityReader.lookingAtChar((char)0x0D, true)) || fEntityReader.lookingAtSpace(true)) { |
| if (fDefaultAttValueOffset - fDefaultAttValueMark > 0) |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| setMark = true; |
| fLiteralData.append(' '); |
| if (skippedCR) |
| fEntityReader.lookingAtChar((char)0x0A, true); |
| continue; |
| } |
| if (fEntityReader.lookingAtChar('&', true)) { |
| if (fDefaultAttValueOffset - fDefaultAttValueMark > 0) |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| setMark = true; |
| // |
| // Check for character reference first. |
| // |
| if (fEntityReader.lookingAtChar('#', true)) { |
| int ch = scanCharRef(); |
| if (ch != -1) { |
| if (ch < 0x10000) |
| fLiteralData.append((char)ch); |
| else { |
| fLiteralData.append((char)(((ch-0x00010000)>>10)+0xd800)); |
| fLiteralData.append((char)(((ch-0x00010000)&0x3ff)+0xdc00)); |
| } |
| } |
| } else { |
| // |
| // Entity reference |
| // |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_REFERENCE, |
| XMLMessages.P68_NAME_REQUIRED); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_REFERENCE, |
| XMLMessages.P68_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else { |
| int entityNameIndex = fEntityReader.addSymbol(nameOffset, nameLength); |
| fEntityHandler.startReadingFromEntity(entityNameIndex, markupDepth(), XMLEntityHandler.ENTITYREF_IN_DEFAULTATTVALUE); |
| } |
| } |
| continue; |
| } |
| if (fEntityReader.lookingAtChar('<', true)) { |
| if (fDefaultAttValueOffset - fDefaultAttValueMark > 0) |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| setMark = true; |
| reportFatalXMLError(XMLMessages.MSG_LESSTHAN_IN_ATTVALUE, |
| XMLMessages.WFC_NO_LESSTHAN_IN_ATTVALUE, |
| element.rawname, |
| attribute.rawname); |
| continue; |
| } |
| // |
| // REVISIT - HACK !!! code added to pass incorrect OASIS test 'valid-sa-094' |
| // Remove this next section to conform to the spec... |
| // |
| if (!getReadingExternalEntity() && fEntityReader.lookingAtChar('%', true)) { |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength != 0 && fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_PEREFERENCE_WITHIN_MARKUP, |
| XMLMessages.WFC_PES_IN_INTERNAL_SUBSET, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } |
| } |
| // |
| // END HACK !!! |
| // |
| if (!fEntityReader.lookingAtValidChar(true)) { |
| if (fDefaultAttValueOffset - fDefaultAttValueMark > 0) |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| setMark = true; |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| return -1; |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_ATTVALUE, |
| XMLMessages.P10_INVALID_CHARACTER, |
| fStringPool.toString(element.rawname), |
| fStringPool.toString(attribute.rawname), |
| Integer.toHexString(invChar)); |
| } |
| continue; |
| } |
| } |
| restoreScannerState(previousState); |
| int dataLength = fLiteralData.length() - dataOffset; |
| if (dataLength == 0) { |
| return fEntityReader.addString(fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| } |
| if (fDefaultAttValueOffset - fDefaultAttValueMark > 0) { |
| fEntityReader.append(fLiteralData, fDefaultAttValueMark, fDefaultAttValueOffset - fDefaultAttValueMark); |
| dataLength = fLiteralData.length() - dataOffset; |
| } |
| return fLiteralData.addString(dataOffset, dataLength); |
| } |
| // |
| // [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' |
| // |
| private void scanNotationDecl() throws Exception |
| { |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_NOTATION_NAME_IN_NOTATIONDECL, |
| XMLMessages.P82_SPACE_REQUIRED); |
| return; |
| } |
| int notationName = checkForNameWithPEReference(fEntityReader, ' '); |
| if (notationName == -1) { |
| abortMarkup(XMLMessages.MSG_NOTATION_NAME_REQUIRED_IN_NOTATIONDECL, |
| XMLMessages.P82_NAME_REQUIRED); |
| return; |
| } |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_AFTER_NOTATION_NAME_IN_NOTATIONDECL, |
| XMLMessages.P82_SPACE_REQUIRED, |
| notationName); |
| return; |
| } |
| if (!scanExternalID(true)) { |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_NOTATIONDECL_UNTERMINATED, |
| XMLMessages.P82_UNTERMINATED, |
| notationName); |
| return; |
| } |
| decreaseMarkupDepth(); |
| /**** |
| System.out.println(fStringPool.toString(notationName)+"," |
| +fStringPool.toString(fPubidLiteral) + "," |
| +fStringPool.toString(fSystemLiteral) + "," |
| +getReadingExternalEntity()); |
| /****/ |
| |
| int notationIndex = ((DefaultEntityHandler) fEntityHandler).addNotationDecl( notationName, |
| fPubidLiteral, |
| fSystemLiteral, |
| getReadingExternalEntity()); |
| fDTDGrammar.addNotationDecl(notationName, fPubidLiteral, fSystemLiteral); |
| if (fDTDHandler != null) { |
| fDTDHandler.notationDecl(notationName, fPubidLiteral, fSystemLiteral); |
| } |
| } |
| // |
| // [70] EntityDecl ::= GEDecl | PEDecl |
| // [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' |
| // [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' |
| // [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) |
| // [74] PEDef ::= EntityValue | ExternalID |
| // [75] ExternalID ::= 'SYSTEM' S SystemLiteral |
| // | 'PUBLIC' S PubidLiteral S SystemLiteral |
| // [76] NDataDecl ::= S 'NDATA' S Name |
| // [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
| // | "'" ([^%&'] | PEReference | Reference)* "'" |
| // |
| // Called after scanning 'ENTITY' |
| // |
| private void scanEntityDecl() throws Exception |
| { |
| boolean isPEDecl = false; |
| boolean sawPERef = false; |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| if (!fEntityReader.lookingAtChar('%', true)) { |
| isPEDecl = false; // <!ENTITY x "x"> |
| } else if (fEntityReader.lookingAtSpace(true)) { |
| checkForPEReference(false); // <!ENTITY % x "x"> |
| isPEDecl = true; |
| } else if (!getReadingExternalEntity()) { |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ENTITY_NAME_IN_PEDECL, |
| XMLMessages.P72_SPACE); |
| isPEDecl = true; |
| } else if (fEntityReader.lookingAtChar('%', false)) { |
| checkForPEReference(false); // <!ENTITY %%x; "x"> is legal |
| isPEDecl = true; |
| } else { |
| sawPERef = true; |
| } |
| } else if (!getReadingExternalEntity() || !fEntityReader.lookingAtChar('%', true)) { |
| // <!ENTITY[^ ]...> or <!ENTITY[^ %]...> |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_ENTITY_NAME_IN_ENTITYDECL, |
| XMLMessages.P70_SPACE); |
| isPEDecl = false; |
| } else if (fEntityReader.lookingAtSpace(false)) { |
| // <!ENTITY% ...> |
| reportFatalXMLError(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_PERCENT_IN_PEDECL, |
| XMLMessages.P72_SPACE); |
| isPEDecl = false; |
| } else { |
| sawPERef = true; |
| } |
| if (sawPERef) { |
| while (true) { |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_NAME_REQUIRED); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else { |
| int peNameIndex = fEntityReader.addSymbol(nameOffset, nameLength); |
| int readerDepth = (fScannerState == SCANNER_STATE_CONTENTSPEC) ? parenDepth() : markupDepth(); |
| fEntityHandler.startReadingFromEntity(peNameIndex, readerDepth, XMLEntityHandler.ENTITYREF_IN_DTD_WITHIN_MARKUP); |
| } |
| fEntityReader.skipPastSpaces(); |
| if (!fEntityReader.lookingAtChar('%', true)) |
| break; |
| if (!isPEDecl) { |
| if (fEntityReader.lookingAtSpace(true)) { |
| checkForPEReference(false); |
| isPEDecl = true; |
| break; |
| } |
| isPEDecl = fEntityReader.lookingAtChar('%', true); |
| } |
| } |
| } |
| int entityName = checkForNameWithPEReference(fEntityReader, ' '); |
| if (entityName == -1) { |
| abortMarkup(XMLMessages.MSG_ENTITY_NAME_REQUIRED_IN_ENTITYDECL, |
| XMLMessages.P70_REQUIRED_NAME); |
| return; |
| } |
| if (!fDTDGrammar.startEntityDecl(isPEDecl, entityName)) { |
| skipPastEndOfCurrentMarkup(); |
| return; |
| } |
| if (!checkForPEReference(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_AFTER_ENTITY_NAME_IN_ENTITYDECL, |
| XMLMessages.P70_REQUIRED_SPACE, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| if (isPEDecl) { |
| boolean single; |
| if ((single = fEntityReader.lookingAtChar('\'', true)) || fEntityReader.lookingAtChar('\"', true)) { |
| int value = scanEntityValue(single); |
| if (value == -1) { |
| skipPastEndOfCurrentMarkup(); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ENTITYDECL_UNTERMINATED, |
| XMLMessages.P72_UNTERMINATED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.endEntityDecl(); |
| |
| // a hack by Eric |
| //REVISIT |
| fDTDGrammar.addInternalPEDecl(entityName, value); |
| if (fDTDHandler != null) { |
| fDTDHandler.internalPEDecl(entityName, value); |
| } |
| int entityIndex = ((DefaultEntityHandler) fEntityHandler).addInternalPEDecl(entityName, |
| value, |
| getReadingExternalEntity()); |
| |
| } else { |
| if (!scanExternalID(false)) { |
| skipPastEndOfCurrentMarkup(); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ENTITYDECL_UNTERMINATED, |
| XMLMessages.P72_UNTERMINATED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.endEntityDecl(); |
| |
| //a hack by Eric |
| //REVISIT |
| fDTDGrammar.addExternalPEDecl(entityName, fPubidLiteral, fSystemLiteral); |
| if (fDTDHandler != null) { |
| fDTDHandler.externalPEDecl(entityName, fPubidLiteral, fSystemLiteral); |
| } |
| int entityIndex = ((DefaultEntityHandler) fEntityHandler).addExternalPEDecl(entityName, |
| fPubidLiteral, |
| fSystemLiteral, getReadingExternalEntity()); |
| } |
| } else { |
| boolean single; |
| if ((single = fEntityReader.lookingAtChar('\'', true)) || fEntityReader.lookingAtChar('\"', true)) { |
| int value = scanEntityValue(single); |
| if (value == -1) { |
| skipPastEndOfCurrentMarkup(); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ENTITYDECL_UNTERMINATED, |
| XMLMessages.P71_UNTERMINATED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.endEntityDecl(); |
| |
| //a hack by Eric |
| //REVISIT |
| fDTDGrammar.addInternalEntityDecl(entityName, value); |
| if (fDTDHandler != null) { |
| fDTDHandler.internalEntityDecl(entityName, value); |
| } |
| int entityIndex = ((DefaultEntityHandler) fEntityHandler).addInternalEntityDecl(entityName, |
| value, |
| getReadingExternalEntity()); |
| } else { |
| if (!scanExternalID(false)) { |
| skipPastEndOfCurrentMarkup(); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| boolean unparsed = false; |
| if (fEntityReader.lookingAtSpace(true)) { |
| fEntityReader.skipPastSpaces(); |
| unparsed = fEntityReader.skippedString(ndata_string); |
| } |
| if (!unparsed) { |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ENTITYDECL_UNTERMINATED, |
| XMLMessages.P72_UNTERMINATED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.endEntityDecl(); |
| |
| //a hack by Eric |
| //REVISIT |
| fDTDGrammar.addExternalEntityDecl(entityName, fPubidLiteral, fSystemLiteral); |
| if (fDTDHandler != null) { |
| fDTDHandler.externalEntityDecl(entityName, fPubidLiteral, fSystemLiteral); |
| } |
| int entityIndex = ((DefaultEntityHandler) fEntityHandler).addExternalEntityDecl(entityName, |
| fPubidLiteral, |
| fSystemLiteral, |
| getReadingExternalEntity()); |
| |
| } else { |
| if (!fEntityReader.lookingAtSpace(true)) { |
| abortMarkup(XMLMessages.MSG_SPACE_REQUIRED_BEFORE_NOTATION_NAME_IN_UNPARSED_ENTITYDECL, |
| XMLMessages.P76_SPACE_REQUIRED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| fEntityReader.skipPastSpaces(); |
| int ndataOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName('>'); |
| int ndataLength = fEntityReader.currentOffset() - ndataOffset; |
| if (ndataLength == 0) { |
| abortMarkup(XMLMessages.MSG_NOTATION_NAME_REQUIRED_FOR_UNPARSED_ENTITYDECL, |
| XMLMessages.P76_REQUIRED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| int notationName = fEntityReader.addSymbol(ndataOffset, ndataLength); |
| checkForPEReference(false); |
| if (!fEntityReader.lookingAtChar('>', true)) { |
| abortMarkup(XMLMessages.MSG_ENTITYDECL_UNTERMINATED, |
| XMLMessages.P72_UNTERMINATED, |
| entityName); |
| fDTDGrammar.endEntityDecl(); |
| return; |
| } |
| decreaseMarkupDepth(); |
| fDTDGrammar.endEntityDecl(); |
| |
| //a hack by Eric |
| //REVISIT |
| fDTDGrammar.addUnparsedEntityDecl(entityName, fPubidLiteral, fSystemLiteral, notationName); |
| if (fDTDHandler != null) { |
| fDTDHandler.unparsedEntityDecl(entityName, fPubidLiteral, fSystemLiteral, notationName); |
| } |
| /**** |
| System.out.println("----addUnparsedEntity--- "+ fStringPool.toString(entityName)+"," |
| +fStringPool.toString(notationName)+"," |
| +fStringPool.toString(fPubidLiteral) + "," |
| +fStringPool.toString(fSystemLiteral) + "," |
| +getReadingExternalEntity()); |
| /****/ |
| int entityIndex = ((DefaultEntityHandler) fEntityHandler).addUnparsedEntityDecl(entityName, |
| fPubidLiteral, |
| fSystemLiteral, |
| notationName, |
| getReadingExternalEntity()); |
| } |
| } |
| } |
| } |
| // |
| // [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
| // | "'" ([^%&'] | PEReference | Reference)* "'" |
| // |
| private int scanEntityValue(boolean single) throws Exception |
| { |
| char qchar = single ? '\'' : '\"'; |
| fEntityValueMark = fEntityReader.currentOffset(); |
| int entityValue = fEntityReader.scanEntityValue(qchar, true); |
| if (entityValue < 0) |
| entityValue = scanComplexEntityValue(qchar, entityValue); |
| return entityValue; |
| } |
| private int scanComplexEntityValue(char qchar, int result) throws Exception |
| { |
| int previousState = setScannerState(SCANNER_STATE_ENTITY_VALUE); |
| fEntityValueReader = fReaderId; |
| int dataOffset = fLiteralData.length(); |
| while (true) { |
| switch (result) { |
| case XMLEntityHandler.ENTITYVALUE_RESULT_FINISHED: |
| { |
| int offset = fEntityReader.currentOffset(); |
| fEntityReader.lookingAtChar(qchar, true); |
| restoreScannerState(previousState); |
| int dataLength = fLiteralData.length() - dataOffset; |
| if (dataLength == 0) { |
| return fEntityReader.addString(fEntityValueMark, offset - fEntityValueMark); |
| } |
| if (offset - fEntityValueMark > 0) { |
| fEntityReader.append(fLiteralData, fEntityValueMark, offset - fEntityValueMark); |
| dataLength = fLiteralData.length() - dataOffset; |
| } |
| return fLiteralData.addString(dataOffset, dataLength); |
| } |
| case XMLEntityHandler.ENTITYVALUE_RESULT_REFERENCE: |
| { |
| int offset = fEntityReader.currentOffset(); |
| if (offset - fEntityValueMark > 0) |
| fEntityReader.append(fLiteralData, fEntityValueMark, offset - fEntityValueMark); |
| fEntityReader.lookingAtChar('&', true); |
| // |
| // Check for character reference first. |
| // |
| if (fEntityReader.lookingAtChar('#', true)) { |
| int ch = scanCharRef(); |
| if (ch != -1) { |
| if (ch < 0x10000) |
| fLiteralData.append((char)ch); |
| else { |
| fLiteralData.append((char)(((ch-0x00010000)>>10)+0xd800)); |
| fLiteralData.append((char)(((ch-0x00010000)&0x3ff)+0xdc00)); |
| } |
| } |
| fEntityValueMark = fEntityReader.currentOffset(); |
| } else { |
| // |
| // Entity reference |
| // |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_REFERENCE, |
| XMLMessages.P68_NAME_REQUIRED); |
| fEntityValueMark = fEntityReader.currentOffset(); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_REFERENCE, |
| XMLMessages.P68_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| fEntityValueMark = fEntityReader.currentOffset(); |
| } else { |
| // |
| // 4.4.7 Bypassed |
| // |
| // When a general entity reference appears in the EntityValue in an |
| // entity declaration, it is bypassed and left as is. |
| // |
| fEntityValueMark = offset; |
| } |
| } |
| break; |
| } |
| case XMLEntityHandler.ENTITYVALUE_RESULT_PEREF: |
| { |
| int offset = fEntityReader.currentOffset(); |
| if (offset - fEntityValueMark > 0) |
| fEntityReader.append(fLiteralData, fEntityValueMark, offset - fEntityValueMark); |
| fEntityReader.lookingAtChar('%', true); |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_NAME_REQUIRED); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else if (!getReadingExternalEntity()) { |
| reportFatalXMLError(XMLMessages.MSG_PEREFERENCE_WITHIN_MARKUP, |
| XMLMessages.WFC_PES_IN_INTERNAL_SUBSET, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else { |
| int peNameIndex = fEntityReader.addSymbol(nameOffset, nameLength); |
| fEntityHandler.startReadingFromEntity(peNameIndex, markupDepth(), XMLEntityHandler.ENTITYREF_IN_ENTITYVALUE); |
| } |
| fEntityValueMark = fEntityReader.currentOffset(); |
| break; |
| } |
| case XMLEntityHandler.ENTITYVALUE_RESULT_INVALID_CHAR: |
| { |
| int offset = fEntityReader.currentOffset(); |
| if (offset - fEntityValueMark > 0) |
| fEntityReader.append(fLiteralData, fEntityValueMark, offset - fEntityValueMark); |
| int invChar = fEntityReader.scanInvalidChar(); |
| if (fScannerState == SCANNER_STATE_END_OF_INPUT) |
| return -1; |
| if (invChar >= 0) { |
| reportFatalXMLError(XMLMessages.MSG_INVALID_CHAR_IN_ENTITYVALUE, |
| XMLMessages.P9_INVALID_CHARACTER, |
| Integer.toHexString(invChar)); |
| } |
| fEntityValueMark = fEntityReader.currentOffset(); |
| break; |
| } |
| case XMLEntityHandler.ENTITYVALUE_RESULT_END_OF_INPUT: |
| // all the work is done by the previous reader, just invoke the next one now. |
| break; |
| default: |
| break; |
| } |
| result = fEntityReader.scanEntityValue(fReaderId == fEntityValueReader ? qchar : -1, false); |
| } |
| } |
| // |
| // |
| // |
| private boolean checkForPEReference(boolean spaceRequired) throws Exception |
| { |
| boolean sawSpace = true; |
| if (spaceRequired) |
| sawSpace = fEntityReader.lookingAtSpace(true); |
| fEntityReader.skipPastSpaces(); |
| if (!getReadingExternalEntity()) |
| return sawSpace; |
| if (!fEntityReader.lookingAtChar('%', true)) |
| return sawSpace; |
| while (true) { |
| int nameOffset = fEntityReader.currentOffset(); |
| fEntityReader.skipPastName(';'); |
| int nameLength = fEntityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) { |
| reportFatalXMLError(XMLMessages.MSG_NAME_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_NAME_REQUIRED); |
| } else if (!fEntityReader.lookingAtChar(';', true)) { |
| reportFatalXMLError(XMLMessages.MSG_SEMICOLON_REQUIRED_IN_PEREFERENCE, |
| XMLMessages.P69_SEMICOLON_REQUIRED, |
| fEntityReader.addString(nameOffset, nameLength)); |
| } else { |
| int peNameIndex = fEntityReader.addSymbol(nameOffset, nameLength); |
| int readerDepth = (fScannerState == SCANNER_STATE_CONTENTSPEC) ? parenDepth() : markupDepth(); |
| fEntityHandler.startReadingFromEntity(peNameIndex, readerDepth, XMLEntityHandler.ENTITYREF_IN_DTD_WITHIN_MARKUP); |
| } |
| fEntityReader.skipPastSpaces(); |
| if (!fEntityReader.lookingAtChar('%', true)) |
| return true; |
| } |
| } |
| // |
| // content model stack |
| // |
| private void initializeContentModelStack(int depth) { |
| if (fOpStack == null) { |
| fOpStack = new int[8]; |
| fNodeIndexStack = new int[8]; |
| fPrevNodeIndexStack = new int[8]; |
| } else if (depth == fOpStack.length) { |
| int[] newStack = new int[depth * 2]; |
| System.arraycopy(fOpStack, 0, newStack, 0, depth); |
| fOpStack = newStack; |
| newStack = new int[depth * 2]; |
| System.arraycopy(fNodeIndexStack, 0, newStack, 0, depth); |
| fNodeIndexStack = newStack; |
| newStack = new int[depth * 2]; |
| System.arraycopy(fPrevNodeIndexStack, 0, newStack, 0, depth); |
| fPrevNodeIndexStack = newStack; |
| } |
| fOpStack[depth] = -1; |
| fNodeIndexStack[depth] = -1; |
| fPrevNodeIndexStack[depth] = -1; |
| } |
| |
| private boolean validVersionNum(String version) { |
| return XMLCharacterProperties.validVersionNum(version); |
| } |
| |
| private boolean validEncName(String encoding) { |
| return XMLCharacterProperties.validEncName(encoding); |
| } |
| |
| private int validPublicId(String publicId) { |
| return XMLCharacterProperties.validPublicId(publicId); |
| } |
| |
| private void scanElementType(XMLEntityHandler.EntityReader entityReader, |
| char fastchar, QName element) throws Exception { |
| |
| if (!fNamespacesEnabled) { |
| element.clear(); |
| element.localpart = entityReader.scanName(fastchar); |
| element.rawname = element.localpart; |
| return; |
| } |
| entityReader.scanQName(fastchar, element); |
| if (entityReader.lookingAtChar(':', false)) { |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_TWO_COLONS_IN_QNAME, |
| XMLMessages.P5_INVALID_CHARACTER, |
| null, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| entityReader.skipPastNmtoken(' '); |
| } |
| |
| } // scanElementType(XMLEntityHandler.EntityReader,char,QName) |
| |
| public void checkForElementTypeWithPEReference(XMLEntityHandler.EntityReader entityReader, |
| char fastchar, QName element) throws Exception { |
| |
| if (!fNamespacesEnabled) { |
| element.clear(); |
| element.localpart = entityReader.scanName(fastchar); |
| element.rawname = element.localpart; |
| return; |
| } |
| entityReader.scanQName(fastchar, element); |
| if (entityReader.lookingAtChar(':', false)) { |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_TWO_COLONS_IN_QNAME, |
| XMLMessages.P5_INVALID_CHARACTER, |
| null, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| entityReader.skipPastNmtoken(' '); |
| } |
| |
| } // checkForElementTypeWithPEReference(XMLEntityHandler.EntityReader,char,QName) |
| |
| public void checkForAttributeNameWithPEReference(XMLEntityHandler.EntityReader entityReader, |
| char fastchar, QName attribute) throws Exception { |
| |
| if (!fNamespacesEnabled) { |
| attribute.clear(); |
| attribute.localpart = entityReader.scanName(fastchar); |
| attribute.rawname = attribute.localpart; |
| return; |
| } |
| |
| entityReader.scanQName(fastchar, attribute); |
| if (entityReader.lookingAtChar(':', false)) { |
| fErrorReporter.reportError(fErrorReporter.getLocator(), |
| XMLMessages.XML_DOMAIN, |
| XMLMessages.MSG_TWO_COLONS_IN_QNAME, |
| XMLMessages.P5_INVALID_CHARACTER, |
| null, |
| XMLErrorReporter.ERRORTYPE_FATAL_ERROR); |
| entityReader.skipPastNmtoken(' '); |
| } |
| |
| } // checkForAttributeNameWithPEReference(XMLEntityHandler.EntityReader,char,QName) |
| |
| public int checkForNameWithPEReference(XMLEntityHandler.EntityReader entityReader, char fastcheck) throws Exception { |
| // |
| // REVISIT - what does this have to do with PE references? |
| // |
| int valueIndex = entityReader.scanName(fastcheck); |
| return valueIndex; |
| } |
| |
| public int checkForNmtokenWithPEReference(XMLEntityHandler.EntityReader entityReader, char fastcheck) throws Exception { |
| // |
| // REVISIT - what does this have to do with PE references? |
| // |
| int nameOffset = entityReader.currentOffset(); |
| entityReader.skipPastNmtoken(fastcheck); |
| int nameLength = entityReader.currentOffset() - nameOffset; |
| if (nameLength == 0) |
| return -1; |
| int valueIndex = entityReader.addSymbol(nameOffset, nameLength); |
| return valueIndex; |
| } |
| |
| public int scanDefaultAttValue(QName element, QName attribute, |
| int attType, int enumeration) throws Exception { |
| /***/ |
| if (fValidationEnabled && attType == XMLAttributeDecl.TYPE_ID) { |
| reportRecoverableXMLError(XMLMessages.MSG_ID_DEFAULT_TYPE_INVALID, |
| XMLMessages.VC_ID_ATTRIBUTE_DEFAULT, |
| fStringPool.toString(attribute.rawname)); |
| } |
| /***/ |
| int defaultAttValue = scanDefaultAttValue(element, attribute); |
| if (defaultAttValue == -1) |
| return -1; |
| // REVISIT |
| /*** |
| if (attType != fCDATASymbol) { |
| // REVISIT: Validation. Should we pass in the element or is this |
| // default attribute value normalization? |
| defaultAttValue = fValidator.normalizeAttValue(null, attribute, defaultAttValue, attType, enumeration); |
| } |
| /***/ |
| return defaultAttValue; |
| } |
| |
| public int normalizeDefaultAttValue( QName attribute, int defaultAttValue, |
| int attType, int enumeration, |
| boolean list) throws Exception { |
| // |
| // Normalize attribute based upon attribute type... |
| // |
| String attValue = fStringPool.toString(defaultAttValue); |
| |
| if (list) { |
| StringTokenizer tokenizer = new StringTokenizer(attValue); |
| StringBuffer sb = new StringBuffer(attValue.length()); |
| boolean ok = true; |
| if (tokenizer.hasMoreTokens()) { |
| while (true) { |
| String nmtoken = tokenizer.nextToken(); |
| if (attType == XMLAttributeDecl.TYPE_NMTOKEN) { |
| if (fValidationEnabled && !XMLCharacterProperties.validNmtoken(nmtoken)) { |
| ok = false; |
| } |
| } |
| else if (attType == XMLAttributeDecl.TYPE_IDREF || attType == XMLAttributeDecl.TYPE_ENTITY) { |
| if (fValidationEnabled && !XMLCharacterProperties.validName(nmtoken)) { |
| ok = false; |
| } |
| // REVISIT: a Hack!!! THis is to pass SUN test /invalid/attr11.xml and attr12.xml |
| // not consistent with XML1.0 spec VC: Attribute Default Legal |
| if (fValidationEnabled && attType == XMLAttributeDecl.TYPE_ENTITY) |
| if (! ((DefaultEntityHandler) fEntityHandler).isUnparsedEntity(defaultAttValue)) { |
| reportRecoverableXMLError(XMLMessages.MSG_ENTITY_INVALID, |
| XMLMessages.VC_ENTITY_NAME, |
| fStringPool.toString(attribute.rawname), nmtoken); |
| } |
| |
| } |
| sb.append(nmtoken); |
| if (!tokenizer.hasMoreTokens()) { |
| break; |
| } |
| sb.append(' '); |
| } |
| } |
| String newAttValue = sb.toString(); |
| if (fValidationEnabled && (!ok || newAttValue.length() == 0)) { |
| reportRecoverableXMLError(XMLMessages.MSG_ATT_DEFAULT_INVALID, |
| XMLMessages.VC_ATTRIBUTE_DEFAULT_LEGAL, |
| fStringPool.toString(attribute.rawname), newAttValue); |
| } |
| if (!newAttValue.equals(attValue)) { |
| defaultAttValue = fStringPool.addString(newAttValue); |
| } |
| return defaultAttValue; |
| } |
| else { |
| String newAttValue = attValue.trim(); |
| |
| if (fValidationEnabled) { |
| // REVISIT - can we release the old string? |
| if (newAttValue != attValue) { |
| defaultAttValue = fStringPool.addSymbol(newAttValue); |
| } |
| else { |
| defaultAttValue = fStringPool.addSymbol(defaultAttValue); |
| } |
| if (attType == XMLAttributeDecl.TYPE_ENTITY || |
| attType == XMLAttributeDecl.TYPE_ID || |
| attType == XMLAttributeDecl.TYPE_IDREF || |
| attType == XMLAttributeDecl.TYPE_NOTATION) { |
| |
| // REVISIT: A Hack!!! THis is to pass SUN test /invalid/attr11.xml and attr12.xml |
| // not consistent with XML1.0 spec VC: Attribute Default Legal |
| if (attType == XMLAttributeDecl.TYPE_ENTITY) |
| if (! ((DefaultEntityHandler) fEntityHandler).isUnparsedEntity(defaultAttValue)) { |
| reportRecoverableXMLError(XMLMessages.MSG_ENTITY_INVALID, |
| XMLMessages.VC_ENTITY_NAME, |
| fStringPool.toString(attribute.rawname), newAttValue); |
| } |
| |
| if (!XMLCharacterProperties.validName(newAttValue)) { |
| reportRecoverableXMLError(XMLMessages.MSG_ATT_DEFAULT_INVALID, |
| XMLMessages.VC_ATTRIBUTE_DEFAULT_LEGAL, |
| fStringPool.toString(attribute.rawname), newAttValue); |
| } |
| |
| } |
| else if (attType == XMLAttributeDecl.TYPE_NMTOKEN || |
| attType == XMLAttributeDecl.TYPE_ENUMERATION ) { |
| |
| if (!XMLCharacterProperties.validNmtoken(newAttValue)) { |
| reportRecoverableXMLError(XMLMessages.MSG_ATT_DEFAULT_INVALID, |
| XMLMessages.VC_ATTRIBUTE_DEFAULT_LEGAL, |
| fStringPool.toString(attribute.rawname), newAttValue); |
| } |
| } |
| |
| if (attType == XMLAttributeDecl.TYPE_NOTATION || |
| attType == XMLAttributeDecl.TYPE_ENUMERATION ) { |
| |
| if ( !fStringPool.stringInList(enumeration, defaultAttValue) ) { |
| reportRecoverableXMLError(XMLMessages.MSG_ATT_DEFAULT_INVALID, |
| XMLMessages.VC_ATTRIBUTE_DEFAULT_LEGAL, |
| fStringPool.toString(attribute.rawname), newAttValue); |
| } |
| } |
| |
| } |
| else if (newAttValue != attValue) { |
| // REVISIT - can we release the old string? |
| defaultAttValue = fStringPool.addSymbol(newAttValue); |
| } |
| } |
| |
| return defaultAttValue; |
| } |
| /*** |
| public boolean scanDoctypeDecl(boolean standalone) throws Exception { |
| fStandaloneReader = standalone ? fEntityHandler.getReaderId() : -1; |
| fDeclsAreExternal = false; |
| if (!fDTDScanner.scanDoctypeDecl()) { |
| return false; |
| } |
| if (fDTDScanner.getReadingExternalEntity()) { |
| fDTDScanner.scanDecls(true); |
| } |
| fDTDHandler.endDTD(); |
| return true; |
| } |
| /***/ |
| |
| } // class XMLDTDScanner |
