| /* Copyright 2004 The Apache Software Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.xmlbeans.impl.newstore2; |
| |
| import org.xml.sax.Locator; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.ext.LexicalHandler; |
| import org.xml.sax.SAXParseException; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.SAXException; |
| |
| import java.util.HashMap; |
| |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.Reference; |
| import java.lang.ref.PhantomReference; |
| |
| import java.lang.reflect.Method; |
| |
| import javax.xml.parsers.SAXParserFactory; |
| |
| import java.io.InputStream; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.io.IOException; |
| |
| import javax.xml.stream.XMLStreamReader; |
| |
| import org.apache.xmlbeans.xml.stream.XMLInputStream; |
| import org.apache.xmlbeans.xml.stream.XMLStreamException; |
| |
| import org.w3c.dom.DOMImplementation; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentType; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Element; |
| |
| import javax.xml.namespace.QName; |
| |
| import org.apache.xmlbeans.impl.common.QNameHelper; |
| import org.apache.xmlbeans.impl.common.XmlLocale; |
| import org.apache.xmlbeans.impl.common.ResolverUtil; |
| |
| import org.apache.xmlbeans.impl.newstore2.Saaj.SaajCallback; |
| |
| import org.apache.xmlbeans.impl.newstore2.DomImpl.Dom; |
| import org.apache.xmlbeans.impl.newstore2.DomImpl.TextNode; |
| import org.apache.xmlbeans.impl.newstore2.DomImpl.CdataNode; |
| import org.apache.xmlbeans.impl.newstore2.DomImpl.SaajTextNode; |
| import org.apache.xmlbeans.impl.newstore2.DomImpl.SaajCdataNode; |
| |
| import org.apache.xmlbeans.impl.newstore2.Cur.Locations; |
| |
| import org.apache.xmlbeans.XmlBeans; |
| import org.apache.xmlbeans.XmlSaxHandler; |
| import org.apache.xmlbeans.XmlException; |
| import org.apache.xmlbeans.XmlObject; |
| import org.apache.xmlbeans.XmlOptions; |
| import org.apache.xmlbeans.SchemaType; |
| import org.apache.xmlbeans.SchemaTypeLoader; |
| import org.apache.xmlbeans.XmlTokenSource; |
| import org.apache.xmlbeans.XmlOptions; |
| import org.apache.xmlbeans.QNameSet; |
| import org.apache.xmlbeans.QNameCache; |
| import org.apache.xmlbeans.XmlBeans; |
| import org.apache.xmlbeans.XmlError; |
| import org.apache.xmlbeans.XmlRuntimeException; |
| import org.apache.xmlbeans.XmlDocumentProperties; |
| |
| import javax.xml.namespace.QName; |
| |
| import org.apache.xmlbeans.impl.values.TypeStore; |
| import org.apache.xmlbeans.impl.values.TypeStoreUser; |
| import org.apache.xmlbeans.impl.values.TypeStoreUserFactory; |
| |
| public final class Locale implements DOMImplementation, SaajCallback, XmlLocale |
| { |
| static final int ROOT = Cur.ROOT; |
| static final int ELEM = Cur.ELEM; |
| static final int ATTR = Cur.ATTR; |
| static final int COMMENT = Cur.COMMENT; |
| static final int PROCINST = Cur.PROCINST; |
| static final int TEXT = Cur.TEXT; |
| |
| static final int WS_UNSPECIFIED = TypeStore.WS_UNSPECIFIED; |
| static final int WS_PRESERVE = TypeStore.WS_PRESERVE; |
| static final int WS_REPLACE = TypeStore.WS_REPLACE; |
| static final int WS_COLLAPSE = TypeStore.WS_COLLAPSE; |
| |
| static final String _xsi = "http://www.w3.org/2001/XMLSchema-instance"; |
| static final String _schema = "http://www.w3.org/2001/XMLSchema"; |
| static final String _openFragUri = "http://www.openuri.org/fragment"; |
| static final String _xml1998Uri = "http://www.w3.org/XML/1998/namespace"; |
| static final String _xmlnsUri = "http://www.w3.org/2000/xmlns/"; |
| |
| static final QName _xsiNil = new QName( _xsi, "nil", "xsi" ); |
| static final QName _xsiType = new QName( _xsi, "type", "xsi" ); |
| static final QName _xsiLoc = new QName( _xsi, "schemaLocation", "xsi" ); |
| static final QName _xsiNoLoc = new QName( _xsi, "noNamespaceSchemaLocation", "xsi" ); |
| static final QName _openuriFragment = new QName( _openFragUri, "fragment", "frag" ); |
| static final QName _xmlFragment = new QName( "xml-fragment" ); |
| |
| private Locale ( SchemaTypeLoader stl, XmlOptions options ) |
| { |
| options = XmlOptions.maskNull( options ); |
| |
| // |
| // |
| // |
| |
| // TODO - add option for no=sync, or make it all thread safe |
| // |
| // Also - have a thread local setting for thread safety? .. Perhaps something |
| // in the type loader which defines whether ot not sync is on???? |
| |
| _noSync = true; |
| |
| _tempFrames = new Cur [ _numTempFramesLeft = 8 ]; |
| |
| // BUGBUG - this cannot be thread locale .... |
| // BUGBUG - this cannot be thread locale .... |
| // BUGBUG - this cannot be thread locale .... |
| // |
| // Lazy create this (loading up a locale should use the thread locale one) |
| // same goes for the qname factory .. use thread local for hte most part when loading |
| |
| _charUtil = CharUtil.getThreadLocalCharUtil(); |
| |
| _qnameFactory = new DefaultQNameFactory(); |
| |
| _locations = new Locations(); |
| |
| _schemaTypeLoader = stl; |
| |
| _validateOnSet = options.hasOption( XmlOptions.VALIDATE_ON_SET ); |
| |
| // |
| // Check for Saaj implementation request |
| // |
| |
| Object saajObj = options.get( Public2.SAAJ_IMPL ); |
| |
| if (saajObj != null) |
| { |
| if (!(saajObj instanceof Saaj)) |
| throw new IllegalStateException( "Saaj impl not correct type: " + saajObj ); |
| |
| _saaj = (Saaj) saajObj; |
| |
| _saaj.setCallback( this ); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| public static final String USE_SAME_LOCALE = "USE_SAME_LOCALE"; |
| |
| static Locale getLocale ( SchemaTypeLoader stl, XmlOptions options ) |
| { |
| if (stl == null) |
| stl = XmlBeans.getContextTypeLoader(); |
| |
| options = XmlOptions.maskNull( options ); |
| |
| Locale l = null; |
| |
| if (options.hasOption( USE_SAME_LOCALE )) |
| { |
| Object source = options.get( USE_SAME_LOCALE ); |
| |
| if (source instanceof Locale) |
| l = (Locale) source; |
| else if (source instanceof XmlTokenSource) |
| l = (Locale) ((XmlTokenSource) source).monitor(); |
| else |
| throw new IllegalArgumentException( "Source locale not understood: " + source ); |
| |
| if (l._schemaTypeLoader != stl) |
| throw new IllegalArgumentException( "Source locale does not support same schema type loader" ); |
| |
| if (l._saaj != null && l._saaj != options.get( Public2.SAAJ_IMPL )) |
| throw new IllegalArgumentException( "Source locale does not support same saaj" ); |
| |
| if (l._validateOnSet && !options.hasOption( XmlOptions.VALIDATE_ON_SET )) |
| throw new IllegalArgumentException( "Source locale does not support same validate on set" ); |
| |
| // TODO - other things to check? |
| } |
| else |
| l = new Locale( stl, options ); |
| |
| return l; |
| } |
| |
| // |
| // |
| // |
| |
| private void autoTypeDocument ( Cur c, SchemaType requestedType, XmlOptions options ) |
| throws XmlException |
| { |
| assert c.isRoot(); |
| |
| // The type in the options overrides all sniffing |
| |
| options = XmlOptions.maskNull( options ); |
| |
| SchemaType optionType = (SchemaType) options.get( XmlOptions.DOCUMENT_TYPE ); |
| |
| if (optionType != null) |
| { |
| c.setType( optionType ); |
| return; |
| } |
| |
| SchemaType type = null; |
| |
| // An xsi:type can be used to pick a type out of the loader, or used to refine |
| // a type with a name. |
| |
| if (requestedType == null || requestedType.getName() != null) |
| { |
| QName xsiTypeName = c.getXsiTypeName(); |
| |
| SchemaType xsiSchemaType = |
| xsiTypeName == null ? null : _schemaTypeLoader.findType( xsiTypeName ); |
| |
| if (requestedType == null || requestedType.isAssignableFrom( xsiSchemaType )) |
| type = xsiSchemaType; |
| } |
| |
| // Look for a document element to establish type |
| |
| if (type == null && (requestedType == null || requestedType.isDocumentType())) |
| { |
| assert c.isRoot(); |
| |
| c.push(); |
| |
| QName docElemName = |
| !c.hasAttrs() && Locale.toFirstChildElement( c ) && |
| !Locale.toNextSiblingElement( c ) |
| ? c.getName() : null; |
| |
| c.pop(); |
| |
| if (docElemName != null) |
| { |
| type = _schemaTypeLoader.findDocumentType( docElemName ); |
| |
| if (type != null && requestedType != null) |
| { |
| QName requesteddocElemNameName = requestedType.getDocumentElementName(); |
| |
| if (!requesteddocElemNameName.equals( docElemName ) && |
| !requestedType.isValidSubstitution( docElemName )) |
| { |
| throw |
| new XmlException( |
| "Element " + QNameHelper.pretty( docElemName ) + |
| " is not a valid " + QNameHelper.pretty( requesteddocElemNameName ) + |
| " document or a valid substitution."); |
| } |
| } |
| } |
| } |
| |
| if (type == null && requestedType == null) |
| { |
| c.push(); |
| |
| type = |
| Locale.toFirstNormalAttr( c ) && !Locale.toNextNormalAttr( c ) |
| ? _schemaTypeLoader.findAttributeType( c.getName() ) : null; |
| |
| c.pop(); |
| } |
| |
| if (type == null) |
| type = requestedType; |
| |
| if (type == null) |
| type = XmlBeans.NO_TYPE; |
| |
| c.setType( type ); |
| |
| if (requestedType != null) |
| { |
| if (type.isDocumentType()) |
| verifyDocumentType( c, type.getDocumentElementName() ); |
| else if (type.isAttributeType()) |
| verifyAttributeType( c, type.getAttributeTypeAttributeName() ); |
| } |
| } |
| |
| private boolean namespacesSame ( QName n1, QName n2 ) |
| { |
| if (n1 == n2) |
| return true; |
| |
| if (n1 == null || n2 == null) |
| return false; |
| |
| if (n1.getNamespaceURI() == n2.getNamespaceURI()) |
| return true; |
| |
| if (n1.getNamespaceURI() == null || n2.getNamespaceURI() == null) |
| return false; |
| |
| return n1.getNamespaceURI().equals( n2.getNamespaceURI() ); |
| } |
| |
| private void addNamespace ( StringBuffer sb, QName name ) |
| { |
| if (name.getNamespaceURI() == null) |
| sb.append( "<no namespace>" ); |
| else |
| { |
| sb.append( "\"" ); |
| sb.append( name.getNamespaceURI() ); |
| sb.append( "\"" ); |
| } |
| } |
| |
| private void verifyDocumentType ( Cur c, QName docElemName ) throws XmlException |
| { |
| assert c.isRoot(); |
| |
| c.push(); |
| |
| try |
| { |
| StringBuffer sb = null; |
| |
| if (!Locale.toFirstChildElement( c ) || Locale.toNextSiblingElement( c )) |
| { |
| sb = new StringBuffer(); |
| |
| sb.append( "The document is not a " ); |
| sb.append( QNameHelper.pretty( docElemName ) ); |
| sb.append( c.isRoot() ? ": no document element" : ": multiple document elements" ); |
| } |
| else |
| { |
| QName name = c.getName(); |
| |
| if (!name.equals( docElemName )) |
| { |
| sb = new StringBuffer(); |
| |
| sb.append( "The document is not a " ); |
| sb.append( QNameHelper.pretty( docElemName ) ); |
| |
| if (docElemName.getLocalPart().equals( name.getLocalPart() )) |
| { |
| sb.append( ": document element namespace mismatch " ); |
| sb.append( "expected " ); |
| addNamespace( sb, docElemName ); |
| sb.append( " got " ); |
| addNamespace(sb, name ); |
| } |
| else if (namespacesSame( docElemName, name )) |
| { |
| sb.append( ": document element local name mismatch " ); |
| sb.append( "expected " + docElemName.getLocalPart() ); |
| sb.append( " got " + name.getLocalPart() ); |
| } |
| else |
| { |
| sb.append( ": document element mismatch " ); |
| sb.append( "got " ); |
| sb.append( QNameHelper.pretty( name ) ); |
| } |
| } |
| } |
| |
| if (sb != null) |
| { |
| XmlError err = XmlError.forCursor( sb.toString(), new Cursor( c ) ); |
| throw new XmlException( err.toString(), null, err ); |
| } |
| } |
| finally |
| { |
| c.pop(); |
| } |
| } |
| |
| private void verifyAttributeType ( Cur c, QName attrName ) throws XmlException |
| { |
| assert c.isRoot(); |
| |
| c.push(); |
| |
| try |
| { |
| StringBuffer sb = null; |
| |
| if (!Locale.toFirstNormalAttr( c ) || Locale.toNextNormalAttr( c )) |
| { |
| sb = new StringBuffer(); |
| |
| sb.append( "The document is not a " ); |
| sb.append( QNameHelper.pretty( attrName ) ); |
| sb.append( c.isRoot() ? ": no attributes" : ": multiple attributes" ); |
| } |
| else |
| { |
| QName name = c.getName(); |
| |
| if (!name.equals( attrName )) |
| { |
| sb = new StringBuffer(); |
| |
| sb.append( "The document is not a " ); |
| sb.append( QNameHelper.pretty( attrName ) ); |
| |
| if (attrName.getLocalPart().equals( name.getLocalPart() )) |
| { |
| sb.append( ": attribute namespace mismatch " ); |
| sb.append( "expected " ); |
| addNamespace( sb, attrName ); |
| sb.append( " got " ); |
| addNamespace(sb, name ); |
| } |
| else if (namespacesSame( attrName, name )) |
| { |
| sb.append( ": attribute local name mismatch " ); |
| sb.append( "expected " + attrName.getLocalPart() ); |
| sb.append( " got " + name.getLocalPart() ); |
| } |
| else |
| { |
| sb.append( ": attribute element mismatch " ); |
| sb.append( "got " ); |
| sb.append( QNameHelper.pretty( name ) ); |
| } |
| } |
| } |
| |
| if (sb != null) |
| { |
| XmlError err = XmlError.forCursor( sb.toString(), new Cursor( c ) ); |
| throw new XmlException( err.toString(), null, err ); |
| } |
| } |
| finally |
| { |
| c.pop(); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| public static XmlObject newInstance ( |
| SchemaTypeLoader stl, SchemaType type, XmlOptions options ) |
| { |
| Locale l = getLocale( stl, options ); |
| |
| if (l.noSync()) { l.enter(); try { return l.newInstance( type, options ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l.newInstance( type, options ); } finally { l.exit(); } } |
| } |
| |
| private XmlObject newInstance ( SchemaType type, XmlOptions options ) |
| { |
| options = XmlOptions.maskNull( options ); |
| |
| Cur c = tempCur(); |
| |
| c.createRoot(); |
| |
| SchemaType sType = (SchemaType) options.get( XmlOptions.DOCUMENT_TYPE ); |
| |
| if (sType == null) |
| sType = type == null ? XmlObject.type : type; |
| |
| c.setType( sType ); |
| |
| XmlObject x = (XmlObject) c.getUser(); |
| |
| c.release(); |
| |
| return x; |
| } |
| |
| // |
| // |
| // |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, String xmlText, SchemaType type, XmlOptions options ) |
| throws XmlException |
| { |
| Locale l = getLocale( stl, options ); |
| |
| if (l.noSync()) { l.enter(); try { return l.parseToXmlObject( xmlText, type, options ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l.parseToXmlObject( xmlText, type, options ); } finally { l.exit(); } } |
| } |
| |
| private XmlObject parseToXmlObject ( String xmlText, SchemaType type, XmlOptions options ) |
| throws XmlException |
| { |
| Cur c = parse( xmlText, type, options ); |
| |
| XmlObject x = (XmlObject) c.getUser(); |
| |
| c.release(); |
| |
| return x; |
| } |
| |
| private Cur parse ( String xmlText, SchemaType type, XmlOptions options ) |
| throws XmlException |
| { |
| Cur c = |
| getSaxLoader( options ). |
| load( this, new InputSource( new StringReader( xmlText ) ), options ); |
| |
| autoTypeDocument( c, type, options ); |
| |
| return c; |
| } |
| |
| // |
| // |
| // |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, XMLInputStream xis, SchemaType type, XmlOptions options ) |
| throws XmlException, XMLStreamException |
| { |
| throw new RuntimeException( "Not impl" ); |
| // Root r = new Root( stl, null, options ); |
| // r.loadXml( xis, type, options ); |
| // return r.getObject(); |
| } |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, XMLStreamReader xsr, SchemaType type, XmlOptions options ) |
| throws XmlException |
| { |
| throw new RuntimeException( "Not impl" ); |
| // Root r = new Root( stl, null, options ); |
| // r.loadXml( xsr, type, options ); |
| // return r.getObject(); |
| } |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, InputStream is, SchemaType type, XmlOptions options ) |
| throws XmlException, IOException |
| { |
| throw new RuntimeException( "Not impl" ); |
| // Root r = new Root( stl, null, options ); |
| // r.loadXml( is, type, options ); |
| // return r.getObject(); |
| } |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, Reader reader, SchemaType type, XmlOptions options ) |
| throws XmlException, IOException |
| { |
| throw new RuntimeException( "Not impl" ); |
| // Root r = new Root( stl, null, options ); |
| // r.loadXml( reader, type, options ); |
| // return r.getObject(); |
| } |
| |
| public static XmlObject parseToXmlObject ( |
| SchemaTypeLoader stl, Node node, SchemaType type, XmlOptions options ) |
| throws XmlException |
| { |
| throw new RuntimeException( "Not impl" ); |
| // Root r = new Root( stl, null, options ); |
| // r.loadXml( node, type, options ); |
| // return r.getObject(); |
| } |
| |
| public static XmlSaxHandler newSaxHandler ( |
| SchemaTypeLoader stl, SchemaType type, XmlOptions options ) |
| { |
| throw new RuntimeException( "Not impl" ); |
| // return new Root( stl, null, options ).newSaxHandler( type, options ); |
| } |
| |
| // TODO (ericvas ) - have a qname factory here so that the same factory may be |
| // used by the parser. This factory would probably come from my |
| // high speed parser. Otherwise, use a thread local on |
| |
| QName makeQName ( String uri, String localPart ) |
| { |
| assert localPart != null && localPart.length() > 0; |
| // TODO - make sure name is a well formed name? |
| |
| return _qnameFactory.getQName( uri, localPart ); |
| } |
| |
| QName makeQName ( String uri, String local, String prefix ) |
| { |
| return _qnameFactory.getQName( uri, local, prefix == null ? "" : prefix ); |
| } |
| |
| QName makeQualifiedQName ( String uri, String qname ) |
| { |
| if (qname == null) |
| qname = ""; |
| |
| int i = qname.indexOf( ':' ); |
| |
| return i < 0 |
| ? _qnameFactory.getQName( uri, qname ) |
| : _qnameFactory.getQName( uri, qname.substring( i + 1 ), qname.substring( 0, i ) ); |
| } |
| |
| static private class DocProps extends XmlDocumentProperties |
| { |
| private HashMap _map = new HashMap(); |
| |
| public Object put ( Object key, Object value ) { return _map.put( key, value ); } |
| public Object get ( Object key ) { return _map.get( key ); } |
| public Object remove ( Object key ) { return _map.remove( key ); } |
| } |
| |
| static XmlDocumentProperties getDocProps ( Cur c, boolean ensure ) |
| { |
| c.push(); |
| |
| while ( c.toParent() ) |
| ; |
| |
| DocProps props = (DocProps) c.getBookmark( DocProps.class ); |
| |
| if (props == null) |
| c.setBookmark( DocProps.class, props = new DocProps() ); |
| |
| c.pop(); |
| |
| return props; |
| } |
| |
| void registerForTextChange ( Cur c ) |
| { |
| // The end of this list points to itself so that I can know if |
| // any cur is on the list by seeing if netx != null. |
| |
| assert c._nextTextChangeListener == null; |
| |
| if (_textChangeListeners == null) |
| _textChangeListeners = c._nextTextChangeListener = c; |
| else |
| { |
| c._nextTextChangeListener = _textChangeListeners; |
| _textChangeListeners = c; |
| } |
| } |
| |
| interface GeneralChangeListener |
| { |
| void notifyGeneralChange ( ); |
| |
| void setNextGeneralChangeListener ( GeneralChangeListener listener ); |
| |
| GeneralChangeListener getNextGeneralChangeListener ( ); |
| } |
| |
| void registerForGeneralChange ( GeneralChangeListener listener ) |
| { |
| if (listener.getNextGeneralChangeListener() == null) |
| { |
| if (_generalChangeListeners == null) |
| listener.setNextGeneralChangeListener( listener ); |
| else |
| listener.setNextGeneralChangeListener( _generalChangeListeners ); |
| |
| _generalChangeListeners = listener; |
| } |
| } |
| |
| void notifyGeneralChangeListeners ( ) |
| { |
| while ( _generalChangeListeners != null ) |
| { |
| _generalChangeListeners.notifyGeneralChange(); |
| |
| if (_generalChangeListeners.getNextGeneralChangeListener() == _generalChangeListeners) |
| _generalChangeListeners.setNextGeneralChangeListener( null ); |
| |
| GeneralChangeListener next = _generalChangeListeners.getNextGeneralChangeListener(); |
| |
| _generalChangeListeners.setNextGeneralChangeListener( null ); |
| |
| _generalChangeListeners = next; |
| } |
| } |
| |
| void notifyTextChangeListeners ( ) |
| { |
| while ( _textChangeListeners != null ) |
| { |
| _textChangeListeners.textChangeNotification(); |
| |
| if (_textChangeListeners._nextTextChangeListener == _textChangeListeners) |
| _textChangeListeners._nextTextChangeListener = null; |
| |
| _textChangeListeners = _textChangeListeners._nextTextChangeListener; |
| } |
| } |
| |
| // |
| // Cursor helpers |
| // |
| |
| static String getTextValue ( Cur c, int wsr ) |
| { |
| assert c.isNode(); |
| |
| if (!c.hasChildren()) |
| return c.getValueAsString( wsr ); |
| |
| ScrubBuffer sb = getScrubBuffer( wsr ); |
| |
| c.push(); |
| |
| for ( c.next() ; !c.isAtEndOfLastPush() ; c.next() ) |
| if (c.isText()) |
| sb.scrub( c.getChars( -1 ), c._offSrc, c._cchSrc ); |
| |
| c.pop(); |
| |
| return sb.getResultAsString(); |
| } |
| |
| static String applyWhiteSpaceRule ( String s, int wsr ) |
| { |
| int l = s.length(); |
| |
| if (l == 0) |
| return s; |
| |
| char ch; |
| |
| if (wsr == Locale.WS_REPLACE) |
| { |
| for ( int i = 0 ; i < l ; i++ ) |
| if ((ch = s.charAt( i )) == '\n' || ch == '\r' || ch == '\t') |
| return processWhiteSpaceRule( s, wsr ); |
| } |
| else if (wsr == Locale.WS_COLLAPSE) |
| { |
| if (CharUtil.isWhiteSpace( s.charAt( 0 ) ) || CharUtil.isWhiteSpace( s.charAt( l - 1 ))) |
| return processWhiteSpaceRule( s, wsr ); |
| |
| boolean lastWasWhite = false; |
| |
| for ( int i = 1 ; i < l ; i++ ) |
| { |
| boolean isWhite = CharUtil.isWhiteSpace( s.charAt( i ) ); |
| |
| if (isWhite && lastWasWhite) |
| return processWhiteSpaceRule( s, wsr ); |
| |
| lastWasWhite = isWhite; |
| } |
| } |
| |
| return s; |
| } |
| |
| static String processWhiteSpaceRule ( String s, int wsr ) |
| { |
| ScrubBuffer sb = getScrubBuffer( wsr ); |
| |
| sb.scrub( s, 0, s.length() ); |
| |
| return sb.getResultAsString(); |
| } |
| |
| private static final class ScrubBuffer |
| { |
| void init ( int wsr ) |
| { |
| assert wsr == Locale.WS_REPLACE || wsr == Locale.WS_COLLAPSE; |
| |
| _dstOff = 0; |
| _replace = wsr == Locale.WS_REPLACE; |
| } |
| |
| void scrub ( Object src, int off, int cch ) |
| { |
| char[] chars; |
| |
| if (cch == 0) |
| return; |
| |
| if (src instanceof char[]) |
| chars = (char[]) src; |
| else if (cch < _srcBuf.length) |
| chars = _srcBuf; |
| else if (cch < 16384) |
| chars = _srcBuf = new char [ 16384 ]; |
| else |
| chars = new char [ cch ]; |
| |
| if (src != chars) |
| { |
| CharUtil.getChars( chars, 0, src, off, cch ); |
| off = 0; |
| } |
| |
| char ch; |
| |
| while ( cch > 0 && CharUtil.isWhiteSpace( chars[ off ] ) ) |
| { off++; cch--; } |
| |
| while ( cch > 0 && CharUtil.isWhiteSpace( chars[ off + cch - 1 ] ) ) |
| cch--; |
| |
| boolean lastWasWhite = _dstOff > 0 && CharUtil.isWhiteSpace( _dstBuf[ _dstOff ] ); |
| |
| while ( cch-- > 0 ) |
| { |
| ch = chars[ off++ ]; |
| |
| if (CharUtil.isWhiteSpace( ch )) |
| { |
| if (_replace || !lastWasWhite) |
| _dstBuf[ _dstOff++ ] = ' '; |
| |
| lastWasWhite = true; |
| } |
| else |
| { |
| _dstBuf[ _dstOff++ ] = ch; |
| lastWasWhite = false; |
| } |
| } |
| } |
| |
| String getResultAsString ( ) |
| { |
| return new String( _dstBuf, 0, _dstOff ); |
| } |
| |
| private static final int START_STATE = 0; |
| private static final int SPACE_SEEN_STATE = 1; |
| private static final int NOSPACE_STATE = 2; |
| |
| private boolean _replace; |
| |
| private char[] _srcBuf = new char [ 1024 ]; |
| private char[] _dstBuf = new char [ 1024 ]; |
| private int _dstOff; |
| } |
| |
| private static ThreadLocal tl_scrubBuffer = |
| new ThreadLocal ( ) { protected Object initialValue ( ) { return new ScrubBuffer(); } }; |
| |
| static ScrubBuffer getScrubBuffer ( int wsr ) |
| { |
| ScrubBuffer sb = (ScrubBuffer) tl_scrubBuffer.get(); |
| sb.init( wsr ); |
| return sb; |
| } |
| |
| static final int scrubText( |
| Object src, int off, int cch, int wsRule, StringBuffer sb, int state ) |
| { |
| char[] chars = cch < 1024 ? (char[]) tl_scrubBuffer.get() : new char [ cch ]; |
| |
| if (chars.length > 1024 && cch < 16384) |
| tl_scrubBuffer.set( chars ); |
| |
| CharUtil.getChars( chars, 0, src, off, cch ); |
| |
| |
| |
| |
| throw new RuntimeException( "Not impl" ); |
| |
| // assert text != null; |
| // |
| // if (text._buf == null) |
| // { |
| // assert cch == 0; |
| // assert cp == 0; |
| // return state; |
| // } |
| // |
| // if (cch == 0) |
| // return state; |
| // |
| // boolean replace = false; |
| // boolean collapse = false; |
| // |
| // switch ( ws ) |
| // { |
| // case TypeStore.WS_UNSPECIFIED : break; |
| // case TypeStore.WS_PRESERVE : break; |
| // case TypeStore.WS_REPLACE : replace = true; break; |
| // case TypeStore.WS_COLLAPSE : collapse = replace = true; break; |
| // |
| // default : assert false: "Unknown white space rule " +ws; |
| // } |
| // |
| // if (!replace && !collapse) |
| // { |
| // text.fetch(sb, cp, cch); |
| // return state; |
| // } |
| // |
| // int off = text.unObscure( cp, cch ); |
| // int startpt = 0; |
| // |
| // for ( int i = 0 ; i < cch ; i++ ) |
| // { |
| // char ch = text._buf[ off + i ]; |
| // |
| // if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') |
| // { |
| // sb.append(text._buf, off + startpt, i - startpt); |
| // startpt = i + 1; |
| // |
| // if (collapse) |
| // { |
| // if (state == NOSPACE_STATE) |
| // state = SPACE_SEEN_STATE; |
| // } |
| // else |
| // sb.append(' '); |
| // } |
| // else |
| // { |
| // if (state == SPACE_SEEN_STATE) |
| // sb.append( ' ' ); |
| // |
| // state = NOSPACE_STATE; |
| // } |
| // } |
| // |
| // sb.append( text._buf, off + startpt, cch - startpt ); |
| // |
| // return state; |
| } |
| |
| static boolean pushToContainer ( Cur c ) |
| { |
| c.push(); |
| |
| for ( ; ; ) |
| { |
| switch ( c.kind() ) |
| { |
| case ROOT : case ELEM : return true; |
| case - ROOT : case - ELEM : c.pop(); return false; |
| case COMMENT : case PROCINST : c.skip(); break; |
| default : c.nextWithAttrs(); break; |
| } |
| } |
| } |
| |
| static boolean toFirstNormalAttr ( Cur c ) |
| { |
| c.push(); |
| |
| if (c.toFirstAttr()) |
| { |
| do |
| { |
| if (!c.isXmlns()) |
| { |
| c.popButStay(); |
| return true; |
| } |
| } |
| while ( c.toNextAttr() ); |
| } |
| |
| c.pop(); |
| |
| return false; |
| } |
| |
| static boolean toNextNormalAttr ( Cur c ) |
| { |
| c.push(); |
| |
| while ( c.toNextAttr() ) |
| { |
| if (!c.isXmlns()) |
| { |
| c.popButStay(); |
| return true; |
| } |
| } |
| |
| c.pop(); |
| |
| return false; |
| } |
| |
| static boolean toFirstChildElement ( Cur c ) |
| { |
| if (!pushToContainer( c )) |
| return false; |
| |
| if (!c.toFirstChild() || (!c.isElem() && !toNextSiblingElement( c ))) |
| { |
| c.pop(); |
| return false; |
| } |
| |
| c.popButStay(); |
| |
| return true; |
| } |
| |
| static boolean toNextSiblingElement ( Cur c ) |
| { |
| if (!c.hasParent()) |
| return false; |
| |
| c.push(); |
| |
| int k = c.kind(); |
| |
| if (k == ATTR) |
| c.toParent(); |
| else if (k == ELEM) |
| c.skip(); |
| |
| while ( (k = c.kind()) > 0 ) |
| { |
| if (k == ELEM) |
| { |
| c.popButStay(); |
| return true; |
| } |
| |
| if (k > 0) |
| c.toEnd(); |
| |
| c.next(); |
| } |
| |
| c.pop(); |
| |
| return false; |
| } |
| |
| static boolean toChild ( Cur c, String uri, String local, int i ) |
| { |
| return toChild( c, c._locale.makeQName( uri, local ), i ); |
| } |
| |
| static boolean toChild ( Cur c, QName name, int i ) |
| { |
| // if (!c.pushToContainer()) |
| // return false; |
| // |
| throw new RuntimeException( "Not implemented" ); |
| // c.pop.... |
| } |
| |
| // private final class NthChildCache |
| // { |
| // private boolean namesSame ( QName pattern, QName name ) |
| // { |
| // return pattern == null || pattern.equals( name ); |
| // } |
| // |
| // private boolean setsSame ( QNameSet patternSet, QNameSet set) |
| // { |
| // // value equality is probably too expensive. Since the use case |
| // // involves QNameSets that are generated by the compiler, we |
| // // can use identity comparison. |
| // return patternSet != null && patternSet == set; |
| // } |
| // |
| // private boolean nameHit(QName namePattern, QNameSet setPattern, QName name) |
| // { |
| // if (setPattern == null) |
| // return namesSame(namePattern, name); |
| // else |
| // return setPattern.contains(name); |
| // } |
| // |
| // private boolean cacheSame (QName namePattern, QNameSet setPattern) |
| // { |
| // return setPattern == null ? namesSame(namePattern, _name) : |
| // setsSame(setPattern, _set); |
| // } |
| // |
| // int distance ( Splay parent, QName name, QNameSet set, int n ) |
| // { |
| // assert n >= 0; |
| // |
| // if (_version != Root.this.getVersion()) |
| // return Integer.MAX_VALUE - 1; |
| // |
| // if (parent != _parent || !cacheSame(name, set)) |
| // return Integer.MAX_VALUE; |
| // |
| // return n > _n ? n - _n : _n - n; |
| // } |
| // |
| // Begin fetch ( Splay parent, QName name, QNameSet set, int n ) |
| // { |
| // assert n >= 0; |
| // |
| // if (_version != Root.this.getVersion() || _parent != parent || |
| // ! cacheSame(name, set) || n == 0) |
| // { |
| // _version = Root.this.getVersion(); |
| // _parent = parent; |
| // _name = name; |
| // _child = null; |
| // _n = -1; |
| // |
| // if (!parent.isLeaf()) |
| // { |
| // loop: |
| // for ( Splay s = parent.nextSplay() ; ; s = s.nextSplay() ) |
| // { |
| // switch ( s.getKind() ) |
| // { |
| // case END : |
| // case ROOT : break loop; |
| // |
| // case BEGIN : |
| // if (nameHit( name, set, s.getName() )) |
| // { |
| // _child = s; |
| // _n = 0; |
| // break loop; |
| // } |
| // |
| // s = s.getFinishSplay(); |
| // break; |
| // } |
| // } |
| // } |
| // } |
| // |
| // if (_n < 0) |
| // return null; |
| // |
| // if (n > _n) |
| // { |
| // while ( n > _n ) |
| // { |
| // for ( Splay s = _child.getFinishSplay().nextSplay() ; ; |
| // s = s.nextSplay() ) |
| // { |
| // if (s.isFinish()) |
| // return null; |
| // |
| // if (s.isBegin()) |
| // { |
| // if (nameHit( name, set, s.getName() )) |
| // { |
| // _child = s; |
| // _n++; |
| // break; |
| // } |
| // |
| // s = s.getFinishSplay(); |
| // } |
| // } |
| // } |
| // } |
| // else if (n < _n) |
| // { |
| // while ( n < _n ) |
| // { |
| // Splay s = _child; |
| // |
| // for ( ; ; ) |
| // { |
| // s = s.prevSplay(); |
| // |
| // if (s.isLeaf() || s.isEnd()) |
| // { |
| // if (s.isEnd()) |
| // s = s.getContainer(); |
| // |
| // if (nameHit( name, set, s.getName() )) |
| // { |
| // _child = s; |
| // _n--; |
| // break; |
| // } |
| // } |
| // else if (s.isContainer()) |
| // return null; |
| // } |
| // } |
| // } |
| // |
| // return (Begin) _child; |
| // } |
| // |
| // private long _version; |
| // private Splay _parent; |
| // private QName _name; |
| // private QNameSet _set; |
| // |
| // private Splay _child; |
| // private int _n; |
| // } |
| |
| // |
| // |
| // |
| |
| long version ( ) |
| { |
| return _versionAll; |
| } |
| |
| Cur permCur ( ) |
| { |
| return getCur( Cur.PERM ); |
| } |
| |
| Cur weakCur ( Object o ) |
| { |
| assert o != null && !(o instanceof Ref); |
| |
| Cur c = getCur( Cur.WEAK ); |
| |
| assert c._value == null; |
| |
| c._value = new Ref( c, o ); |
| |
| return c; |
| } |
| |
| final ReferenceQueue refQueue ( ) |
| { |
| if (_refQueue == null) |
| _refQueue = new ReferenceQueue(); |
| |
| return _refQueue; |
| } |
| |
| final static class Ref extends PhantomReference |
| { |
| Ref ( Cur c, Object obj ) |
| { |
| super( obj, c._locale.refQueue() ); |
| |
| _cur = c; |
| } |
| |
| final Cur _cur; |
| } |
| |
| Cur tempCur ( ) |
| { |
| Cur c = getCur( Cur.TEMP ); |
| |
| if (c._tempFrame < 0) |
| { |
| assert _numTempFramesLeft < _tempFrames.length; |
| |
| int frame = _tempFrames.length - _numTempFramesLeft - 1; |
| |
| assert frame >= 0 && frame < _tempFrames.length; |
| |
| c._nextTemp = _tempFrames[ frame ]; |
| _tempFrames[ frame ] = c; |
| |
| c._tempFrame = frame; |
| } |
| |
| return c; |
| } |
| |
| void unregisterCurs ( ) |
| { |
| while ( _registered != null ) |
| _registered.embed(); |
| |
| assert _registered == null; |
| } |
| |
| private Cur getCur ( int curKind ) |
| { |
| assert curKind == Cur.TEMP || curKind == Cur.PERM || curKind == Cur.WEAK; |
| assert _curPool == null || _curPoolCount > 0; |
| |
| Cur c; |
| |
| if (_curPool == null) |
| { |
| c = new Cur( this ); |
| c._tempFrame = -1; |
| } |
| else |
| { |
| c = _curPool; |
| _curPool = c.listRemove( _curPool ); |
| c._state = Cur.UNREGISTERED; |
| _curPoolCount--; |
| } |
| |
| assert c._state == Cur.UNREGISTERED; |
| assert c._prev == null && c._next == null; |
| assert !c.isPositioned(); |
| assert c._value == null; |
| |
| c._curKind = curKind; |
| |
| return c; |
| } |
| |
| TextNode createTextNode ( ) |
| { |
| return _saaj == null ? new TextNode( this ) : new SaajTextNode( this ); |
| } |
| |
| CdataNode createCdataNode ( ) |
| { |
| return _saaj == null ? new CdataNode( this ) : new SaajCdataNode( this ); |
| } |
| |
| boolean entered ( ) |
| { |
| return _tempFrames.length - _numTempFramesLeft > 0; |
| } |
| |
| public void enter ( Locale otherLocale ) |
| { |
| enter(); |
| |
| if (otherLocale != this) |
| otherLocale.enter(); |
| } |
| |
| public void enter ( ) |
| { |
| assert _numTempFramesLeft >= 0; |
| |
| if (--_numTempFramesLeft <= 0) |
| { |
| Cur[] newTempFrames = new Cur [ (_numTempFramesLeft = _tempFrames.length) * 2 ]; |
| System.arraycopy( _tempFrames, 0, newTempFrames, 0, _tempFrames.length ); |
| _tempFrames = newTempFrames; |
| } |
| |
| if (++_entryCount > 1000) |
| { |
| _entryCount = 0; |
| |
| if (_refQueue != null) |
| { |
| for ( ; ; ) |
| { |
| Ref ref = (Ref) _refQueue.poll(); |
| |
| if (ref == null) |
| break; |
| |
| ref._cur.release(); |
| } |
| } |
| } |
| } |
| |
| public void exit ( Locale otherLocale ) |
| { |
| exit(); |
| |
| if (otherLocale != this) |
| otherLocale.exit(); |
| } |
| |
| public void exit ( ) |
| { |
| assert _numTempFramesLeft >= 0; |
| |
| int frame = _tempFrames.length - ++_numTempFramesLeft; |
| |
| Cur c = _tempFrames [ frame ]; |
| |
| _tempFrames [ frame ] = null; |
| |
| while ( c != null ) |
| { |
| assert c._tempFrame == frame; |
| |
| Cur next = c._nextTemp; |
| |
| c._nextTemp = null; |
| c._tempFrame = -1; |
| |
| c.release(); |
| |
| c = next; |
| } |
| } |
| |
| // |
| // |
| // |
| |
| public boolean noSync ( ) |
| { |
| return _noSync; |
| } |
| |
| public boolean sync ( ) |
| { |
| return !_noSync; |
| } |
| |
| static final boolean isWhiteSpace ( String s ) |
| { |
| int l = s.length(); |
| |
| while ( l-- > 0) |
| if (!CharUtil.isWhiteSpace( s.charAt( l ))) |
| return false; |
| |
| return true; |
| } |
| |
| static final boolean isWhiteSpace ( StringBuffer sb ) |
| { |
| int l = sb.length(); |
| |
| while ( l-- > 0) |
| if (!CharUtil.isWhiteSpace( sb.charAt( l ))) |
| return false; |
| |
| return true; |
| } |
| |
| static boolean beginsWithXml ( String name ) |
| { |
| if (name.length() < 3) |
| return false; |
| |
| char ch; |
| |
| if (((ch = name.charAt( 0 )) == 'x' || ch == 'X') && |
| ((ch = name.charAt( 1 )) == 'm' || ch == 'M') && |
| ((ch = name.charAt( 2 )) == 'l' || ch == 'L')) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static boolean isXmlns ( QName name ) |
| { |
| String prefix = name.getPrefix(); |
| |
| if (prefix.equals( "xmlns" )) |
| return true; |
| |
| return prefix.length() == 0 && name.getLocalPart().equals( "xmlns" ); |
| } |
| |
| QName createXmlns ( String prefix ) |
| { |
| if (prefix == null) |
| prefix = ""; |
| |
| return |
| prefix.length() == 0 |
| ? makeQName( _xmlnsUri, "xmlns", "" ) |
| : makeQName( _xmlnsUri, prefix, "xmlns" ); |
| } |
| |
| static String xmlnsPrefix ( QName name ) |
| { |
| return name.getPrefix().equals( "xmlns" ) ? name.getLocalPart() : ""; |
| } |
| |
| // |
| // Loading/parsing |
| // |
| |
| static abstract class LoadContext |
| { |
| protected abstract void startElement ( QName name ); |
| protected abstract void endElement ( ); |
| |
| protected abstract void attr ( String local, String uri, String prefix, |
| String value ); |
| |
| protected abstract void comment ( char[] buff, int off, int cch ); |
| protected abstract void procInst ( String target, String value ); |
| protected abstract void text ( char[] buff, int off, int cch ); |
| protected abstract Cur finish ( ); |
| |
| } |
| |
| private static ThreadLocal tl_saxLoadersDefaultResolver = |
| new ThreadLocal ( ) { protected Object initialValue ( ) { return newSaxLoader(); } }; |
| |
| private static ThreadLocal tl_saxLoaders = |
| new ThreadLocal ( ) { protected Object initialValue ( ) { return newSaxLoader(); } }; |
| |
| private static SaxLoader getSaxLoader ( XmlOptions options ) |
| { |
| // XMLReader.setEntityResolver() cannot be passed null. |
| // Because of this, I cannot reset the entity resolver to be |
| // that which was default. Thus, I need to cache two |
| // SaxLoaders. One which uses the default entity resolver and |
| // one which I can change the resolve to whatever I want for a |
| // given parse. |
| |
| options = XmlOptions.maskNull( options ); |
| |
| EntityResolver er = (EntityResolver) options.get( XmlOptions.ENTITY_RESOLVER ); |
| |
| if (er == null) |
| er = ResolverUtil.getGlobalEntityResolver(); |
| |
| if (er == null && options.hasOption( XmlOptions.LOAD_USE_DEFAULT_RESOLVER )) |
| return (SaxLoader) tl_saxLoadersDefaultResolver.get(); |
| |
| SaxLoader sl = (SaxLoader) tl_saxLoaders.get(); |
| |
| if (er == null) |
| er = sl; |
| |
| sl.setEntityResolver( er ); |
| |
| return sl; |
| } |
| |
| private static SaxLoader newSaxLoader ( ) |
| { |
| SaxLoader sl = null; |
| |
| try |
| { |
| sl = PiccoloSaxLoader.newInstance(); |
| |
| if (sl == null) |
| sl = DefaultSaxLoader.newInstance(); |
| } |
| catch ( Exception e ) |
| { |
| throw new RuntimeException( "Can't find an XML parser", e ); |
| } |
| |
| if (sl == null) |
| throw new RuntimeException( "Can't find an XML parser" ); |
| |
| return sl; |
| } |
| |
| private static class DefaultSaxLoader extends SaxLoader |
| { |
| private DefaultSaxLoader ( XMLReader xr ) |
| { |
| super( xr, null ); |
| } |
| |
| static SaxLoader newInstance ( ) throws Exception |
| { |
| return |
| new DefaultSaxLoader( |
| SAXParserFactory.newInstance().newSAXParser().getXMLReader() ); |
| } |
| } |
| |
| private static class PiccoloSaxLoader extends SaxLoader |
| { |
| // TODO - Need to look at root.java to bring this loader up to |
| // date with all needed features |
| |
| private PiccoloSaxLoader ( |
| XMLReader xr, Locator startLocator, Method m_getEncoding, Method m_getVersion ) |
| { |
| super( xr, startLocator ); |
| |
| _m_getEncoding = m_getEncoding; |
| _m_getVersion = m_getVersion; |
| } |
| |
| static SaxLoader newInstance ( ) throws Exception |
| { |
| Class pc = null; |
| |
| try |
| { |
| pc = Class.forName( "com.bluecast.xml.Piccolo" ); |
| } |
| catch ( ClassNotFoundException e ) |
| { |
| return null; |
| } |
| |
| XMLReader xr = (XMLReader) pc.newInstance(); |
| |
| Method m_getEncoding = pc.getMethod( "getEncoding", null ); |
| Method m_getVersion = pc.getMethod( "getVersion", null ); |
| Method m_getStartLocator = pc.getMethod( "getStartLocator", null ); |
| |
| Locator startLocator = |
| (Locator) m_getStartLocator.invoke( xr, null ); |
| |
| return new PiccoloSaxLoader( xr, startLocator, m_getEncoding, m_getVersion ); |
| } |
| |
| private Method _m_getEncoding; |
| private Method _m_getVersion; |
| } |
| |
| private static abstract class SaxLoader |
| implements ContentHandler, LexicalHandler, ErrorHandler, EntityResolver |
| { |
| SaxLoader ( XMLReader xr, Locator startLocator ) |
| { |
| _xr = xr; |
| _startLocator = startLocator; |
| |
| try |
| { |
| _xr.setFeature( "http://xml.org/sax/features/namespace-prefixes", true ); |
| _xr.setFeature( "http://xml.org/sax/features/namespaces", true ); |
| _xr.setFeature( "http://xml.org/sax/features/validation", false ); |
| _xr.setProperty( "http://xml.org/sax/properties/lexical-handler", this ); |
| _xr.setContentHandler( this ); |
| _xr.setErrorHandler( this ); |
| } |
| catch ( Throwable e ) |
| { |
| throw new RuntimeException( e.getMessage(), e ); |
| } |
| } |
| |
| void setEntityResolver ( EntityResolver er ) |
| { |
| _xr.setEntityResolver( er ); |
| } |
| |
| public Cur load ( Locale l, InputSource is, XmlOptions options ) |
| { |
| _locale = l; |
| _context = new Cur.CurLoadContext( _locale, options ); |
| |
| try |
| { |
| _xr.parse( is ); |
| } |
| catch ( Exception e ) |
| { |
| throw new RuntimeException( e.getMessage(), e ); |
| } |
| |
| return _context.finish(); |
| } |
| |
| public void setDocumentLocator ( Locator locator ) |
| { |
| // TODO - hook up locator ... |
| } |
| |
| public void startDocument ( ) throws SAXException |
| { |
| // Do nothing ... start of document is implicit |
| } |
| |
| public void endDocument ( ) throws SAXException |
| { |
| // Do nothing ... end of document is implicit |
| } |
| |
| public void startElement ( String uri, String local, String qName, Attributes atts ) |
| throws SAXException |
| { |
| if (local.length() == 0) |
| local = qName; |
| |
| // Out current parser (Piccolo) does not error when a |
| // namespace is used and not defined. Check for these here |
| |
| if (qName.indexOf( ':' ) >= 0 && uri.length() == 0) |
| { |
| XmlError err = |
| XmlError.forMessage( |
| "Use of undefined namespace prefix: " + |
| qName.substring( 0, qName.indexOf( ':' ) )); |
| |
| throw new XmlRuntimeException( err.toString(), null, err ); |
| } |
| |
| _context.startElement( _locale.makeQualifiedQName( uri, qName ) ); |
| |
| for ( int i = 0, len = atts.getLength() ; i < len ; i++ ) |
| { |
| String aqn = atts.getQName( i ); |
| |
| if (aqn.equals( "xmlns" )) |
| { |
| _context.attr( "xmlns", _xmlnsUri, null, atts.getValue( i ) ); |
| } |
| else if (aqn.startsWith( "xmlns:" )) |
| { |
| String prefix = aqn.substring( 6 ); |
| |
| if (prefix.length() == 0) |
| { |
| XmlError err = |
| XmlError.forMessage( "Prefix not specified", XmlError.SEVERITY_ERROR ); |
| |
| throw new XmlRuntimeException( err.toString(), null, err ); |
| } |
| |
| String attrUri = atts.getValue( i ); |
| |
| if (attrUri.length() == 0) |
| { |
| XmlError err = |
| XmlError.forMessage( |
| "Prefix can't be mapped to no namespace: " + prefix, |
| XmlError.SEVERITY_ERROR ); |
| |
| throw new XmlRuntimeException( err.toString(), null, err ); |
| } |
| |
| _context.attr( prefix, _xmlnsUri, "xmlns", attrUri ); |
| } |
| else |
| { |
| int colon = aqn.indexOf( ':' ); |
| |
| if (colon < 0) |
| _context.attr( aqn, atts.getURI( i ), null, atts.getValue( i ) ); |
| else |
| { |
| _context.attr( |
| aqn.substring( colon + 1 ), atts.getURI( i ), aqn.substring( 0, colon ), |
| atts.getValue( i ) ); |
| } |
| } |
| } |
| } |
| |
| public void endElement ( String namespaceURI, String localName, String qName ) |
| throws SAXException |
| { |
| _context.endElement(); |
| } |
| |
| public void characters ( char ch[], int start, int length ) throws SAXException |
| { |
| _context.text( ch, start, length ); |
| } |
| |
| public void ignorableWhitespace ( char ch[], int start, int length ) throws SAXException |
| { |
| } |
| |
| public void comment ( char ch[], int start, int length ) throws SAXException |
| { |
| _context.comment( ch, start, length ); |
| } |
| |
| public void processingInstruction ( String target, String data ) throws SAXException |
| { |
| _context.procInst( target, data ); |
| } |
| |
| public void startDTD ( String name, String publicId, String systemId ) throws SAXException |
| { |
| } |
| |
| public void endDTD ( ) throws SAXException |
| { |
| } |
| |
| public void startPrefixMapping ( String prefix, String uri ) throws SAXException |
| { |
| if (beginsWithXml( prefix ) && ! ( "xml".equals( prefix ) && _xml1998Uri.equals( uri ))) |
| { |
| XmlError err = |
| XmlError.forMessage( |
| "Prefix can't begin with XML: " + prefix, XmlError.SEVERITY_ERROR ); |
| |
| throw new XmlRuntimeException( err.toString(), null, err ); |
| } |
| } |
| |
| public void endPrefixMapping ( String prefix ) throws SAXException |
| { |
| } |
| |
| public void skippedEntity ( String name ) throws SAXException |
| { |
| // throw new RuntimeException( "Not impl: skippedEntity" ); |
| } |
| |
| public void startCDATA ( ) throws SAXException |
| { |
| } |
| |
| public void endCDATA ( ) throws SAXException |
| { |
| } |
| |
| public void startEntity ( String name ) throws SAXException |
| { |
| // throw new RuntimeException( "Not impl: startEntity" ); |
| } |
| |
| public void endEntity ( String name ) throws SAXException |
| { |
| // throw new RuntimeException( "Not impl: endEntity" ); |
| } |
| |
| public void fatalError ( SAXParseException e ) throws SAXException |
| { |
| throw e; |
| } |
| |
| public void error ( SAXParseException e ) throws SAXException |
| { |
| throw e; |
| } |
| |
| public void warning ( SAXParseException e ) throws SAXException |
| { |
| throw e; |
| } |
| |
| public InputSource resolveEntity ( String publicId, String systemId ) |
| { |
| return new InputSource( new StringReader( "" ) ); |
| } |
| |
| private Locale _locale; |
| private XMLReader _xr; |
| private LoadContext _context; |
| private Locator _startLocator; |
| } |
| |
| private Dom load ( InputSource is, XmlOptions options ) |
| { |
| return getSaxLoader( options ).load( this, is, options ).getDom(); |
| } |
| |
| public Dom load ( Reader r ) |
| { |
| return load( new InputSource( r ), null ); |
| } |
| |
| public Dom load ( String s ) |
| { |
| return load( new InputSource( new StringReader( s ) ), null ); |
| } |
| |
| public Dom load ( InputStream in ) |
| { |
| return load( in, null ); |
| } |
| |
| public Dom load ( InputStream in, XmlOptions options ) |
| { |
| return load( new InputSource( in ), options ); |
| } |
| |
| public Dom load ( String s, XmlOptions options ) |
| { |
| return load( new InputSource( new StringReader( s ) ), options ); |
| } |
| |
| // |
| // DOMImplementation methods |
| // |
| |
| public Document createDocument ( String uri, String qname, DocumentType doctype ) |
| { |
| return DomImpl._domImplementation_createDocument( this, uri, qname, doctype ); |
| } |
| |
| public DocumentType createDocumentType ( String qname, String publicId, String systemId ) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| // return DomImpl._domImplementation_createDocumentType( this, qname, publicId, systemId ); |
| } |
| |
| public boolean hasFeature ( String feature, String version ) |
| { |
| return DomImpl._domImplementation_hasFeature( this, feature, version ); |
| } |
| |
| public Object getFeature ( String feature, String version ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| |
| // |
| // SaajCallback methods |
| // |
| |
| public void setSaajData ( Node n, Object o ) |
| { |
| assert n instanceof Dom; |
| |
| DomImpl.saajCallback_setSaajData( (Dom) n, o ); |
| } |
| |
| public Object getSaajData ( Node n ) |
| { |
| assert n instanceof Dom; |
| |
| return DomImpl.saajCallback_getSaajData( (Dom) n ); |
| } |
| |
| public Element createSoapElement ( QName name, QName parentName ) |
| { |
| assert _ownerDoc != null; |
| |
| return DomImpl.saajCallback_createSoapElement( _ownerDoc, name, parentName ); |
| } |
| |
| public Element importSoapElement ( Document doc, Element elem, boolean deep, QName parentName ) |
| { |
| assert doc instanceof Dom; |
| |
| return DomImpl.saajCallback_importSoapElement( (Dom) doc, elem, deep, parentName ); |
| } |
| |
| |
| private static final class DefaultQNameFactory implements QNameFactory |
| { |
| private QNameCache _cache = XmlBeans.getQNameCache(); |
| |
| public QName getQName ( String uri, String local ) |
| { |
| return _cache.getName( uri, local, "" ); |
| } |
| |
| public QName getQName ( String uri, String local, String prefix ) |
| { |
| return _cache.getName( uri, local, prefix ); |
| } |
| |
| public QName getQName ( |
| char[] uriSrc, int uriPos, int uriCch, |
| char[] localSrc, int localPos, int localCch ) |
| { |
| return |
| _cache.getName( |
| new String( uriSrc, uriPos, uriCch ), |
| new String( localSrc, localPos, localCch ), |
| "" ); |
| } |
| |
| public QName getQName ( |
| char[] uriSrc, int uriPos, int uriCch, |
| char[] localSrc, int localPos, int localCch, |
| char[] prefixSrc, int prefixPos, int prefixCch ) |
| { |
| return |
| _cache.getName( |
| new String( uriSrc, uriPos, uriCch ), |
| new String( localSrc, localPos, localCch ), |
| new String( prefixSrc, prefixPos, prefixCch ) ); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| boolean _noSync; |
| |
| SchemaTypeLoader _schemaTypeLoader; |
| |
| private ReferenceQueue _refQueue; |
| private int _entryCount; |
| |
| private int _numTempFramesLeft; |
| private Cur[] _tempFrames; |
| |
| Cur _curPool; |
| int _curPoolCount; |
| |
| Cur _registered; |
| |
| GeneralChangeListener _generalChangeListeners; |
| |
| Cur _textChangeListeners; |
| |
| long _versionAll; |
| long _versionSansText; |
| |
| Locations _locations; |
| |
| CharUtil _charUtil; |
| |
| Saaj _saaj; |
| |
| Dom _ownerDoc; |
| |
| QNameFactory _qnameFactory; |
| |
| boolean _validateOnSet; |
| } |
