* Schema object must be thread-safe; multiple-threads can access
* one Schema obejct at the same time.
*
*
* The schema object allows an application to "cache" a schema by compiling it * once and using it many times, possibly by different threads. */ public interface Schema { /** * creates a new Verifier object that validates documents with this schema. * * @return * a valid non-null instance of a Verifier. */ Verifier newVerifier() throws VerifierConfigurationException; } isorelax-20041111/org/iso_relax/verifier/Verifier.java 0000664 0000000 0000000 00000014737 11250544366 0022622 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier; import java.io.File; import java.io.IOException; import org.w3c.dom.Node; import org.xml.sax.EntityResolver; import org.xml.sax.ErrorHandler; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.SAXNotRecognizedException; import org.xml.sax.SAXNotSupportedException; /** * An instance of this interface can validates documents. * *
* An instance of this interface can be obtained through the * {@link VerifierFactory#newVerifier} method or * {@link Schema#newVerifier} method. * Once it is created, an application can use one instance to validate * multiple documents. * *
* This interface is not thread-safe and not reentrant.
* That is, only one thread can use it at any given time, and you can only
* validate one document at any given time.
*
* @since Feb. 23, 2001
* @version Mar. 4, 2001
* @author ASAMI, Tomoharu (asami@zeomtech.com)
* @author Kohsuke KAWAGUCHI
*/
public interface Verifier {
/**
* a read-only feature that checks whether the implementation supports
* getVerifierHandler method.
*
*
* Now a verifier implementation is required to support
* VerifierHandler. Therefore an application doesn't need to
* check this feature.
*
* @deprecated
*/
String FEATURE_HANDLER = "http://www.iso-relax.org/verifier/handler";
/**
* a read-only feature that checks whether the implementation supports
* getVerifierFilter method.
*
*
* Now a verifier implementation is required to support * VerifierFilter. * Therefore an application doesn't need to check this feature. * * @deprecated */ String FEATURE_FILTER = "http://www.iso-relax.org/verifier/filter"; /** * Checks whether a feature is supported or not. * *
* This method is modeled after SAX2. * * @param feature feature name */ boolean isFeature(String feature) throws SAXNotRecognizedException, SAXNotSupportedException; /** * Sets a value to a feature. * *
* This method is modeled after SAX2. * * @param feature feature name * @param value feature value */ void setFeature(String feature, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException; /** * Gets a property value * *
* This method is modeled after SAX2. * * @param property property name */ Object getProperty(String property) throws SAXNotRecognizedException, SAXNotSupportedException; /** * Sets a property value * *
* This method is modeled after SAX2.
*
* @param property property name
* @param value property value
*/
void setProperty(String property, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException;
/**
* Sets a ErrorHandler that receives validation
* errors/warnings.
*
*
* If no error handler is set explicitly, a verifier implementation * will not report any error/warning at all. However, the caller can * still obtain the result of validation through the return value. * *
* Conscious developers should always set an error handler explicitly
* as the default behavior has been changed several times.
*
* @param handler
* this object will receive errors/warning encountered
* during the validation.
*/
void setErrorHandler(ErrorHandler handler);
/**
* Sets a EntityResolver to resolve external entity locations.
*
*
* The given entity resolver is used in the * {@link verify(String)} method and the * {@link verify(InputSource)} method. * * @param handler EntityResolver */ void setEntityResolver(EntityResolver handler); /** * validates an XML document. * * @param uri * URI of a document. * * @return * true if the document is valid. * false if otherwise. */ boolean verify(String uri) throws SAXException, IOException; /** * validates an XML document. * * @param source InputSource of a XML document to verify. * * @return * true if the document is valid. * false if otherwise. */ boolean verify(InputSource source) throws SAXException, IOException; /** * validates an XML document. * * @param file * File to be validated * * @return * true if the document is valid. * false if otherwise. */ boolean verify(File file) throws SAXException, IOException; /** * validates an XML document. * *
* An implementation is required to accept Document object
* as the node parameter. If it also implements partial validation,
* it can also accepts things like Element.
*
* @param node
* the root DOM node of an XML document.
*
* @exception UnsupportedOperationException
* If the node type of the node parameter is something which
* this implementation does not support.
*
* @return
* true if the document is valid.
* false if otherwise.
*/
boolean verify(Node node) throws SAXException;
/**
* Gets a VerifierHandler.
*
*
* you can use the returned
* VerifierHandler to validate documents
* through SAX.
*
*
* Note that two different invocations of this method
* can return the same value; this method does NOT
* necessarily create a new VerifierHandler object.
*/
VerifierHandler getVerifierHandler() throws SAXException;
/**
* Gets a VerifierFilter.
*
*
* you can use the returned
* VerifierHandler to validate documents
* through SAX.
*
*
* Note that two different invocations of this method
* can return the same value; this method does NOT
* necessarily create a new VerifierFilter object.
*/
VerifierFilter getVerifierFilter() throws SAXException;
}
isorelax-20041111/org/iso_relax/verifier/VerifierConfigurationException.java 0000664 0000000 0000000 00000002560 11250544366 0027220 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* VerifierConfigurationException
*
* @since Feb. 23, 2001
* @version Apr. 17, 2001
* @author ASAMI, Tomoharu (asami@zeomtech.com)
*/
public class VerifierConfigurationException extends Exception {
private Exception cause_ = null;
public VerifierConfigurationException(String message) {
super(message);
}
public VerifierConfigurationException(Exception e) {
super(e.getMessage());
cause_ = e;
}
public VerifierConfigurationException(String message, Exception e) {
super(message);
cause_ = e;
}
public Exception getException() {
if (cause_ != null) {
return (cause_);
} else {
return (this);
}
}
public Exception getCauseException() {
return (cause_);
}
public void printStackTrace() {
printStackTrace(new PrintWriter(System.err, true));
}
public void printStackTrace(PrintStream out) {
printStackTrace(new PrintWriter(out));
}
public void printStackTrace(PrintWriter writer) {
if (writer == null) {
writer = new PrintWriter(System.err, true);
}
super.printStackTrace(writer);
if (cause_ != null) {
writer.println();
writer.println("StackTrace of Original Exception:");
cause_.printStackTrace(writer);
}
}
}
isorelax-20041111/org/iso_relax/verifier/VerifierException.java 0000664 0000000 0000000 00000002156 11250544366 0024471 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier;
import java.io.PrintStream;
import java.io.PrintWriter;
import org.xml.sax.SAXException;
/**
* VerifierException
*
* @since Feb. 23, 2001
* @version Mar. 4, 2001
* @author ASAMI, Tomoharu (asami@zeomtech.com)
*/
public class VerifierException extends SAXException {
public VerifierException(String message) {
super(message);
}
public VerifierException(Exception e) {
super(e);
}
public VerifierException(String message, Exception e) {
super(message,e);
}
public void printStackTrace() {
printStackTrace(new PrintWriter(System.err, true));
}
public void printStackTrace(PrintStream out) {
printStackTrace(new PrintWriter(out));
}
public void printStackTrace(PrintWriter writer) {
if (writer == null) {
writer = new PrintWriter(System.err, true);
}
super.printStackTrace(writer);
Exception cause = super.getException();
if (cause != null) {
writer.println();
writer.println("StackTrace of Original Exception:");
cause.printStackTrace(writer);
}
}
}
isorelax-20041111/org/iso_relax/verifier/VerifierFactory.java 0000664 0000000 0000000 00000031660 11250544366 0024144 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
/**
* VerifierFactory
*
* @since Feb. 23, 2001
* @version Apr. 17, 2001
* @author ASAMI, Tomoharu (asami@zeomtech.com)
* @author Kohsuke KAWAGUCHI
*/
public abstract class VerifierFactory {
/**
* parses a schema at the specified location and returns a Verifier object
* that validates documents by using that schema.
*
*
* Some of XML parsers accepts filenames as well as URLs, while others * reject them. Therefore, to parse a file as a schema, you should use * a File object. * * @param uri URI of a schema file */ public Verifier newVerifier(String uri) throws VerifierConfigurationException, SAXException, IOException { return compileSchema(uri).newVerifier(); } /** * parses a schema from the specified file and returns a Verifier object * that validates documents by using that schema. * * @param uri File of a schema file */ public Verifier newVerifier(File file) throws VerifierConfigurationException, SAXException, IOException { return compileSchema(file).newVerifier(); } /** * parses a schema from the specified InputStream and returns a Verifier object * that validates documents by using that schema. */ public Verifier newVerifier(InputStream stream) throws VerifierConfigurationException, SAXException, IOException { return compileSchema( stream, null ).newVerifier(); } /** * parses a schema from the specified InputStream and returns a Verifier object * that validates documents by using that schema. * * @param systemId * System ID of this stream. */ public Verifier newVerifier(InputStream stream, String systemId ) throws VerifierConfigurationException, SAXException, IOException { return compileSchema(stream,systemId).newVerifier(); } /** * parses a schema from the specified InputSource and returns a Verifier object * that validates documents by using that schema. * * @param source InputSource of a schema file */ public Verifier newVerifier(InputSource source) throws VerifierConfigurationException, SAXException, IOException { return compileSchema(source).newVerifier(); } /** * processes a schema into a Schema object, which is a compiled representation * of a schema. * * The obtained schema object can then be used concurrently across multiple * threads. */ public abstract Schema compileSchema( InputSource is ) throws VerifierConfigurationException, SAXException, IOException; /** * processes a schema into a Schema object, which is a compiled representation * of a schema. * * The obtained schema object can then be used concurrently across multiple * threads. * *
* Some of XML parsers accepts filenames as well as URLs, while others
* reject them. Therefore, to parse a file as a schema, you should use
* a File object.
*
* @param url
* A source url of a schema file to be compiled.
*/
public Schema compileSchema( String url )
throws VerifierConfigurationException, SAXException, IOException {
return compileSchema( new InputSource(url) );
}
/**
* processes a schema into a Schema object, which is a compiled representation
* of a schema.
*
* The obtained schema object can then be used concurrently across multiple
* threads.
*
* @param stream
* A stream object that holds a schema.
*/
public Schema compileSchema( InputStream stream )
throws VerifierConfigurationException, SAXException, IOException {
return compileSchema(stream,null);
}
/**
* processes a schema into a Schema object, which is a compiled representation
* of a schema.
*
* The obtained schema object can then be used concurrently across multiple
* threads.
*
* @param systemId
* The system Id of this input stream.
*/
public Schema compileSchema( InputStream stream, String systemId )
throws VerifierConfigurationException, SAXException, IOException {
InputSource is = new InputSource(stream);
is.setSystemId(systemId);
return compileSchema(is);
}
/**
* processes a schema into a Schema object, which is a compiled representation
* of a schema.
*
* The obtained schema object can then be used concurrently across multiple
* threads.
*
* @param file
* A schema file to be compiled
*/
public Schema compileSchema( File f )
throws VerifierConfigurationException, SAXException, IOException {
String uri = "file:" + f.getAbsolutePath();
if (File.separatorChar == '\\') {
uri = uri.replace('\\', '/');
}
return compileSchema(new InputSource(uri));
}
/**
* Indicates whether if the feature is supported, or not.
*
* @param feature feature name
*/
public boolean isFeature(String feature)
throws SAXNotRecognizedException, SAXNotSupportedException {
if (Verifier.FEATURE_HANDLER.equals(feature) ||
Verifier.FEATURE_FILTER.equals(feature))
return true;
throw new SAXNotRecognizedException(feature);
}
/**
* Sets feature value
*
* @param feature feature name
* @param value feature value
*/
public void setFeature(String feature, boolean value)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(feature);
}
/**
* Gets property value
*
* @param property property name
*/
public Object getProperty(String property)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(property);
}
/**
* Sets property value
*
* @param property property name
* @param value property value
*/
public void setProperty(String property, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(property);
}
private EntityResolver resolver = null;
/**
* Sets an EntityResolver
*
* This entity resolver is used to resolve entities encountered while
* parsing a schema.
*/
public void setEntityResolver( EntityResolver _resolver ) {
this.resolver = _resolver;
}
/**
* Gets the current entity resolver, which was set by
* the SetEntityResolver method.
*/
public EntityResolver getEntityResolver() {
return resolver;
}
/**
* Creates a new instance of a VerifierFactory.
*
* @deprecated
*/
public static VerifierFactory newInstance()
throws VerifierConfigurationException {
return newInstance("http://www.xml.gr.jp/xmlns/relaxNamespace");
}
/**
* Creates a new instance of a VerifierFactory for the specified schema language.
*
* @param language
* URI that specifies the schema language.
*
*
* It is preferable to use the namespace URI of the schema language * to designate the schema language. For example, * *
| URI | *language | *
| http://relaxng.org/ns/structure/0.9 | ** RELAX NG * | *
| http://www.xml.gr.jp/xmlns/relaxCore | ** RELAX Core * | *
| http://www.xml.gr.jp/xmlns/relaxNamespace | ** RELAX Namespace * | *
| http://www.thaiopensource.com/trex | ** TREX * | *
| http://www.w3.org/2001/XMLSchema | ** W3C XML Schema * | *
| http://www.w3.org/XML/1998/namespace | ** XML DTD * | *
* Implementations of this interface are discovered through
* META-INF/services, just like JAXP. This object then
* provides VerifierFactory implementation for the specified schema language.
*
* @author Kohsuke KAWAGUCHI
*/
public interface VerifierFactoryLoader {
/**
* returns a VerifierFactory that supports the specified schema language,
* or returns null if it's not supported.
*/
VerifierFactory createFactory( String schemaLanguage );
}
isorelax-20041111/org/iso_relax/verifier/VerifierFilter.java 0000664 0000000 0000000 00000001700 11250544366 0023752 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier;
import org.xml.sax.XMLFilter;
/**
* XMLFilter implementation that validates a document.
*
*
* An instance of this interface can be obtained through the * {@link Verifier#getVerifierFilter} method. * *
* The implementation validates incoming SAX events and then pass it * to the successive SAX handlers. * * @since Feb. 23, 2001 * @version Feb. 24, 2001 * @author ASAMI, Tomoharu (asami@zeomtech.com) */ public interface VerifierFilter extends XMLFilter { /** * checks if the document was valid. * *
* This method can be only called after this handler receives * the endDocument event. * * @return * true if the document was valid, * false if not. * * @exception IllegalStateException * If this method is called before the endDocument event is dispatched. */ boolean isValid() throws IllegalStateException; } isorelax-20041111/org/iso_relax/verifier/VerifierHandler.java 0000664 0000000 0000000 00000002171 11250544366 0024105 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier; import org.xml.sax.ContentHandler; /** * SAX2 ContentHandler implementation that validates a document. * *
* An instance of this interface can be obtained through the * {@link Verifier#getVerifierHandler} method. * *
* The implementation validates incoming SAX events. * The application can check the result by calling the isValid method. * * @since Feb. 23, 2001 * @version Feb. 24, 2001 * @author ASAMI, Tomoharu (asami@zeomtech.com) */ public interface VerifierHandler extends ContentHandler { /** * Checks if the document was valid. * *
* This method can be only called after this handler receives
* the endDocument event.
*
*
* If you need to know the error at an earlier moment,
* you should set an error handler to {@link Verifier}.
*
* @return
* true if the document was valid,
* false if not.
*
* @exception IllegalStateException
* If this method is called before the endDocument event is dispatched.
*/
boolean isValid() throws IllegalStateException;
}
isorelax-20041111/org/iso_relax/verifier/impl/ 0000775 0000000 0000000 00000000000 11250544366 0021131 5 ustar 00root root 0000000 0000000 isorelax-20041111/org/iso_relax/verifier/impl/ForkContentHandler.java 0000664 0000000 0000000 00000006003 11250544366 0025525 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier.impl;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
/**
* ContentHandler that "forks" the incoming SAX2 events to
* two ContentHandlers.
*
*
* @version $Id: ForkContentHandler.java,v 1.3 2003/05/30 23:46:33 kkawa Exp $
* @author Kohsuke KAWAGUCHI
*/
public class ForkContentHandler implements ContentHandler {
/**
* Creates a ForkContentHandler.
*
* @param first
* This handler will receive a SAX event first.
* @param second
* This handler will receive a SAX event after the first handler
* receives it.
*/
public ForkContentHandler( ContentHandler first, ContentHandler second ) {
lhs = first;
rhs = second;
}
/**
* Creates ForkContentHandlers so that the specified handlers
* will receive SAX events in the order of the array.
*/
public static ContentHandler create( ContentHandler[] handlers ) {
if(handlers.length==0)
throw new IllegalArgumentException();
ContentHandler result = handlers[0];
for( int i=1; i
* A verifier implementation can use this class to support VerifierFilter functionality.
*
*
* To use this class, implement the {@link Verifier#getVerifierFilter()} method
* as follows:
*
* Also, usually you may want to override
* This class is useful as the base class of the verifier implementation.
*
*
* The only remaining method that has to be implemented by the derived
* class is the makeEvent method to use it.
*
* @author
* ASAMI, Tomoharu (asami@zeomtech.com)
* Kohsuke KAWAGUCHI
*/
public class SAXEventGenerator implements IDOMVisitor {
private Node root_;
private boolean needDocumentEmulation_ = true;
private String systemID_;
private String publicID_;
private DTDHandler dtd_;
private ContentHandler content_;
private DeclHandler decl_;
private LexicalHandler lexical_;
private ErrorHandler error_;
private final NamespaceSupport namespace_ = new NamespaceSupport();
public SAXEventGenerator(Node node) {
root_ = node;
DefaultHandler handler = new DefaultHandler();
dtd_ = handler;
content_ = handler;
error_ = handler;
lexical_ = new LexicalHandlerBase();
decl_ = new DeclHandlerBase();
}
public void setDocumentEmulation(boolean emulate) {
needDocumentEmulation_ = emulate;
}
public void setDTDHandler(DTDHandler dtd) {
dtd_ = dtd;
}
public void setContentHandler(ContentHandler content) {
content_ = content;
}
public void setLexicalHandler(LexicalHandler lexical) {
lexical_ = lexical;
}
public void setDeclHandler(DeclHandler decl) {
decl_ = decl;
}
public void setErrorHandler(ErrorHandler error) {
error_ = error;
}
public void makeEvent() throws SAXException {
try {
if (!(root_ instanceof Document) && needDocumentEmulation_) {
emulateStartDocument();
UDOMVisitor.traverse(root_, this);
emulateEndDocument();
} else {
UDOMVisitor.traverse(root_, this);
}
} catch (DOMVisitorException e) {
Exception cause = e.getCauseException();
if (cause == null) {
throw (new SAXException(e.getMessage()));
} else if (cause instanceof SAXException) {
throw ((SAXException)cause);
} else {
throw (new SAXException(e.getMessage()));
}
}
}
public void makeEvent(ContentHandler handler) throws SAXException {
setContentHandler(handler);
makeEvent();
}
public void emulateStartDocument() {
try {
_handleLocator();
content_.startDocument();
} catch (SAXException e) {
_errorReport(e);
}
}
public void emulateEndDocument() {
try {
content_.endDocument();
} catch (SAXException e) {
_errorReport(e);
}
}
public boolean enter(Element element) {
try {
namespace_.pushContext();
String namespaceURI = element.getNamespaceURI();
if (namespaceURI == null) {
namespaceURI = "";
}
String localName = element.getLocalName();
String qName = element.getTagName();
if(localName==null) localName = qName;
NamedNodeMap attrMap = element.getAttributes();
AttributesImpl attrs = new AttributesImpl();
int size = attrMap.getLength();
for (int i = 0;i < size;i++) {
Attr attr = (Attr)attrMap.item(i);
String attrNamespaceURI = attr.getNamespaceURI();
if (attrNamespaceURI == null) {
attrNamespaceURI = "";
}
String attrLocalName = attr.getLocalName();
String attrQName = attr.getName();
if(attrLocalName==null) attrLocalName = attrQName;
String attrValue = attr.getValue();
if (attrQName.startsWith("xmlns")) {
String prefix;
int index = attrQName.indexOf(':');
if (index == -1) {
prefix = "";
} else {
prefix = attrQName.substring(index + 1);
}
if (!namespace_.declarePrefix(prefix, attrValue)) {
_errorReport("bad prefix = " + prefix);
} else {
content_.startPrefixMapping(prefix, attrValue);
}
} else {
attrs.addAttribute(
attrNamespaceURI,
attrLocalName,
attrQName,
"CDATA",
attrValue
);
}
}
content_.startElement(namespaceURI, localName, qName, attrs);
} catch (SAXException e) {
_errorReport(e);
}
return (true);
}
public boolean enter(Attr attr) {
return (false);
}
public boolean enter(Text text) {
try {
String data = text.getData();
content_.characters(data.toCharArray(), 0, data.length());
} catch (SAXException e) {
_errorReport(e);
}
return (false);
}
public boolean enter(CDATASection cdata) {
try {
lexical_.startCDATA();
String data = cdata.getData();
content_.characters(data.toCharArray(), 0, data.length());
lexical_.endCDATA();
} catch (SAXException e) {
_errorReport(e);
}
return (false);
}
public boolean enter(EntityReference entityRef) {
try {
lexical_.startEntity(entityRef.getNodeName());
} catch (SAXException e) {
_errorReport(e);
}
return (true);
}
public boolean enter(Entity entity) {
return (false);
}
public boolean enter(ProcessingInstruction pi) {
try {
content_.processingInstruction(pi.getTarget(), pi.getData());
} catch (SAXException e) {
_errorReport(e);
}
return (false);
}
public boolean enter(Comment comment) {
try {
String data = comment.getData();
lexical_.comment(data.toCharArray(), 0, data.length());
} catch (SAXException e) {
_errorReport(e);
}
return (false);
}
public boolean enter(Document doc) {
try {
_handleLocator();
content_.startDocument();
_handleDoctype(doc.getDoctype());
} catch (SAXException e) {
_errorReport(e);
}
return (true);
}
private void _handleLocator() {
if (systemID_ == null && publicID_ == null) {
return;
}
_locatorEvent(systemID_, publicID_);
}
private void _locatorEvent(String systemID, String publicID) {
LocatorImpl locator = new LocatorImpl();
locator.setSystemId(systemID_);
locator.setPublicId(publicID_);
locator.setLineNumber(-1);
locator.setColumnNumber(-1);
content_.setDocumentLocator(locator);
}
private void _handleDoctype(DocumentType doctype) {
try {
if (doctype == null) {
return;
}
String systemID = doctype.getSystemId();
String publicID = doctype.getPublicId();
String internalSubset = doctype.getInternalSubset();
if (systemID != null) {
lexical_.startDTD(doctype.getName(), publicID, systemID);
if (internalSubset == null) {
lexical_.endDTD();
_handleEntities(doctype);
} else {
_handleEntities(doctype);
lexical_.endDTD();
}
} else {
_handleEntities(doctype);
}
} catch (SAXException e) {
_errorReport(e);
}
}
private void _handleEntities(DocumentType doctype) {
try {
NamedNodeMap entities = doctype.getEntities();
int nEntities = entities.getLength();
for (int i = 0;i < nEntities;i++) {
Entity entity = (Entity)entities.item(i);
String publicID = entity.getPublicId();
String systemID = entity.getSystemId();
String notationName = entity.getNotationName();
if (publicID != null || systemID != null) {
_handleExternalEntity(
entity.getNodeName(),
publicID,
systemID,
notationName
);
} else {
_handleInternalEntity(entity);
}
}
NamedNodeMap notations = doctype.getNotations();
int nNotations = notations.getLength();
for (int i = 0;i < nNotations;i++) {
Notation notation = (Notation)notations.item(i);
String publicID = notation.getPublicId();
String systemID = notation.getSystemId();
dtd_.notationDecl(notation.getNodeName(), publicID, systemID);
}
} catch (SAXException e) {
_errorReport(e);
}
}
private void _handleExternalEntity(
String name,
String publicID,
String systemID,
String notationName
) {
try {
if (notationName == null) {
decl_.externalEntityDecl(name, publicID, systemID);
} else {
dtd_.unparsedEntityDecl(
name,
publicID,
systemID,
notationName
);
}
} catch (SAXException e) {
_errorReport(e);
}
}
private void _handleInternalEntity(Entity entity) {
try {
decl_.internalEntityDecl(
entity.getNodeName(),
UDOM.getXMLText(entity)
);
} catch (SAXException e) {
_errorReport(e);
}
}
public boolean enter(DocumentType doctype) {
return (false);
}
public boolean enter(DocumentFragment docfrag) {
return (true);
}
public boolean enter(Notation notation) {
return (false);
}
public boolean enter(Node node) {
return (false);
}
public void leave(Element element) {
try {
String namespaceURI = element.getNamespaceURI();
if (namespaceURI == null) {
namespaceURI = "";
}
String localName = element.getLocalName();
String qName = element.getTagName();
if(localName==null) localName=qName;
content_.endElement(namespaceURI, localName, qName);
for (Enumeration e=namespace_.getDeclaredPrefixes(); e.hasMoreElements(); )
content_.endPrefixMapping( (String)e.nextElement() );
namespace_.popContext();
} catch (SAXException e) {
_errorReport(e);
}
}
public void leave(Attr attr) {
}
public void leave(Text text) {
}
public void leave(CDATASection cdata) {
}
public void leave(EntityReference entityRef) {
try {
lexical_.endEntity(entityRef.getNodeName());
} catch (SAXException e) {
_errorReport(e);
}
}
public void leave(Entity entity) {
}
public void leave(ProcessingInstruction pi) {
}
public void leave(Comment comment) {
}
public void leave(Document doc) {
try {
content_.endDocument();
} catch (SAXException e) {
_errorReport(e);
}
}
public void leave(DocumentType doctype) {
}
public void leave(DocumentFragment docfrag) {
}
public void leave(Notation notation) {
}
public void leave(Node node) {
}
private void _errorReport(String message) throws DOMVisitorException {
_errorReport(
new SAXParseException(
message,
publicID_,
systemID_,
-1,
-1
)
);
}
private void _errorReport(SAXException e) throws DOMVisitorException {
try {
SAXParseException parseException;
if (e instanceof SAXParseException) {
parseException = (SAXParseException)e;
} else {
parseException = new SAXParseException(
e.getMessage(),
publicID_,
systemID_,
-1,
-1,
e
);
}
error_.fatalError(parseException);
throw new DOMVisitorException(e);
} catch (SAXException ee) {
throw new DOMVisitorException(ee);
}
}
}
isorelax-20041111/org/iso_relax/verifier/impl/VerifierFilterImpl.java 0000664 0000000 0000000 00000007275 11250544366 0025552 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier.impl;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierFilter;
import org.iso_relax.verifier.VerifierHandler;
import org.xml.sax.Attributes;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.XMLFilterImpl;
/**
* plain vanilla {@link VerifierFilter} implementation.
*
*
* public VerifierFilter getVerifierFilter() throws SAXException {
* return new VerifierFilterImpl(getVerifierHandler());
* }
*
*
* setErrorHandler method so that
* your VerifierHandler will send errors to that handler.
*
* @version $Id: VerifierFilterImpl.java,v 1.5 2003/05/30 23:46:33 kkawa Exp $
* @author Kohsuke KAWAGUCHI
*/
public class VerifierFilterImpl extends XMLFilterImpl implements VerifierFilter {
public VerifierFilterImpl( Verifier _verifier ) throws SAXException {
this.verifier = _verifier;
this.core = verifier.getVerifierHandler();
}
private final Verifier verifier;
private final VerifierHandler core;
public boolean isValid() {
return core.isValid();
}
public void setErrorHandler( ErrorHandler handler ) {
super.setErrorHandler(handler);
// we need to call the setErrorHandler method of the verifier,
// so that the verifier handler will use this error handler from now on.
verifier.setErrorHandler(handler);
}
public void setEntityResolver( EntityResolver resolver ) {
super.setEntityResolver(resolver);
verifier.setEntityResolver(resolver);
}
//
//
// ContentHandler events
//
//
public void setDocumentLocator (Locator locator) {
core.setDocumentLocator(locator);
super.setDocumentLocator(locator);
}
public void startDocument() throws SAXException {
core.startDocument();
super.startDocument();
}
public void endDocument () throws SAXException {
core.endDocument();
super.endDocument();
}
public void startPrefixMapping (String prefix, String uri) throws SAXException {
core.startPrefixMapping(prefix,uri);
super.startPrefixMapping(prefix,uri);
}
public void endPrefixMapping (String prefix) throws SAXException {
core.endPrefixMapping(prefix);
super.endPrefixMapping(prefix);
}
public void startElement (String uri, String localName, String qName, Attributes attributes) throws SAXException {
core.startElement(uri,localName,qName,attributes);
super.startElement(uri,localName,qName,attributes);
}
public void endElement (String uri, String localName, String qName) throws SAXException {
core.endElement(uri,localName,qName);
super.endElement(uri,localName,qName);
}
public void characters (char ch[], int start, int length) throws SAXException {
core.characters(ch,start,length);
super.characters(ch,start,length);
}
public void ignorableWhitespace (char ch[], int start, int length) throws SAXException {
core.ignorableWhitespace(ch,start,length);
super.ignorableWhitespace(ch,start,length);
}
public void processingInstruction (String target, String data) throws SAXException {
core.processingInstruction(target,data);
super.processingInstruction(target,data);
}
public void skippedEntity (String name) throws SAXException {
core.skippedEntity(name);
super.skippedEntity(name);
}
}
isorelax-20041111/org/iso_relax/verifier/impl/VerifierImpl.java 0000664 0000000 0000000 00000011223 11250544366 0024370 0 ustar 00root root 0000000 0000000 package org.iso_relax.verifier.impl;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierConfigurationException;
import org.iso_relax.verifier.VerifierFilter;
import org.iso_relax.verifier.VerifierHandler;
import org.w3c.dom.Node;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
/**
* Partial implementation of {@link Verifier}.
*
* getVerifierHandler method. Please be noted
* that applications can call the setErrorHandler method
* after the getVerifierHandler method and that change
* should take effect.
*
*
* @version $Id: VerifierImpl.java,v 1.4 2003/05/30 23:46:33 kkawa Exp $
* @author Kohsuke KAWAGUCHI
*/
public abstract class VerifierImpl implements Verifier
{
protected XMLReader reader;
protected VerifierImpl() throws VerifierConfigurationException {
prepareXMLReader();
}
/**
* Creates and sets a sole instance of XMLReader which will be used
* by this verifier.
*/
protected void prepareXMLReader() throws VerifierConfigurationException {
try {
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(true);
reader = factory.newSAXParser().getXMLReader();
} catch( SAXException e ) {
throw new VerifierConfigurationException(e);
} catch( ParserConfigurationException pce ) {
throw new VerifierConfigurationException(pce);
}
}
public boolean isFeature(String feature)
throws SAXNotRecognizedException, SAXNotSupportedException {
if (FEATURE_HANDLER.equals(feature) ||
FEATURE_FILTER.equals(feature))
return true;
throw new SAXNotRecognizedException(feature);
}
public void setFeature(String feature, boolean value)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(feature);
}
public Object getProperty(String property)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(property);
}
public void setProperty(String property, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException {
throw new SAXNotRecognizedException(property);
}
// default error handler must not report any error.
protected ErrorHandler errorHandler = new ErrorHandler(){
public void warning( SAXParseException e ) {}
public void error( SAXParseException e ) {}
public void fatalError( SAXParseException e ) {}
};
public void setErrorHandler(ErrorHandler handler) {
this.errorHandler = handler;
}
protected EntityResolver entityResolver;
public void setEntityResolver(EntityResolver resolver ) {
this.entityResolver = resolver;
}
public boolean verify(String uri) throws SAXException, IOException {
return verify( new InputSource(uri) );
}
public boolean verify(InputSource source) throws SAXException, IOException {
VerifierHandler handler = getVerifierHandler();
reader.setErrorHandler(errorHandler);
if(entityResolver!=null)
reader.setEntityResolver(entityResolver);
reader.setContentHandler(handler);
reader.parse(source);
return handler.isValid();
}
public boolean verify(File f) throws SAXException, IOException {
String uri = "file:" + f.getAbsolutePath();
if (File.separatorChar == '\\') {
uri = uri.replace('\\', '/');
}
return verify(new InputSource(uri));
}
public boolean verify(Node node) throws SAXException {
SAXEventGenerator generator = new SAXEventGenerator(node);
// generate startDocument/endDocument events
generator.setDocumentEmulation(true);
generator.setErrorHandler(errorHandler);
VerifierHandler handler = getVerifierHandler();
generator.makeEvent(handler);
return handler.isValid();
}
public abstract VerifierHandler getVerifierHandler() throws SAXException;
private VerifierFilter filter;
public VerifierFilter getVerifierFilter() throws SAXException {
if(filter==null)
filter = new VerifierFilterImpl(this);
return filter;
}
}