feat(jdk8): move files to new folder to avoid resources compiled.
This commit is contained in:
598
jdkSrc/jdk8/com/sun/tools/internal/xjc/ModelLoader.java
Normal file
598
jdkSrc/jdk8/com/sun/tools/internal/xjc/ModelLoader.java
Normal file
@@ -0,0 +1,598 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
package com.sun.tools.internal.xjc;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
|
||||
import com.sun.codemodel.internal.JCodeModel;
|
||||
import com.sun.tools.internal.xjc.model.Model;
|
||||
import com.sun.tools.internal.xjc.reader.Const;
|
||||
import com.sun.tools.internal.xjc.reader.ExtensionBindingChecker;
|
||||
import com.sun.tools.internal.xjc.reader.dtd.TDTDReader;
|
||||
import com.sun.tools.internal.xjc.reader.internalizer.DOMForest;
|
||||
import com.sun.tools.internal.xjc.reader.internalizer.DOMForestScanner;
|
||||
import com.sun.tools.internal.xjc.reader.internalizer.InternalizationLogic;
|
||||
import com.sun.tools.internal.xjc.reader.internalizer.SCDBasedBindingSet;
|
||||
import com.sun.tools.internal.xjc.reader.internalizer.VersionChecker;
|
||||
import com.sun.tools.internal.xjc.reader.relaxng.RELAXNGCompiler;
|
||||
import com.sun.tools.internal.xjc.reader.relaxng.RELAXNGInternalizationLogic;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.BGMBuilder;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.AnnotationParserFactoryImpl;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.parser.CustomizationContextChecker;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.parser.IncorrectNamespaceURIChecker;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.parser.SchemaConstraintChecker;
|
||||
import com.sun.tools.internal.xjc.reader.xmlschema.parser.XMLSchemaInternalizationLogic;
|
||||
import com.sun.tools.internal.xjc.util.ErrorReceiverFilter;
|
||||
import com.sun.xml.internal.bind.v2.util.XmlFactory;
|
||||
import com.sun.xml.internal.xsom.XSSchemaSet;
|
||||
import com.sun.xml.internal.xsom.parser.JAXPParser;
|
||||
import com.sun.xml.internal.xsom.parser.XMLParser;
|
||||
import com.sun.xml.internal.xsom.parser.XSOMParser;
|
||||
import javax.xml.XMLConstants;
|
||||
|
||||
import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
|
||||
import com.sun.xml.internal.rngom.ast.util.CheckingSchemaBuilder;
|
||||
import com.sun.xml.internal.rngom.digested.DPattern;
|
||||
import com.sun.xml.internal.rngom.digested.DSchemaBuilderImpl;
|
||||
import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
|
||||
import com.sun.xml.internal.rngom.parse.Parseable;
|
||||
import com.sun.xml.internal.rngom.parse.compact.CompactParseable;
|
||||
import com.sun.xml.internal.rngom.parse.xml.SAXParseable;
|
||||
import com.sun.xml.internal.rngom.xml.sax.XMLReaderCreator;
|
||||
import org.w3c.dom.Document;
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.NodeList;
|
||||
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.SAXException;
|
||||
import org.xml.sax.SAXParseException;
|
||||
import org.xml.sax.XMLFilter;
|
||||
import org.xml.sax.XMLReader;
|
||||
import org.xml.sax.helpers.XMLFilterImpl;
|
||||
|
||||
/**
|
||||
* Builds a {@link Model} object.
|
||||
*
|
||||
* This is an utility class that makes it easy to load a grammar object
|
||||
* from various sources.
|
||||
*
|
||||
* @author
|
||||
* Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
|
||||
*/
|
||||
public final class ModelLoader {
|
||||
|
||||
private final Options opt;
|
||||
private final ErrorReceiverFilter errorReceiver;
|
||||
private final JCodeModel codeModel;
|
||||
/**
|
||||
* {@link DOMForest#transform(boolean)} creates this on the side.
|
||||
*/
|
||||
private SCDBasedBindingSet scdBasedBindingSet;
|
||||
|
||||
|
||||
/**
|
||||
* A convenience method to load schemas into a {@link Model}.
|
||||
*/
|
||||
public static Model load( Options opt, JCodeModel codeModel, ErrorReceiver er ) {
|
||||
return new ModelLoader(opt,codeModel,er).load();
|
||||
}
|
||||
|
||||
|
||||
public ModelLoader(Options _opt, JCodeModel _codeModel, ErrorReceiver er) {
|
||||
this.opt = _opt;
|
||||
this.codeModel = _codeModel;
|
||||
this.errorReceiver = new ErrorReceiverFilter(er);
|
||||
}
|
||||
|
||||
@SuppressWarnings("CallToThreadDumpStack")
|
||||
private Model load() {
|
||||
Model grammar;
|
||||
|
||||
if(!sanityCheck())
|
||||
return null;
|
||||
|
||||
|
||||
try {
|
||||
switch (opt.getSchemaLanguage()) {
|
||||
case DTD :
|
||||
// TODO: make sure that bindFiles,size()<=1
|
||||
InputSource bindFile = null;
|
||||
if (opt.getBindFiles().length > 0)
|
||||
bindFile = opt.getBindFiles()[0];
|
||||
// if there is no binding file, make a dummy one.
|
||||
if (bindFile == null) {
|
||||
// if no binding information is specified, provide a default
|
||||
bindFile =
|
||||
new InputSource(
|
||||
new StringReader(
|
||||
"<?xml version='1.0'?><xml-java-binding-schema><options package='"
|
||||
+ (opt.defaultPackage==null?"generated":opt.defaultPackage)
|
||||
+ "'/></xml-java-binding-schema>"));
|
||||
}
|
||||
|
||||
checkTooManySchemaErrors();
|
||||
grammar = loadDTD(opt.getGrammars()[0], bindFile );
|
||||
break;
|
||||
|
||||
case RELAXNG :
|
||||
checkTooManySchemaErrors();
|
||||
grammar = loadRELAXNG();
|
||||
break;
|
||||
|
||||
case RELAXNG_COMPACT :
|
||||
checkTooManySchemaErrors();
|
||||
grammar = loadRELAXNGCompact();
|
||||
break;
|
||||
|
||||
case WSDL:
|
||||
grammar = annotateXMLSchema( loadWSDL() );
|
||||
break;
|
||||
|
||||
case XMLSCHEMA:
|
||||
grammar = annotateXMLSchema( loadXMLSchema() );
|
||||
break;
|
||||
|
||||
default :
|
||||
throw new AssertionError(); // assertion failed
|
||||
}
|
||||
|
||||
if (errorReceiver.hadError()) {
|
||||
grammar = null;
|
||||
} else {
|
||||
grammar.setPackageLevelAnnotations(opt.packageLevelAnnotations);
|
||||
}
|
||||
|
||||
return grammar;
|
||||
|
||||
} catch (SAXException e) {
|
||||
// parsing error in the input document.
|
||||
// this error must have been reported to the user vis error handler
|
||||
// so don't print it again.
|
||||
if (opt.verbose) {
|
||||
// however, a bug in XJC might throw unexpected SAXException.
|
||||
// thus when one is debugging, it is useful to print what went
|
||||
// wrong.
|
||||
if (e.getException() != null)
|
||||
e.getException().printStackTrace();
|
||||
else
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
} catch (AbortException e) {
|
||||
// error should have been reported already, since this is requested by the error receiver
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Do some extra checking and return false if the compilation
|
||||
* should abort.
|
||||
*/
|
||||
private boolean sanityCheck() {
|
||||
if( opt.getSchemaLanguage()==Language.XMLSCHEMA ) {
|
||||
Language guess = opt.guessSchemaLanguage();
|
||||
|
||||
String[] msg = null;
|
||||
switch(guess) {
|
||||
case DTD:
|
||||
msg = new String[]{"DTD","-dtd"};
|
||||
break;
|
||||
case RELAXNG:
|
||||
msg = new String[]{"RELAX NG","-relaxng"};
|
||||
break;
|
||||
case RELAXNG_COMPACT:
|
||||
msg = new String[]{"RELAX NG compact syntax","-relaxng-compact"};
|
||||
break;
|
||||
case WSDL:
|
||||
msg = new String[]{"WSDL","-wsdl"};
|
||||
break;
|
||||
}
|
||||
if( msg!=null )
|
||||
errorReceiver.warning( null,
|
||||
Messages.format(
|
||||
Messages.EXPERIMENTAL_LANGUAGE_WARNING,
|
||||
msg[0], msg[1] ));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* {@link XMLParser} implementation that adds additional processors into the chain.
|
||||
*
|
||||
* <p>
|
||||
* This parser will parse a DOM forest as:
|
||||
* DOMForestParser -->
|
||||
* ExtensionBindingChecker -->
|
||||
* ProhibitedFeatureFilter -->
|
||||
* XSOMParser
|
||||
*/
|
||||
private class XMLSchemaParser implements XMLParser {
|
||||
private final XMLParser baseParser;
|
||||
|
||||
private XMLSchemaParser(XMLParser baseParser) {
|
||||
this.baseParser = baseParser;
|
||||
}
|
||||
|
||||
public void parse(InputSource source, ContentHandler handler,
|
||||
ErrorHandler errorHandler, EntityResolver entityResolver ) throws SAXException, IOException {
|
||||
// set up the chain of handlers.
|
||||
handler = wrapBy( new ExtensionBindingChecker(XMLConstants.W3C_XML_SCHEMA_NS_URI,opt,errorReceiver), handler );
|
||||
handler = wrapBy( new IncorrectNamespaceURIChecker(errorReceiver), handler );
|
||||
handler = wrapBy( new CustomizationContextChecker(errorReceiver), handler );
|
||||
// handler = wrapBy( new VersionChecker(controller), handler );
|
||||
|
||||
baseParser.parse( source, handler, errorHandler, entityResolver );
|
||||
}
|
||||
/**
|
||||
* Wraps the specified content handler by a filter.
|
||||
* It is little awkward to use a helper implementation class like XMLFilterImpl
|
||||
* as the method parameter, but this simplifies the code.
|
||||
*/
|
||||
private ContentHandler wrapBy( XMLFilterImpl filter, ContentHandler handler ) {
|
||||
filter.setContentHandler(handler);
|
||||
return filter;
|
||||
}
|
||||
}
|
||||
|
||||
private void checkTooManySchemaErrors() {
|
||||
if( opt.getGrammars().length!=1 )
|
||||
errorReceiver.error(null,Messages.format(Messages.ERR_TOO_MANY_SCHEMA));
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a DTD file into an annotated grammar.
|
||||
*
|
||||
* @param source
|
||||
* DTD file
|
||||
* @param bindFile
|
||||
* External binding file.
|
||||
*/
|
||||
private Model loadDTD( InputSource source, InputSource bindFile) {
|
||||
|
||||
// parse the schema as a DTD.
|
||||
return TDTDReader.parse(
|
||||
source,
|
||||
bindFile,
|
||||
errorReceiver,
|
||||
opt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds DOMForest and performs the internalization.
|
||||
*
|
||||
* @throws SAXException
|
||||
* when a fatal error happens
|
||||
*/
|
||||
public DOMForest buildDOMForest( InternalizationLogic logic )
|
||||
throws SAXException {
|
||||
|
||||
// parse into DOM forest
|
||||
DOMForest forest = new DOMForest(logic, opt);
|
||||
|
||||
forest.setErrorHandler(errorReceiver);
|
||||
if(opt.entityResolver!=null)
|
||||
forest.setEntityResolver(opt.entityResolver);
|
||||
|
||||
// parse source grammars
|
||||
for (InputSource value : opt.getGrammars()) {
|
||||
errorReceiver.pollAbort();
|
||||
forest.parse(value, true);
|
||||
}
|
||||
|
||||
// parse external binding files
|
||||
for (InputSource value : opt.getBindFiles()) {
|
||||
errorReceiver.pollAbort();
|
||||
Document dom = forest.parse(value, true);
|
||||
if(dom==null) continue; // error must have been reported
|
||||
Element root = dom.getDocumentElement();
|
||||
// TODO: it somehow doesn't feel right to do a validation in the Driver class.
|
||||
// think about moving it to somewhere else.
|
||||
if (!fixNull(root.getNamespaceURI()).equals(Const.JAXB_NSURI)
|
||||
|| !root.getLocalName().equals("bindings"))
|
||||
errorReceiver.error(new SAXParseException(Messages.format(Messages.ERR_NOT_A_BINDING_FILE,
|
||||
root.getNamespaceURI(),
|
||||
root.getLocalName()),
|
||||
null,
|
||||
value.getSystemId(),
|
||||
-1, -1));
|
||||
}
|
||||
|
||||
scdBasedBindingSet = forest.transform(opt.isExtensionMode());
|
||||
|
||||
return forest;
|
||||
}
|
||||
|
||||
private String fixNull(String s) {
|
||||
if(s==null) return "";
|
||||
else return s;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a set of XML Schema files into an annotated grammar.
|
||||
*/
|
||||
public XSSchemaSet loadXMLSchema() throws SAXException {
|
||||
|
||||
if( opt.strictCheck && !SchemaConstraintChecker.check(opt.getGrammars(),errorReceiver,opt.entityResolver, opt.disableXmlSecurity)) {
|
||||
// schema error. error should have been reported
|
||||
return null;
|
||||
}
|
||||
|
||||
if(opt.getBindFiles().length==0) {
|
||||
// no external binding. try the speculative no DOMForest execution,
|
||||
// which is faster if the speculation succeeds.
|
||||
try {
|
||||
return createXSOMSpeculative();
|
||||
} catch( SpeculationFailure e) {
|
||||
// failed. go the slow way
|
||||
}
|
||||
}
|
||||
|
||||
// the default slower way is to parse everything into DOM first.
|
||||
// so that we can take external annotations into account.
|
||||
DOMForest forest = buildDOMForest( new XMLSchemaInternalizationLogic() );
|
||||
return createXSOM(forest, scdBasedBindingSet);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a set of schemas inside a WSDL file.
|
||||
*
|
||||
* A WSDL file may contain multiple <xsd:schema> elements.
|
||||
*/
|
||||
private XSSchemaSet loadWSDL()
|
||||
throws SAXException {
|
||||
|
||||
|
||||
// build DOMForest just like we handle XML Schema
|
||||
DOMForest forest = buildDOMForest( new XMLSchemaInternalizationLogic() );
|
||||
|
||||
DOMForestScanner scanner = new DOMForestScanner(forest);
|
||||
|
||||
XSOMParser xsomParser = createXSOMParser( forest );
|
||||
|
||||
// find <xsd:schema>s and parse them individually
|
||||
for( InputSource grammar : opt.getGrammars() ) {
|
||||
Document wsdlDom = forest.get( grammar.getSystemId() );
|
||||
if (wsdlDom == null) {
|
||||
String systemId = Options.normalizeSystemId(grammar.getSystemId());
|
||||
if (forest.get(systemId) != null) {
|
||||
grammar.setSystemId(systemId);
|
||||
wsdlDom = forest.get( grammar.getSystemId() );
|
||||
}
|
||||
}
|
||||
|
||||
NodeList schemas = wsdlDom.getElementsByTagNameNS(XMLConstants.W3C_XML_SCHEMA_NS_URI,"schema");
|
||||
for( int i=0; i<schemas.getLength(); i++ )
|
||||
scanner.scan( (Element)schemas.item(i), xsomParser.getParserHandler() );
|
||||
}
|
||||
return xsomParser.getResult();
|
||||
}
|
||||
|
||||
/**
|
||||
* Annotates the obtained schema set.
|
||||
*
|
||||
* @return
|
||||
* null if an error happens. In that case, the error messages
|
||||
* will be properly reported to the controller by this method.
|
||||
*/
|
||||
public Model annotateXMLSchema(XSSchemaSet xs) {
|
||||
if (xs == null)
|
||||
return null;
|
||||
return BGMBuilder.build(xs, codeModel, errorReceiver, opt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Potentially problematic - make sure the parser instance passed is initialized
|
||||
* with proper security feature.
|
||||
*
|
||||
* @param parser
|
||||
* @return
|
||||
*/
|
||||
public XSOMParser createXSOMParser(XMLParser parser) {
|
||||
// set up other parameters to XSOMParser
|
||||
XSOMParser reader = new XSOMParser(new XMLSchemaParser(parser));
|
||||
reader.setAnnotationParser(new AnnotationParserFactoryImpl(opt));
|
||||
reader.setErrorHandler(errorReceiver);
|
||||
reader.setEntityResolver(opt.entityResolver);
|
||||
return reader;
|
||||
}
|
||||
|
||||
public XSOMParser createXSOMParser(final DOMForest forest) {
|
||||
XSOMParser p = createXSOMParser(forest.createParser());
|
||||
p.setEntityResolver(new EntityResolver() {
|
||||
public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
|
||||
// DOMForest only parses documents that are reachable through systemIds,
|
||||
// and it won't pick up references like <xs:import namespace="..." /> without
|
||||
// @schemaLocation. So we still need to use an entity resolver here to resolve
|
||||
// these references, yet we don't want to just run them blindly, since if we do that
|
||||
// DOMForestParser always get the translated system ID when catalog is used
|
||||
// (where DOMForest records trees with their original system IDs.)
|
||||
if(systemId!=null && forest.get(systemId)!=null)
|
||||
return new InputSource(systemId);
|
||||
if(opt.entityResolver!=null)
|
||||
return opt.entityResolver.resolveEntity(publicId,systemId);
|
||||
|
||||
return null;
|
||||
}
|
||||
});
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
private static final class SpeculationFailure extends Error {}
|
||||
|
||||
private static final class SpeculationChecker extends XMLFilterImpl {
|
||||
@Override
|
||||
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
|
||||
if(localName.equals("bindings") && uri.equals(Const.JAXB_NSURI))
|
||||
throw new SpeculationFailure();
|
||||
super.startElement(uri,localName,qName,attributes);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses schemas directly into XSOM by assuming that there's
|
||||
* no external annotations.
|
||||
* <p>
|
||||
* When an external annotation is found, a {@link SpeculationFailure} is thrown,
|
||||
* and we will do it all over again by using the slow way.
|
||||
*/
|
||||
private XSSchemaSet createXSOMSpeculative() throws SAXException, SpeculationFailure {
|
||||
|
||||
// check if the schema contains external binding files. If so, speculation is a failure.
|
||||
|
||||
XMLParser parser = new XMLParser() {
|
||||
private final JAXPParser base = new JAXPParser(XmlFactory.createParserFactory(opt.disableXmlSecurity));
|
||||
|
||||
public void parse(InputSource source, ContentHandler handler,
|
||||
ErrorHandler errorHandler, EntityResolver entityResolver ) throws SAXException, IOException {
|
||||
// set up the chain of handlers.
|
||||
handler = wrapBy( new SpeculationChecker(), handler );
|
||||
handler = wrapBy( new VersionChecker(null,errorReceiver,entityResolver), handler );
|
||||
|
||||
base.parse( source, handler, errorHandler, entityResolver );
|
||||
}
|
||||
/**
|
||||
* Wraps the specified content handler by a filter.
|
||||
* It is little awkward to use a helper implementation class like XMLFilterImpl
|
||||
* as the method parameter, but this simplifies the code.
|
||||
*/
|
||||
private ContentHandler wrapBy( XMLFilterImpl filter, ContentHandler handler ) {
|
||||
filter.setContentHandler(handler);
|
||||
return filter;
|
||||
}
|
||||
};
|
||||
|
||||
XSOMParser reader = createXSOMParser(parser);
|
||||
|
||||
// parse source grammars
|
||||
for (InputSource value : opt.getGrammars())
|
||||
reader.parse(value);
|
||||
|
||||
return reader.getResult();
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a {@link DOMForest} into a {@link XSSchemaSet}.
|
||||
*
|
||||
* @return
|
||||
* null if the parsing failed.
|
||||
*/
|
||||
public XSSchemaSet createXSOM(DOMForest forest, SCDBasedBindingSet scdBasedBindingSet) throws SAXException {
|
||||
// set up other parameters to XSOMParser
|
||||
XSOMParser reader = createXSOMParser(forest);
|
||||
|
||||
// re-parse the transformed schemas
|
||||
for (String systemId : forest.getRootDocuments()) {
|
||||
errorReceiver.pollAbort();
|
||||
Document dom = forest.get(systemId);
|
||||
if (!dom.getDocumentElement().getNamespaceURI().equals(Const.JAXB_NSURI)) {
|
||||
reader.parse(systemId);
|
||||
}
|
||||
}
|
||||
|
||||
XSSchemaSet result = reader.getResult();
|
||||
|
||||
if(result!=null)
|
||||
scdBasedBindingSet.apply(result,errorReceiver);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a RELAX NG grammar into an annotated grammar.
|
||||
*/
|
||||
private Model loadRELAXNG() throws SAXException {
|
||||
|
||||
// build DOM forest
|
||||
final DOMForest forest = buildDOMForest( new RELAXNGInternalizationLogic() );
|
||||
|
||||
// use JAXP masquerading to validate the input document.
|
||||
// DOMForest -> ExtensionBindingChecker -> RNGOM
|
||||
|
||||
XMLReaderCreator xrc = new XMLReaderCreator() {
|
||||
public XMLReader createXMLReader() {
|
||||
|
||||
// foreset parser cannot change the receivers while it's working,
|
||||
// so we need to have one XMLFilter that works as a buffer
|
||||
XMLFilter buffer = new XMLFilterImpl() {
|
||||
@Override
|
||||
public void parse(InputSource source) throws IOException, SAXException {
|
||||
forest.createParser().parse( source, this, this, this );
|
||||
}
|
||||
};
|
||||
|
||||
XMLFilter f = new ExtensionBindingChecker(Const.RELAXNG_URI,opt,errorReceiver);
|
||||
f.setParent(buffer);
|
||||
|
||||
f.setEntityResolver(opt.entityResolver);
|
||||
|
||||
return f;
|
||||
}
|
||||
};
|
||||
|
||||
Parseable p = new SAXParseable( opt.getGrammars()[0], errorReceiver, xrc );
|
||||
|
||||
return loadRELAXNG(p);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads RELAX NG compact syntax
|
||||
*/
|
||||
private Model loadRELAXNGCompact() {
|
||||
if(opt.getBindFiles().length>0)
|
||||
errorReceiver.error(new SAXParseException(
|
||||
Messages.format(Messages.ERR_BINDING_FILE_NOT_SUPPORTED_FOR_RNC),null));
|
||||
|
||||
// TODO: entity resolver?
|
||||
Parseable p = new CompactParseable( opt.getGrammars()[0], errorReceiver );
|
||||
|
||||
return loadRELAXNG(p);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Common part between the XML syntax and the compact syntax.
|
||||
*/
|
||||
private Model loadRELAXNG(Parseable p) {
|
||||
SchemaBuilder sb = new CheckingSchemaBuilder(new DSchemaBuilderImpl(),errorReceiver);
|
||||
|
||||
try {
|
||||
DPattern out = (DPattern)p.parse(sb);
|
||||
return RELAXNGCompiler.build(out,codeModel,opt);
|
||||
} catch (IllegalSchemaException e) {
|
||||
errorReceiver.error(e.getMessage(),e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user