Wed, 27 Apr 2016 01:27:09 +0800
Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/jaxws/
changeset: 657:d47a47f961ee
tag: jdk8u25-b17
1 /*
2 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 /*
26 * Copyright (C) 2004-2012
27 *
28 * Permission is hereby granted, free of charge, to any person obtaining a copy
29 * of this software and associated documentation files (the "Software"), to deal
30 * in the Software without restriction, including without limitation the rights
31 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
32 * copies of the Software, and to permit persons to whom the Software is
33 * furnished to do so, subject to the following conditions:
34 *
35 * The above copyright notice and this permission notice shall be included in
36 * all copies or substantial portions of the Software.
37 *
38 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
39 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
40 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
41 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
42 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
43 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
44 * THE SOFTWARE.
45 */
46 package com.sun.xml.internal.rngom.binary;
48 import java.util.Enumeration;
49 import java.util.Hashtable;
50 import java.util.List;
52 import com.sun.xml.internal.rngom.ast.builder.Annotations;
53 import com.sun.xml.internal.rngom.ast.builder.BuildException;
54 import com.sun.xml.internal.rngom.ast.builder.CommentList;
55 import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
56 import com.sun.xml.internal.rngom.ast.builder.Div;
57 import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
58 import com.sun.xml.internal.rngom.ast.builder.Grammar;
59 import com.sun.xml.internal.rngom.ast.builder.GrammarSection;
60 import com.sun.xml.internal.rngom.ast.builder.Include;
61 import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
62 import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
63 import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
64 import com.sun.xml.internal.rngom.ast.builder.Scope;
65 import com.sun.xml.internal.rngom.ast.om.Location;
66 import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
67 import com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
68 import com.sun.xml.internal.rngom.ast.om.ParsedPattern;
69 import com.sun.xml.internal.rngom.ast.util.LocatorImpl;
70 import com.sun.xml.internal.rngom.dt.builtin.BuiltinDatatypeLibraryFactory;
71 import com.sun.xml.internal.rngom.dt.CascadingDatatypeLibraryFactory;
72 import com.sun.xml.internal.rngom.nc.NameClass;
73 import com.sun.xml.internal.rngom.nc.NameClassBuilderImpl;
74 import com.sun.xml.internal.rngom.parse.Context;
75 import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
76 import com.sun.xml.internal.rngom.parse.Parseable;
77 import com.sun.xml.internal.rngom.util.Localizer;
78 import org.relaxng.datatype.Datatype;
79 import org.relaxng.datatype.DatatypeBuilder;
80 import org.relaxng.datatype.DatatypeException;
81 import org.relaxng.datatype.DatatypeLibrary;
82 import org.relaxng.datatype.DatatypeLibraryFactory;
83 import org.relaxng.datatype.ValidationContext;
84 import org.relaxng.datatype.helpers.DatatypeLibraryLoader;
85 import org.xml.sax.ErrorHandler;
86 import org.xml.sax.Locator;
87 import org.xml.sax.SAXException;
88 import org.xml.sax.SAXParseException;
90 public class SchemaBuilderImpl implements SchemaBuilder, ElementAnnotationBuilder, CommentList {
92 private final SchemaBuilderImpl parent;
93 private boolean hadError = false;
94 private final SchemaPatternBuilder pb;
95 private final DatatypeLibraryFactory datatypeLibraryFactory;
96 private final String inheritNs;
97 private final ErrorHandler eh;
98 private final OpenIncludes openIncludes;
99 private final NameClassBuilder ncb = new NameClassBuilderImpl();
100 static final Localizer localizer = new Localizer(SchemaBuilderImpl.class);
102 static class OpenIncludes {
104 final String uri;
105 final OpenIncludes parent;
107 OpenIncludes(String uri, OpenIncludes parent) {
108 this.uri = uri;
109 this.parent = parent;
110 }
111 }
113 public ParsedPattern expandPattern(ParsedPattern _pattern)
114 throws BuildException, IllegalSchemaException {
115 Pattern pattern = (Pattern) _pattern;
116 if (!hadError) {
117 try {
118 pattern.checkRecursion(0);
119 pattern = pattern.expand(pb);
120 pattern.checkRestrictions(Pattern.START_CONTEXT, null, null);
121 if (!hadError) {
122 return pattern;
123 }
124 } catch (SAXParseException e) {
125 error(e);
126 } catch (SAXException e) {
127 throw new BuildException(e);
128 } catch (RestrictionViolationException e) {
129 if (e.getName() != null) {
130 error(e.getMessageId(), e.getName().toString(), e
131 .getLocator());
132 } else {
133 error(e.getMessageId(), e.getLocator());
134 }
135 }
136 }
137 throw new IllegalSchemaException();
138 }
140 /**
141 *
142 * @param eh Error handler to receive errors while building the schema.
143 */
144 public SchemaBuilderImpl(ErrorHandler eh) {
145 this(eh,
146 new CascadingDatatypeLibraryFactory(new DatatypeLibraryLoader(),
147 new BuiltinDatatypeLibraryFactory(new DatatypeLibraryLoader())),
148 new SchemaPatternBuilder());
149 }
151 /**
152 *
153 * @param eh Error handler to receive errors while building the schema.
154 * @param datatypeLibraryFactory This is consulted to locate datatype
155 * libraries.
156 * @param pb Used to build patterns.
157 */
158 public SchemaBuilderImpl(ErrorHandler eh,
159 DatatypeLibraryFactory datatypeLibraryFactory,
160 SchemaPatternBuilder pb) {
161 this.parent = null;
162 this.eh = eh;
163 this.datatypeLibraryFactory = datatypeLibraryFactory;
164 this.pb = pb;
165 this.inheritNs = "";
166 this.openIncludes = null;
167 }
169 private SchemaBuilderImpl(String inheritNs,
170 String uri,
171 SchemaBuilderImpl parent) {
172 this.parent = parent;
173 this.eh = parent.eh;
174 this.datatypeLibraryFactory = parent.datatypeLibraryFactory;
175 this.pb = parent.pb;
176 this.inheritNs = inheritNs;
177 this.openIncludes = new OpenIncludes(uri, parent.openIncludes);
178 }
180 public NameClassBuilder getNameClassBuilder() {
181 return ncb;
182 }
184 public ParsedPattern makeChoice(List patterns, Location loc, Annotations anno)
185 throws BuildException {
186 if (patterns.isEmpty()) {
187 throw new IllegalArgumentException();
188 }
189 Pattern result = (Pattern) patterns.get(0);
190 for (int i = 1; i < patterns.size(); i++) {
191 result = pb.makeChoice(result, (Pattern) patterns.get(i));
192 }
193 return result;
194 }
196 public ParsedPattern makeInterleave(List patterns, Location loc, Annotations anno)
197 throws BuildException {
198 if (patterns.isEmpty()) {
199 throw new IllegalArgumentException();
200 }
201 Pattern result = (Pattern) patterns.get(0);
202 for (int i = 1; i < patterns.size(); i++) {
203 result = pb.makeInterleave(result, (Pattern) patterns.get(i));
204 }
205 return result;
206 }
208 public ParsedPattern makeGroup(List patterns, Location loc, Annotations anno)
209 throws BuildException {
210 if (patterns.isEmpty()) {
211 throw new IllegalArgumentException();
212 }
213 Pattern result = (Pattern) patterns.get(0);
214 for (int i = 1; i < patterns.size(); i++) {
215 result = pb.makeGroup(result, (Pattern) patterns.get(i));
216 }
217 return result;
218 }
220 public ParsedPattern makeOneOrMore(ParsedPattern p, Location loc, Annotations anno)
221 throws BuildException {
222 return pb.makeOneOrMore((Pattern) p);
223 }
225 public ParsedPattern makeZeroOrMore(ParsedPattern p, Location loc, Annotations anno)
226 throws BuildException {
227 return pb.makeZeroOrMore((Pattern) p);
228 }
230 public ParsedPattern makeOptional(ParsedPattern p, Location loc, Annotations anno)
231 throws BuildException {
232 return pb.makeOptional((Pattern) p);
233 }
235 public ParsedPattern makeList(ParsedPattern p, Location loc, Annotations anno)
236 throws BuildException {
237 return pb.makeList((Pattern) p, (Locator) loc);
238 }
240 public ParsedPattern makeMixed(ParsedPattern p, Location loc, Annotations anno)
241 throws BuildException {
242 return pb.makeMixed((Pattern) p);
243 }
245 public ParsedPattern makeEmpty(Location loc, Annotations anno) {
246 return pb.makeEmpty();
247 }
249 public ParsedPattern makeNotAllowed(Location loc, Annotations anno) {
250 return pb.makeUnexpandedNotAllowed();
251 }
253 public ParsedPattern makeText(Location loc, Annotations anno) {
254 return pb.makeText();
255 }
257 public ParsedPattern makeErrorPattern() {
258 return pb.makeError();
259 }
261 // public ParsedNameClass makeErrorNameClass() {
262 // return new ErrorNameClass();
263 // }
264 public ParsedPattern makeAttribute(ParsedNameClass nc, ParsedPattern p, Location loc, Annotations anno)
265 throws BuildException {
266 return pb.makeAttribute((NameClass) nc, (Pattern) p, (Locator) loc);
267 }
269 public ParsedPattern makeElement(ParsedNameClass nc, ParsedPattern p, Location loc, Annotations anno)
270 throws BuildException {
271 return pb.makeElement((NameClass) nc, (Pattern) p, (Locator) loc);
272 }
274 private class DummyDataPatternBuilder implements DataPatternBuilder {
276 public void addParam(String name, String value, Context context, String ns, Location loc, Annotations anno)
277 throws BuildException {
278 }
280 public ParsedPattern makePattern(Location loc, Annotations anno)
281 throws BuildException {
282 return pb.makeError();
283 }
285 public ParsedPattern makePattern(ParsedPattern except, Location loc, Annotations anno)
286 throws BuildException {
287 return pb.makeError();
288 }
290 public void annotation(ParsedElementAnnotation ea) {
291 }
292 }
294 private static class ValidationContextImpl implements ValidationContext {
296 private ValidationContext vc;
297 private String ns;
299 ValidationContextImpl(ValidationContext vc, String ns) {
300 this.vc = vc;
301 this.ns = ns.length() == 0 ? null : ns;
302 }
304 public String resolveNamespacePrefix(String prefix) {
305 return prefix.length() == 0 ? ns : vc.resolveNamespacePrefix(prefix);
306 }
308 public String getBaseUri() {
309 return vc.getBaseUri();
310 }
312 public boolean isUnparsedEntity(String entityName) {
313 return vc.isUnparsedEntity(entityName);
314 }
316 public boolean isNotation(String notationName) {
317 return vc.isNotation(notationName);
318 }
319 }
321 private class DataPatternBuilderImpl implements DataPatternBuilder {
323 private DatatypeBuilder dtb;
325 DataPatternBuilderImpl(DatatypeBuilder dtb) {
326 this.dtb = dtb;
327 }
329 public void addParam(String name, String value, Context context, String ns, Location loc, Annotations anno)
330 throws BuildException {
331 try {
332 dtb.addParameter(name, value, new ValidationContextImpl(context, ns));
333 } catch (DatatypeException e) {
334 String detail = e.getMessage();
335 int pos = e.getIndex();
336 String displayedParam;
337 if (pos == DatatypeException.UNKNOWN) {
338 displayedParam = null;
339 } else {
340 displayedParam = displayParam(value, pos);
341 }
342 if (displayedParam != null) {
343 if (detail != null) {
344 error("invalid_param_detail_display", detail, displayedParam, (Locator) loc);
345 } else {
346 error("invalid_param_display", displayedParam, (Locator) loc);
347 }
348 } else if (detail != null) {
349 error("invalid_param_detail", detail, (Locator) loc);
350 } else {
351 error("invalid_param", (Locator) loc);
352 }
353 }
354 }
356 String displayParam(String value, int pos) {
357 if (pos < 0) {
358 pos = 0;
359 } else if (pos > value.length()) {
360 pos = value.length();
361 }
362 return localizer.message("display_param", value.substring(0, pos), value.substring(pos));
363 }
365 public ParsedPattern makePattern(Location loc, Annotations anno)
366 throws BuildException {
367 try {
368 return pb.makeData(dtb.createDatatype());
369 } catch (DatatypeException e) {
370 String detail = e.getMessage();
371 if (detail != null) {
372 error("invalid_params_detail", detail, (Locator) loc);
373 } else {
374 error("invalid_params", (Locator) loc);
375 }
376 return pb.makeError();
377 }
378 }
380 public ParsedPattern makePattern(ParsedPattern except, Location loc, Annotations anno)
381 throws BuildException {
382 try {
383 return pb.makeDataExcept(dtb.createDatatype(), (Pattern) except, (Locator) loc);
384 } catch (DatatypeException e) {
385 String detail = e.getMessage();
386 if (detail != null) {
387 error("invalid_params_detail", detail, (Locator) loc);
388 } else {
389 error("invalid_params", (Locator) loc);
390 }
391 return pb.makeError();
392 }
393 }
395 public void annotation(ParsedElementAnnotation ea) {
396 }
397 }
399 public DataPatternBuilder makeDataPatternBuilder(String datatypeLibrary, String type, Location loc)
400 throws BuildException {
401 DatatypeLibrary dl = datatypeLibraryFactory.createDatatypeLibrary(datatypeLibrary);
402 if (dl == null) {
403 error("unrecognized_datatype_library", datatypeLibrary, (Locator) loc);
404 } else {
405 try {
406 return new DataPatternBuilderImpl(dl.createDatatypeBuilder(type));
407 } catch (DatatypeException e) {
408 String detail = e.getMessage();
409 if (detail != null) {
410 error("unsupported_datatype_detail", datatypeLibrary, type, detail, (Locator) loc);
411 } else {
412 error("unrecognized_datatype", datatypeLibrary, type, (Locator) loc);
413 }
414 }
415 }
416 return new DummyDataPatternBuilder();
417 }
419 public ParsedPattern makeValue(String datatypeLibrary, String type, String value, Context context, String ns,
420 Location loc, Annotations anno) throws BuildException {
421 DatatypeLibrary dl = datatypeLibraryFactory.createDatatypeLibrary(datatypeLibrary);
422 if (dl == null) {
423 error("unrecognized_datatype_library", datatypeLibrary, (Locator) loc);
424 } else {
425 try {
426 DatatypeBuilder dtb = dl.createDatatypeBuilder(type);
427 try {
428 Datatype dt = dtb.createDatatype();
429 Object obj = dt.createValue(value, new ValidationContextImpl(context, ns));
430 if (obj != null) {
431 return pb.makeValue(dt, obj);
432 }
433 error("invalid_value", value, (Locator) loc);
434 } catch (DatatypeException e) {
435 String detail = e.getMessage();
436 if (detail != null) {
437 error("datatype_requires_param_detail", detail, (Locator) loc);
438 } else {
439 error("datatype_requires_param", (Locator) loc);
440 }
441 }
442 } catch (DatatypeException e) {
443 error("unrecognized_datatype", datatypeLibrary, type, (Locator) loc);
444 }
445 }
446 return pb.makeError();
447 }
449 static class GrammarImpl implements Grammar, Div, IncludedGrammar {
451 private final SchemaBuilderImpl sb;
452 private final Hashtable defines;
453 private final RefPattern startRef;
454 private final Scope parent;
456 private GrammarImpl(SchemaBuilderImpl sb, Scope parent) {
457 this.sb = sb;
458 this.parent = parent;
459 this.defines = new Hashtable();
460 this.startRef = new RefPattern(null);
461 }
463 protected GrammarImpl(SchemaBuilderImpl sb, GrammarImpl g) {
464 this.sb = sb;
465 parent = g.parent;
466 startRef = g.startRef;
467 defines = g.defines;
468 }
470 public ParsedPattern endGrammar(Location loc, Annotations anno) throws BuildException {
471 for (Enumeration e = defines.keys();
472 e.hasMoreElements();) {
473 String name = (String) e.nextElement();
474 RefPattern rp = (RefPattern) defines.get(name);
475 if (rp.getPattern() == null) {
476 sb.error("reference_to_undefined", name, rp.getRefLocator());
477 rp.setPattern(sb.pb.makeError());
478 }
479 }
480 Pattern start = startRef.getPattern();
481 if (start == null) {
482 sb.error("missing_start_element", (Locator) loc);
483 start = sb.pb.makeError();
484 }
485 return start;
486 }
488 public void endDiv(Location loc, Annotations anno) throws BuildException {
489 // nothing to do
490 }
492 public ParsedPattern endIncludedGrammar(Location loc, Annotations anno) throws BuildException {
493 return null;
494 }
496 public void define(String name, GrammarSection.Combine combine, ParsedPattern pattern, Location loc, Annotations anno)
497 throws BuildException {
498 define(lookup(name), combine, pattern, loc);
499 }
501 private void define(RefPattern rp, GrammarSection.Combine combine, ParsedPattern pattern, Location loc)
502 throws BuildException {
503 switch (rp.getReplacementStatus()) {
504 case RefPattern.REPLACEMENT_KEEP:
505 if (combine == null) {
506 if (rp.isCombineImplicit()) {
507 if (rp.getName() == null) {
508 sb.error("duplicate_start", (Locator) loc);
509 } else {
510 sb.error("duplicate_define", rp.getName(), (Locator) loc);
511 }
512 } else {
513 rp.setCombineImplicit();
514 }
515 } else {
516 byte combineType = (combine == COMBINE_CHOICE ? RefPattern.COMBINE_CHOICE : RefPattern.COMBINE_INTERLEAVE);
517 if (rp.getCombineType() != RefPattern.COMBINE_NONE
518 && rp.getCombineType() != combineType) {
519 if (rp.getName() == null) {
520 sb.error("conflict_combine_start", (Locator) loc);
521 } else {
522 sb.error("conflict_combine_define", rp.getName(), (Locator) loc);
523 }
524 }
525 rp.setCombineType(combineType);
526 }
527 Pattern p = (Pattern) pattern;
528 if (rp.getPattern() == null) {
529 rp.setPattern(p);
530 } else if (rp.getCombineType() == RefPattern.COMBINE_INTERLEAVE) {
531 rp.setPattern(sb.pb.makeInterleave(rp.getPattern(), p));
532 } else {
533 rp.setPattern(sb.pb.makeChoice(rp.getPattern(), p));
534 }
535 break;
536 case RefPattern.REPLACEMENT_REQUIRE:
537 rp.setReplacementStatus(RefPattern.REPLACEMENT_IGNORE);
538 break;
539 case RefPattern.REPLACEMENT_IGNORE:
540 break;
541 }
542 }
544 public void topLevelAnnotation(ParsedElementAnnotation ea) throws BuildException {
545 }
547 public void topLevelComment(CommentList comments) throws BuildException {
548 }
550 private RefPattern lookup(String name) {
551 if (name == START) {
552 return startRef;
553 }
554 return lookup1(name);
555 }
557 private RefPattern lookup1(String name) {
558 RefPattern p = (RefPattern) defines.get(name);
559 if (p == null) {
560 p = new RefPattern(name);
561 defines.put(name, p);
562 }
563 return p;
564 }
566 public ParsedPattern makeRef(String name, Location loc, Annotations anno) throws BuildException {
567 RefPattern p = lookup1(name);
568 if (p.getRefLocator() == null && loc != null) {
569 p.setRefLocator((Locator) loc);
570 }
571 return p;
572 }
574 public ParsedPattern makeParentRef(String name, Location loc, Annotations anno) throws BuildException {
575 // TODO: do this check by the caller
576 if (parent == null) {
577 sb.error("parent_ref_outside_grammar", (Locator) loc);
578 return sb.makeErrorPattern();
579 }
580 return parent.makeRef(name, loc, anno);
581 }
583 public Div makeDiv() {
584 return this;
585 }
587 public Include makeInclude() {
588 return new IncludeImpl(sb, this);
589 }
590 }
592 static class Override {
594 Override(RefPattern prp, Override next) {
595 this.prp = prp;
596 this.next = next;
597 }
598 RefPattern prp;
599 Override next;
600 byte replacementStatus;
601 }
603 private static class IncludeImpl implements Include, Div {
605 private SchemaBuilderImpl sb;
606 private Override overrides;
607 private GrammarImpl grammar;
609 private IncludeImpl(SchemaBuilderImpl sb, GrammarImpl grammar) {
610 this.sb = sb;
611 this.grammar = grammar;
612 }
614 public void define(String name, GrammarSection.Combine combine, ParsedPattern pattern, Location loc, Annotations anno)
615 throws BuildException {
616 RefPattern rp = grammar.lookup(name);
617 overrides = new Override(rp, overrides);
618 grammar.define(rp, combine, pattern, loc);
619 }
621 public void endDiv(Location loc, Annotations anno) throws BuildException {
622 // nothing to do
623 }
625 public void topLevelAnnotation(ParsedElementAnnotation ea) throws BuildException {
626 // nothing to do
627 }
629 public void topLevelComment(CommentList comments) throws BuildException {
630 }
632 public Div makeDiv() {
633 return this;
634 }
636 public void endInclude(Parseable current, String uri, String ns,
637 Location loc, Annotations anno) throws BuildException {
638 for (OpenIncludes inc = sb.openIncludes;
639 inc != null;
640 inc = inc.parent) {
641 if (inc.uri.equals(uri)) {
642 sb.error("recursive_include", uri, (Locator) loc);
643 return;
644 }
645 }
647 for (Override o = overrides; o != null; o = o.next) {
648 o.replacementStatus = o.prp.getReplacementStatus();
649 o.prp.setReplacementStatus(RefPattern.REPLACEMENT_REQUIRE);
650 }
651 try {
652 SchemaBuilderImpl isb = new SchemaBuilderImpl(ns, uri, sb);
653 current.parseInclude(uri, isb, new GrammarImpl(isb, grammar), ns);
654 for (Override o = overrides; o != null; o = o.next) {
655 if (o.prp.getReplacementStatus() == RefPattern.REPLACEMENT_REQUIRE) {
656 if (o.prp.getName() == null) {
657 sb.error("missing_start_replacement", (Locator) loc);
658 } else {
659 sb.error("missing_define_replacement", o.prp.getName(), (Locator) loc);
660 }
661 }
662 }
663 } catch (IllegalSchemaException e) {
664 sb.noteError();
665 } finally {
666 for (Override o = overrides; o != null; o = o.next) {
667 o.prp.setReplacementStatus(o.replacementStatus);
668 }
669 }
670 }
672 public Include makeInclude() {
673 return null;
674 }
675 }
677 public Grammar makeGrammar(Scope parent) {
678 return new GrammarImpl(this, parent);
679 }
681 public ParsedPattern annotate(ParsedPattern p, Annotations anno) throws BuildException {
682 return p;
683 }
685 public ParsedPattern annotateAfter(ParsedPattern p, ParsedElementAnnotation e) throws BuildException {
686 return p;
687 }
689 public ParsedPattern commentAfter(ParsedPattern p, CommentList comments) throws BuildException {
690 return p;
691 }
693 public ParsedPattern makeExternalRef(Parseable current, String uri, String ns, Scope scope,
694 Location loc, Annotations anno)
695 throws BuildException {
696 for (OpenIncludes inc = openIncludes;
697 inc != null;
698 inc = inc.parent) {
699 if (inc.uri.equals(uri)) {
700 error("recursive_include", uri, (Locator) loc);
701 return pb.makeError();
702 }
703 }
704 try {
705 return current.parseExternal(uri, new SchemaBuilderImpl(ns, uri, this), scope, ns);
706 } catch (IllegalSchemaException e) {
707 noteError();
708 return pb.makeError();
709 }
710 }
712 public Location makeLocation(String systemId, int lineNumber, int columnNumber) {
713 return new LocatorImpl(systemId, lineNumber, columnNumber);
714 }
716 public Annotations makeAnnotations(CommentList comments, Context context) {
717 return this;
718 }
720 public ElementAnnotationBuilder makeElementAnnotationBuilder(String ns, String localName, String prefix,
721 Location loc, CommentList comments, Context context) {
722 return this;
723 }
725 public CommentList makeCommentList() {
726 return this;
727 }
729 public void addComment(String value, Location loc) throws BuildException {
730 }
732 public void addAttribute(String ns, String localName, String prefix, String value, Location loc) {
733 // nothing needed
734 }
736 public void addElement(ParsedElementAnnotation ea) {
737 // nothing needed
738 }
740 public void addComment(CommentList comments) throws BuildException {
741 // nothing needed
742 }
744 public void addLeadingComment(CommentList comments) throws BuildException {
745 // nothing needed
746 }
748 public ParsedElementAnnotation makeElementAnnotation() {
749 return null;
750 }
752 public void addText(String value, Location loc, CommentList comments) throws BuildException {
753 }
755 public boolean usesComments() {
756 return false;
757 }
759 private void error(SAXParseException message) throws BuildException {
760 noteError();
761 try {
762 if (eh != null) {
763 eh.error(message);
764 }
765 } catch (SAXException e) {
766 throw new BuildException(e);
767 }
768 }
770 private void error(String key, Locator loc) throws BuildException {
771 error(new SAXParseException(localizer.message(key), loc));
772 }
774 private void error(String key, String arg, Locator loc) throws BuildException {
775 error(new SAXParseException(localizer.message(key, arg), loc));
776 }
778 private void error(String key, String arg1, String arg2, Locator loc) throws BuildException {
779 error(new SAXParseException(localizer.message(key, arg1, arg2), loc));
780 }
782 private void error(String key, String arg1, String arg2, String arg3, Locator loc) throws BuildException {
783 error(new SAXParseException(localizer.message(key, new Object[]{arg1, arg2, arg3}), loc));
784 }
786 private void noteError() {
787 if (!hadError && parent != null) {
788 parent.noteError();
789 }
790 hadError = true;
791 }
792 }