* 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
* 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;
}
}
}