com.thaiopensource.relaxng.pattern.SchemaBuilderImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of wicketstuff-jing Show documentation
Show all versions of wicketstuff-jing Show documentation
Jing is a validator for RELAX NG and other schema languages. This
project was taken from http://code.google.com/p/jing-trang and
mavenized for inclusion in the Wicket Stuff HTML Validator.
The code was taken from the 20091111 release.
package com.thaiopensource.relaxng.pattern;
import com.thaiopensource.relaxng.parse.BuildException;
import com.thaiopensource.relaxng.parse.Context;
import com.thaiopensource.relaxng.parse.DataPatternBuilder;
import com.thaiopensource.relaxng.parse.Div;
import com.thaiopensource.relaxng.parse.ElementAnnotationBuilder;
import com.thaiopensource.relaxng.parse.Grammar;
import com.thaiopensource.relaxng.parse.GrammarSection;
import com.thaiopensource.relaxng.parse.IllegalSchemaException;
import com.thaiopensource.relaxng.parse.Include;
import com.thaiopensource.relaxng.parse.IncludedGrammar;
import com.thaiopensource.relaxng.parse.ParseReceiver;
import com.thaiopensource.relaxng.parse.Parseable;
import com.thaiopensource.relaxng.parse.ParsedPatternFuture;
import com.thaiopensource.relaxng.parse.SchemaBuilder;
import com.thaiopensource.relaxng.parse.Scope;
import com.thaiopensource.relaxng.parse.SubParseable;
import com.thaiopensource.relaxng.parse.SubParser;
import com.thaiopensource.util.Localizer;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.xml.util.Name;
import org.relaxng.datatype.Datatype;
import org.relaxng.datatype.DatatypeBuilder;
import org.relaxng.datatype.DatatypeException;
import org.relaxng.datatype.DatatypeLibrary;
import org.relaxng.datatype.DatatypeLibraryFactory;
import org.relaxng.datatype.ValidationContext;
import org.xml.sax.ErrorHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SchemaBuilderImpl extends AnnotationsImpl implements
ElementAnnotationBuilder,
SchemaBuilder {
private final SchemaBuilderImpl parent;
private boolean hadError = false;
private final SubParser subParser;
private final SchemaPatternBuilder pb;
private final DatatypeLibraryFactory datatypeLibraryFactory;
private final String inheritNs;
private final ErrorHandler eh;
private final OpenIncludes openIncludes;
private final AttributeNameClassChecker attributeNameClassChecker = new AttributeNameClassChecker();
static final Localizer localizer = new Localizer(SchemaBuilderImpl.class);
static class OpenIncludes {
final String uri;
final OpenIncludes parent;
OpenIncludes(String uri, OpenIncludes parent) {
this.uri = uri;
this.parent = parent;
}
}
static public Pattern parse(Parseable parseable,
ErrorHandler eh,
DatatypeLibraryFactory datatypeLibraryFactory,
SchemaPatternBuilder pb,
boolean isAttributesPattern)
throws IllegalSchemaException, IOException, SAXException {
try {
SchemaBuilderImpl sb = new SchemaBuilderImpl(parseable,
eh,
new BuiltinDatatypeLibraryFactory(datatypeLibraryFactory),
pb);
Pattern pattern = parseable.parse(sb, new RootScope(sb));
if (isAttributesPattern)
pattern = sb.wrapAttributesPattern(pattern);
return sb.expandPattern(pattern);
}
catch (BuildException e) {
throw unwrapBuildException(e);
}
}
static public PatternFuture installHandlers(ParseReceiver parser,
XMLReader xr,
ErrorHandler eh,
DatatypeLibraryFactory dlf,
SchemaPatternBuilder pb)
throws SAXException {
final SchemaBuilderImpl sb = new SchemaBuilderImpl(parser,
eh,
new BuiltinDatatypeLibraryFactory(dlf),
pb);
final ParsedPatternFuture pf = parser.installHandlers(xr, sb, new RootScope(sb));
return new PatternFuture() {
public Pattern getPattern(boolean isAttributesPattern) throws IllegalSchemaException, SAXException, IOException {
try {
Pattern pattern = pf.getParsedPattern();
if (isAttributesPattern)
pattern = sb.wrapAttributesPattern(pattern);
return sb.expandPattern(pattern);
}
catch (BuildException e) {
throw unwrapBuildException(e);
}
}
};
}
static public RuntimeException unwrapBuildException(BuildException e) throws SAXException, IllegalSchemaException, IOException {
Throwable t = e.getCause();
if (t instanceof IOException)
throw (IOException)t;
if (t instanceof RuntimeException)
return (RuntimeException)t;
if (t instanceof IllegalSchemaException)
throw new IllegalSchemaException();
if (t instanceof SAXException)
throw (SAXException)t;
if (t instanceof Exception)
throw new SAXException((Exception)t);
throw new SAXException(t.getClass().getName() + " thrown");
}
private Pattern wrapAttributesPattern(Pattern pattern) {
// XXX where can we get a locator from?
return makeElement(makeAnyName(null, null), pattern, null, null);
}
private Pattern expandPattern(Pattern pattern) throws IllegalSchemaException, BuildException {
if (!hadError) {
try {
pattern.checkRecursion(0);
pattern = pattern.expand(pb);
pattern.checkRestrictions(Pattern.START_CONTEXT, null, null);
if (!hadError)
return pattern;
}
catch (SAXParseException e) {
error(e);
}
catch (SAXException e) {
throw new BuildException(e);
}
catch (RestrictionViolationException e) {
if (e.getName() != null)
error(e.getMessageId(), NameFormatter.format(e.getName()), e.getLocator());
else if (e.getNamespaceUri() != null)
error(e.getMessageId(), e.getNamespaceUri(), e.getLocator());
else
error(e.getMessageId(), e.getLocator());
}
}
throw new IllegalSchemaException();
}
private SchemaBuilderImpl(SubParser subParser,
ErrorHandler eh,
DatatypeLibraryFactory datatypeLibraryFactory,
SchemaPatternBuilder pb) {
this.parent = null;
this.subParser = subParser;
this.eh = eh;
this.datatypeLibraryFactory = datatypeLibraryFactory;
this.pb = pb;
this.inheritNs = "";
this.openIncludes = null;
}
private SchemaBuilderImpl(String inheritNs,
String uri,
SchemaBuilderImpl parent) {
this.parent = parent;
this.subParser = parent.subParser;
this.eh = parent.eh;
this.datatypeLibraryFactory = parent.datatypeLibraryFactory;
this.pb = parent.pb;
this.inheritNs = parent.resolveInherit(inheritNs);
this.openIncludes = new OpenIncludes(uri, parent.openIncludes);
}
public Pattern makeChoice(List patterns, Locator loc, AnnotationsImpl anno)
throws BuildException {
int nPatterns = patterns.size();
if (nPatterns <= 0)
throw new IllegalArgumentException();
Pattern result = patterns.get(0);
for (int i = 1; i < nPatterns; i++)
result = pb.makeChoice(result, patterns.get(i));
return result;
}
public Pattern makeInterleave(List patterns, Locator loc, AnnotationsImpl anno)
throws BuildException {
int nPatterns = patterns.size();
if (nPatterns <= 0)
throw new IllegalArgumentException();
Pattern result = patterns.get(0);
for (int i = 1; i < nPatterns; i++)
result = pb.makeInterleave(result, patterns.get(i));
return result;
}
public Pattern makeGroup(List patterns, Locator loc, AnnotationsImpl anno)
throws BuildException {
int nPatterns = patterns.size();
if (nPatterns <= 0)
throw new IllegalArgumentException();
Pattern result = patterns.get(0);
for (int i = 1; i < nPatterns; i++)
result = pb.makeGroup(result, patterns.get(i));
return result;
}
public Pattern makeOneOrMore(Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeOneOrMore(p);
}
public Pattern makeZeroOrMore(Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeZeroOrMore(p);
}
public Pattern makeOptional(Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeOptional(p);
}
public Pattern makeList(Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeList(p, loc);
}
public Pattern makeMixed(Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeMixed(p);
}
public Pattern makeEmpty(Locator loc, AnnotationsImpl anno) {
return pb.makeEmpty();
}
public Pattern makeNotAllowed(Locator loc, AnnotationsImpl anno) {
return pb.makeUnexpandedNotAllowed();
}
public Pattern makeText(Locator loc, AnnotationsImpl anno) {
return pb.makeText();
}
public Pattern makeErrorPattern() {
return pb.makeError();
}
public NameClass makeErrorNameClass() {
return new ErrorNameClass();
}
public Pattern makeAttribute(NameClass nc, Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
String messageId = attributeNameClassChecker.checkNameClass(nc);
if (messageId != null)
error(messageId, loc);
return pb.makeAttribute(nc, p, loc);
}
public Pattern makeElement(NameClass nc, Pattern p, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeElement(nc, p, loc);
}
private class DummyDataPatternBuilder implements DataPatternBuilder {
public void addParam(String name, String value, Context context, String ns, Locator loc, AnnotationsImpl anno)
throws BuildException {
}
public void annotation(VoidValue ea)
throws BuildException {
}
public Pattern makePattern(Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeError();
}
public Pattern makePattern(Pattern except, Locator loc, AnnotationsImpl anno)
throws BuildException {
return pb.makeError();
}
}
private class ValidationContextImpl implements ValidationContext {
private final ValidationContext vc;
private final String ns;
ValidationContextImpl(ValidationContext vc, String ns) {
this.vc = vc;
this.ns = ns.length() == 0 ? null : ns;
}
public String resolveNamespacePrefix(String prefix) {
String result = prefix.length() == 0 ? ns : vc.resolveNamespacePrefix(prefix);
if (result == INHERIT_NS) {
if (inheritNs.length() == 0)
return null;
return inheritNs;
}
return result;
}
public String getBaseUri() {
return vc.getBaseUri();
}
public boolean isUnparsedEntity(String entityName) {
return vc.isUnparsedEntity(entityName);
}
public boolean isNotation(String notationName) {
return vc.isNotation(notationName);
}
}
private class DataPatternBuilderImpl implements DataPatternBuilder {
private final DatatypeBuilder dtb;
private final Name dtName;
private final List params = new ArrayList();
DataPatternBuilderImpl(DatatypeBuilder dtb, Name dtName) {
this.dtb = dtb;
this.dtName = dtName;
}
public void addParam(String name, String value, Context context, String ns, Locator loc, AnnotationsImpl anno)
throws BuildException {
try {
dtb.addParameter(name, value, new ValidationContextImpl(context, ns));
params.add(name);
params.add(value);
}
catch (DatatypeException e) {
String detail = e.getMessage();
int pos = e.getIndex();
String displayedParam;
if (pos == DatatypeException.UNKNOWN)
displayedParam = null;
else
displayedParam = displayParam(value, pos);
if (displayedParam != null) {
if (detail != null)
error("invalid_param_detail_display", detail, displayedParam, loc);
else
error("invalid_param_display", displayedParam, loc);
}
else if (detail != null)
error("invalid_param_detail", detail, loc);
else
error("invalid_param", loc);
}
}
public void annotation(VoidValue ea)
throws BuildException {
}
String displayParam(String value, int pos) {
if (pos < 0)
pos = 0;
else if (pos > value.length())
pos = value.length();
return localizer.message("display_param", value.substring(0, pos), value.substring(pos));
}
public Pattern makePattern(Locator loc, AnnotationsImpl anno)
throws BuildException {
try {
return pb.makeData(dtb.createDatatype(), dtName, params);
}
catch (DatatypeException e) {
String detail = e.getMessage();
if (detail != null)
error("invalid_params_detail", detail, loc);
else
error("invalid_params", loc);
return pb.makeError();
}
}
public Pattern makePattern(Pattern except, Locator loc, AnnotationsImpl anno)
throws BuildException {
try {
return pb.makeDataExcept(dtb.createDatatype(), dtName, params, except, loc);
}
catch (DatatypeException e) {
String detail = e.getMessage();
if (detail != null)
error("invalid_params_detail", detail, loc);
else
error("invalid_params", loc);
return pb.makeError();
}
}
}
public DataPatternBuilder makeDataPatternBuilder(String datatypeLibrary, String type, Locator loc)
throws BuildException {
DatatypeLibrary dl = datatypeLibraryFactory.createDatatypeLibrary(datatypeLibrary);
if (dl == null)
error("unrecognized_datatype_library", datatypeLibrary, loc);
else {
try {
return new DataPatternBuilderImpl(dl.createDatatypeBuilder(type), new Name(datatypeLibrary, type));
}
catch (DatatypeException e) {
String detail = e.getMessage();
if (detail != null)
error("unsupported_datatype_detail", datatypeLibrary, type, detail, loc);
else
error("unrecognized_datatype", datatypeLibrary, type, loc);
}
}
return new DummyDataPatternBuilder();
}
public Pattern makeValue(String datatypeLibrary, String type, String value, Context context, String ns,
Locator loc, AnnotationsImpl anno) throws BuildException {
DatatypeLibrary dl = datatypeLibraryFactory.createDatatypeLibrary(datatypeLibrary);
if (dl == null)
error("unrecognized_datatype_library", datatypeLibrary, loc);
else {
try {
DatatypeBuilder dtb = dl.createDatatypeBuilder(type);
try {
Datatype dt = dtb.createDatatype();
Object obj = dt.createValue(value, new ValidationContextImpl(context, ns));
if (obj != null)
return pb.makeValue(dt, new Name(datatypeLibrary, type), obj, value);
error("invalid_value", value, loc);
}
catch (DatatypeException e) {
String detail = e.getMessage();
if (detail != null)
error("datatype_requires_param_detail", detail, loc);
else
error("datatype_requires_param", loc);
}
}
catch (DatatypeException e) {
error("unrecognized_datatype", datatypeLibrary, type, loc);
}
}
return pb.makeError();
}
static class GrammarImpl implements Grammar, Div, IncludedGrammar {
private final SchemaBuilderImpl sb;
private final Map defines;
private final RefPattern startRef;
private final Scope parent;
private GrammarImpl(SchemaBuilderImpl sb, Scope parent) {
this.sb = sb;
this.parent = parent;
this.defines = new HashMap();
this.startRef = new RefPattern(null);
}
protected GrammarImpl(SchemaBuilderImpl sb, GrammarImpl g) {
this.sb = sb;
parent = g.parent;
startRef = g.startRef;
defines = g.defines;
}
public Pattern endGrammar(Locator loc, AnnotationsImpl anno) throws BuildException {
for (String name : defines.keySet()) {
RefPattern rp = defines.get(name);
if (rp.getPattern() == null) {
sb.error("reference_to_undefined", name, rp.getRefLocator());
rp.setPattern(sb.pb.makeError());
}
}
Pattern start = startRef.getPattern();
if (start == null) {
sb.error("missing_start_element", loc);
start = sb.pb.makeError();
}
return start;
}
public void endDiv(Locator loc, AnnotationsImpl anno) throws BuildException {
// nothing to do
}
public Pattern endIncludedGrammar(Locator loc, AnnotationsImpl anno) throws BuildException {
return null;
}
public void define(String name, GrammarSection.Combine combine, Pattern pattern, Locator loc, AnnotationsImpl anno)
throws BuildException {
define(lookup(name), combine, pattern, loc);
}
private void define(RefPattern rp, GrammarSection.Combine combine, Pattern pattern, Locator loc)
throws BuildException {
switch (rp.getReplacementStatus()) {
case RefPattern.REPLACEMENT_KEEP:
if (combine == null) {
if (rp.isCombineImplicit()) {
if (rp.getName() == null)
sb.error("duplicate_start", loc);
else
sb.error("duplicate_define", rp.getName(), loc);
}
else
rp.setCombineImplicit();
}
else {
byte combineType = (combine == COMBINE_CHOICE ? RefPattern.COMBINE_CHOICE : RefPattern.COMBINE_INTERLEAVE);
if (rp.getCombineType() != RefPattern.COMBINE_NONE
&& rp.getCombineType() != combineType) {
if (rp.getName() == null)
sb.error("conflict_combine_start", loc);
else
sb.error("conflict_combine_define", rp.getName(), loc);
}
rp.setCombineType(combineType);
}
if (rp.getPattern() == null)
rp.setPattern(pattern);
else if (rp.getCombineType() == RefPattern.COMBINE_INTERLEAVE)
rp.setPattern(sb.pb.makeInterleave(rp.getPattern(), pattern));
else
rp.setPattern(sb.pb.makeChoice(rp.getPattern(), pattern));
break;
case RefPattern.REPLACEMENT_REQUIRE:
rp.setReplacementStatus(RefPattern.REPLACEMENT_IGNORE);
break;
case RefPattern.REPLACEMENT_IGNORE:
break;
}
}
public void topLevelAnnotation(VoidValue ea) throws BuildException {
}
public void topLevelComment(CommentListImpl comments) throws BuildException {
}
private RefPattern lookup(String name) {
if (name == START)
return startRef;
return lookup1(name);
}
private RefPattern lookup1(String name) {
RefPattern p = defines.get(name);
if (p == null) {
p = new RefPattern(name);
defines.put(name, p);
}
return p;
}
public Pattern makeRef(String name, Locator loc, AnnotationsImpl anno) throws BuildException {
RefPattern p = lookup1(name);
if (p.getRefLocator() == null && loc != null)
p.setRefLocator(loc);
return p;
}
public Pattern makeParentRef(String name, Locator loc, AnnotationsImpl anno) throws BuildException {
if (parent == null) {
sb.error("parent_ref_outside_grammar", loc);
return sb.makeErrorPattern();
}
return parent.makeRef(name, loc, anno);
}
public Div makeDiv() {
return this;
}
public Include makeInclude() {
return new IncludeImpl(sb, this);
}
}
static class RootScope implements Scope {
private final SchemaBuilderImpl sb;
RootScope(SchemaBuilderImpl sb) {
this.sb = sb;
}
public Pattern makeParentRef(String name, Locator loc, AnnotationsImpl anno) throws BuildException {
sb.error("parent_ref_outside_grammar", loc);
return sb.makeErrorPattern();
}
public Pattern makeRef(String name, Locator loc, AnnotationsImpl anno) throws BuildException {
sb.error("ref_outside_grammar", loc);
return sb.makeErrorPattern();
}
}
static class Override {
Override(RefPattern prp, Override next) {
this.prp = prp;
this.next = next;
}
final RefPattern prp;
final Override next;
byte replacementStatus;
}
private static class IncludeImpl implements Include, Div {
private final SchemaBuilderImpl sb;
private Override overrides;
private final GrammarImpl grammar;
private IncludeImpl(SchemaBuilderImpl sb, GrammarImpl grammar) {
this.sb = sb;
this.grammar = grammar;
}
public void define(String name, GrammarSection.Combine combine, Pattern pattern, Locator loc, AnnotationsImpl anno)
throws BuildException {
RefPattern rp = grammar.lookup(name);
overrides = new Override(rp, overrides);
grammar.define(rp, combine, pattern, loc);
}
public void endDiv(Locator loc, AnnotationsImpl anno) throws BuildException {
// nothing to do
}
public void topLevelAnnotation(VoidValue ea) throws BuildException {
// nothing to do
}
public void topLevelComment(CommentListImpl comments) throws BuildException {
}
public Div makeDiv() {
return this;
}
public void endInclude(String href, String base, String ns,
Locator loc, AnnotationsImpl anno) throws BuildException {
SubParseable subParseable
= sb.subParser.createSubParseable(href, base);
String uri = subParseable.getUri();
for (OpenIncludes inc = sb.openIncludes;
inc != null;
inc = inc.parent) {
if (inc.uri.equals(uri)) {
sb.error("recursive_include", uri, loc);
return;
}
}
for (Override o = overrides; o != null; o = o.next) {
o.replacementStatus = o.prp.getReplacementStatus();
o.prp.setReplacementStatus(RefPattern.REPLACEMENT_REQUIRE);
}
try {
SchemaBuilderImpl isb = new SchemaBuilderImpl(ns, uri, sb);
subParseable.parseAsInclude(isb, new GrammarImpl(isb, grammar));
for (Override o = overrides; o != null; o = o.next) {
if (o.prp.getReplacementStatus() == RefPattern.REPLACEMENT_REQUIRE) {
if (o.prp.getName() == null)
sb.error("missing_start_replacement", loc);
else
sb.error("missing_define_replacement", o.prp.getName(), loc);
}
}
}
catch (IllegalSchemaException e) {
sb.noteError();
}
finally {
for (Override o = overrides; o != null; o = o.next)
o.prp.setReplacementStatus(o.replacementStatus);
}
}
public Include makeInclude() {
return null;
}
}
public Grammar makeGrammar(Scope parent) {
return new GrammarImpl(this, parent);
}
public Pattern makeExternalRef(String href, String base, String ns, Scope scope,
Locator loc, AnnotationsImpl anno)
throws BuildException {
SubParseable subParseable
= subParser.createSubParseable(href, base);
String uri = subParseable.getUri();
for (OpenIncludes inc = openIncludes;
inc != null;
inc = inc.parent) {
if (inc.uri.equals(uri)) {
error("recursive_include", uri, loc);
return pb.makeError();
}
}
try {
return subParseable.parse(new SchemaBuilderImpl(ns, uri, this), scope);
}
catch (IllegalSchemaException e) {
noteError();
return pb.makeError();
}
}
public NameClass makeNameClassChoice(List nameClasses, Locator loc, AnnotationsImpl anno) {
int nNameClasses = nameClasses.size();
if (nNameClasses <= 0)
throw new IllegalArgumentException();
NameClass result = nameClasses.get(0);
for (int i = 1; i < nNameClasses; i++)
result = new ChoiceNameClass(result, nameClasses.get(i));
return result;
}
public NameClass makeName(String ns, String localName, String prefix, Locator loc, AnnotationsImpl anno) {
return new SimpleNameClass(new Name(resolveInherit(ns), localName));
}
public NameClass makeNsName(String ns, Locator loc, AnnotationsImpl anno) {
return new NsNameClass(resolveInherit(ns));
}
public NameClass makeNsName(String ns, NameClass except, Locator loc, AnnotationsImpl anno) {
return new NsNameExceptNameClass(resolveInherit(ns), except);
}
public NameClass makeAnyName(Locator loc, AnnotationsImpl anno) {
return new AnyNameClass();
}
public NameClass makeAnyName(NameClass except, Locator loc, AnnotationsImpl anno) {
return new AnyNameExceptNameClass(except);
}
public AnnotationsImpl makeAnnotations(CommentListImpl comments, Context context) {
return this;
}
public VoidValue makeElementAnnotation() throws BuildException {
return VoidValue.VOID;
}
public void addText(String value, Locator loc, CommentListImpl comments) throws BuildException {
}
public ElementAnnotationBuilder
makeElementAnnotationBuilder(String ns, String localName, String prefix,
Locator loc, CommentListImpl comments, Context context) {
return this;
}
public CommentListImpl makeCommentList() {
return this;
}
public boolean usesComments() {
return false;
}
public Pattern annotatePattern(Pattern p, AnnotationsImpl anno) throws BuildException {
return p;
}
public NameClass annotateNameClass(NameClass nc, AnnotationsImpl anno) throws BuildException {
return nc;
}
public Pattern annotateAfterPattern(Pattern p, VoidValue e) throws BuildException {
return p;
}
public NameClass annotateAfterNameClass(NameClass nc, VoidValue e) throws BuildException {
return nc;
}
public Pattern commentAfterPattern(Pattern p, CommentListImpl comments) throws BuildException {
return p;
}
public NameClass commentAfterNameClass(NameClass nc, CommentListImpl comments) throws BuildException {
return nc;
}
private String resolveInherit(String ns) {
if (ns == INHERIT_NS)
return inheritNs;
return ns;
}
private class LocatorImpl implements Locator {
private final String systemId;
private final int lineNumber;
private final int columnNumber;
private LocatorImpl(String systemId, int lineNumber, int columnNumber) {
this.systemId = systemId;
this.lineNumber = lineNumber;
this.columnNumber = columnNumber;
}
public String getPublicId() {
return null;
}
public String getSystemId() {
return systemId;
}
public int getLineNumber() {
return lineNumber;
}
public int getColumnNumber() {
return columnNumber;
}
}
public Locator makeLocation(String systemId, int lineNumber, int columnNumber) {
return new LocatorImpl(systemId, lineNumber, columnNumber);
}
private void error(SAXParseException message) throws BuildException {
noteError();
try {
if (eh != null)
eh.error(message);
}
catch (SAXException e) {
throw new BuildException(e);
}
}
/*
private void warning(SAXParseException message) throws BuildException {
try {
if (eh != null)
eh.warning(message);
}
catch (SAXException e) {
throw new BuildException(e);
}
}
*/
private void error(String key, Locator loc) throws BuildException {
error(new SAXParseException(localizer.message(key), loc));
}
private void error(String key, String arg, Locator loc) throws BuildException {
error(new SAXParseException(localizer.message(key, arg), loc));
}
private void error(String key, String arg1, String arg2, Locator loc) throws BuildException {
error(new SAXParseException(localizer.message(key, arg1, arg2), loc));
}
private void error(String key, String arg1, String arg2, String arg3, Locator loc) throws BuildException {
error(new SAXParseException(localizer.message(key, new Object[]{arg1, arg2, arg3}), loc));
}
private void noteError() {
if (!hadError && parent != null)
parent.noteError();
hadError = true;
}
}