comparison src/share/classes/com/sun/xml/internal/rngom/parse/compact/CompactSyntax.jj @ 0:0961a4a21176

Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:818bc8ac48b7
1 options {
2 STATIC = false;
3 UNICODE_INPUT = true;
4 JAVA_UNICODE_ESCAPE = true;
5 }
6
7 PARSER_BEGIN(CompactSyntax)
8
9 package com.sun.xml.internal.rngom.parse.compact;
10
11 import java.io.Reader;
12 import java.net.MalformedURLException;
13 import java.net.URL;
14 import java.util.Arrays;
15 import java.util.ArrayList;
16 import java.util.Collections;
17 import java.util.Enumeration;
18 import java.util.Hashtable;
19 import java.util.List;
20
21 import com.sun.xml.internal.rngom.ast.builder.Annotations;
22 import com.sun.xml.internal.rngom.ast.builder.BuildException;
23 import com.sun.xml.internal.rngom.ast.builder.CommentList;
24 import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
25 import com.sun.xml.internal.rngom.ast.builder.Div;
26 import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
27 import com.sun.xml.internal.rngom.ast.builder.Grammar;
28 import com.sun.xml.internal.rngom.ast.builder.GrammarSection;
29 import com.sun.xml.internal.rngom.ast.builder.Include;
30 import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
31 import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
32 import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
33 import com.sun.xml.internal.rngom.ast.builder.Scope;
34 import com.sun.xml.internal.rngom.ast.om.Location;
35 import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
36 import com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
37 import com.sun.xml.internal.rngom.ast.om.ParsedPattern;
38 import com.sun.xml.internal.rngom.parse.Context;
39 import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
40 import com.sun.xml.internal.rngom.parse.Parseable;
41 import org.xml.sax.ErrorHandler;
42 import org.xml.sax.SAXException;
43 import org.xml.sax.SAXParseException;
44 import org.xml.sax.helpers.LocatorImpl;
45
46 import com.sun.xml.internal.rngom.util.Localizer;
47 import com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces;
48
49
50 public class CompactSyntax implements Context {
51 private static final int IN_ELEMENT = 0;
52 private static final int IN_ATTRIBUTE = 1;
53 private static final int IN_ANY_NAME = 2;
54 private static final int IN_NS_NAME = 4;
55
56 private String defaultNamespace;
57 private String compatibilityPrefix = null;
58 private SchemaBuilder sb;
59 private NameClassBuilder ncb;
60 private String sourceUri;
61 /**
62 * This is what we are parsing right now.
63 */
64 private CompactParseable parseable;
65 private ErrorHandler eh;
66 private final Hashtable namespaceTable = new Hashtable();
67 private final Hashtable datatypesTable = new Hashtable();
68 private boolean hadError = false;
69 private static final Localizer localizer = new Localizer(new Localizer(Parseable.class),CompactSyntax.class);
70 private final Hashtable attributeNameTable = new Hashtable();
71 private boolean annotationsIncludeElements = false;
72
73 /**
74 * String that represents the inherited namespace.
75 *
76 * <p>
77 * HACK: we always allocate a new String instance so that
78 * we can distinguish inherited value from the explicitly
79 * given value.
80 */
81 private /*final*/ String inheritedNs; // essentially final but JavaCC don't let us declare it as so.
82
83 final class LocatedString {
84 private final String str;
85 private final Token tok;
86
87 LocatedString(String str, Token tok) {
88 this.str = str;
89 this.tok = tok;
90 }
91
92 String getString() {
93 return str;
94 }
95
96 Location getLocation() {
97 return makeLocation(tok);
98 }
99
100 Token getToken() {
101 return tok;
102 }
103
104 }
105
106 public CompactSyntax(CompactParseable parseable, Reader r, String sourceUri, SchemaBuilder sb, ErrorHandler eh, String inheritedNs) {
107 this(r);
108 this.sourceUri = sourceUri;
109 this.parseable = parseable;
110 this.sb = sb;
111 this.ncb = sb.getNameClassBuilder();
112 this.eh = eh;
113 // this causes the root pattern to have non-null annotations
114 // which is useful because it gives a context to trang
115 this.topLevelComments = sb.makeCommentList();
116 this.inheritedNs = defaultNamespace = new String(inheritedNs);
117 }
118
119 ParsedPattern parse(Scope scope) throws IllegalSchemaException {
120 try {
121 ParsedPattern p = Input(scope);
122 if (!hadError)
123 return p;
124 }
125 catch (ParseException e) {
126 error("syntax_error", e.getMessage(), e.currentToken.next);
127 }
128 catch (EscapeSyntaxException e) {
129 reportEscapeSyntaxException(e);
130 }
131 throw new IllegalSchemaException();
132 }
133
134 ParsedPattern parseInclude(IncludedGrammar g) throws IllegalSchemaException {
135 try {
136 ParsedPattern p = IncludedGrammar(g);
137 if (!hadError)
138 return p;
139 }
140 catch (ParseException e) {
141 error("syntax_error", e.getMessage(), e.currentToken.next);
142 }
143 catch (EscapeSyntaxException e) {
144 reportEscapeSyntaxException(e);
145 }
146 throw new IllegalSchemaException();
147 }
148
149 private void checkNsName(int context, LocatedString ns) {
150 if ((context & IN_NS_NAME) != 0)
151 error("ns_name_except_contains_ns_name", ns.getToken());
152 }
153
154 private void checkAnyName(int context, Token t) {
155 if ((context & IN_NS_NAME) != 0)
156 error("ns_name_except_contains_any_name", t);
157 if ((context & IN_ANY_NAME) != 0)
158 error("any_name_except_contains_any_name", t);
159 }
160
161 private void error(String key, Token tok) {
162 doError(localizer.message(key), tok);
163 }
164
165 private void error(String key, String arg, Token tok) {
166 doError(localizer.message(key, arg), tok);
167 }
168
169 private void error(String key, String arg1, String arg2, Token tok) {
170 doError(localizer.message(key, arg1, arg2), tok);
171 }
172
173 private void doError(String message, Token tok) {
174 hadError = true;
175 if (eh != null) {
176 LocatorImpl loc = new LocatorImpl();
177 loc.setLineNumber(tok.beginLine);
178 loc.setColumnNumber(tok.beginColumn);
179 loc.setSystemId(sourceUri);
180 try {
181 eh.error(new SAXParseException(message, loc));
182 }
183 catch (SAXException se) {
184 throw new BuildException(se);
185 }
186 }
187 }
188
189 private void reportEscapeSyntaxException(EscapeSyntaxException e) {
190 if (eh != null) {
191 LocatorImpl loc = new LocatorImpl();
192 loc.setLineNumber(e.getLineNumber());
193 loc.setColumnNumber(e.getColumnNumber());
194 loc.setSystemId(sourceUri);
195 try {
196 eh.error(new SAXParseException(localizer.message(e.getKey()), loc));
197 }
198 catch (SAXException se) {
199 throw new BuildException(se);
200 }
201 }
202 }
203
204 private static String unquote(String s) {
205 if (s.length() >= 6 && s.charAt(0) == s.charAt(1)) {
206 s = s.replace('\u0000', '\n');
207 return s.substring(3, s.length() - 3);
208 }
209 else
210 return s.substring(1, s.length() - 1);
211 }
212
213 Location makeLocation(Token t) {
214 return sb.makeLocation(sourceUri, t.beginLine, t.beginColumn);
215 }
216
217 private static ParsedPattern[] addPattern(ParsedPattern[] patterns, int i, ParsedPattern p) {
218 if (i >= patterns.length) {
219 ParsedPattern[] oldPatterns = patterns;
220 patterns = new ParsedPattern[oldPatterns.length*2];
221 System.arraycopy(oldPatterns, 0, patterns, 0, oldPatterns.length);
222 }
223 patterns[i] = p;
224 return patterns;
225 }
226
227 String getCompatibilityPrefix() {
228 if (compatibilityPrefix == null) {
229 compatibilityPrefix = "a";
230 while (namespaceTable.get(compatibilityPrefix) != null)
231 compatibilityPrefix = compatibilityPrefix + "a";
232 }
233 return compatibilityPrefix;
234 }
235
236 public String resolveNamespacePrefix(String prefix) {
237 String result = (String)namespaceTable.get(prefix);
238 if (result.length() == 0)
239 return null;
240 return result;
241 }
242
243 public Enumeration prefixes() {
244 return namespaceTable.keys();
245 }
246
247 public String getBaseUri() {
248 return sourceUri;
249 }
250
251 public boolean isUnparsedEntity(String entityName) {
252 return false;
253 }
254
255 public boolean isNotation(String notationName) {
256 return false;
257 }
258
259 public Context copy() {
260 return this;
261 }
262
263 private Context getContext() {
264 return this;
265 }
266
267 private CommentList getComments() {
268 return getComments(getTopLevelComments());
269 }
270
271 private CommentList topLevelComments;
272
273 private CommentList getTopLevelComments() {
274 CommentList tem = topLevelComments;
275 topLevelComments = null;
276 return tem;
277 }
278
279 private void noteTopLevelComments() {
280 topLevelComments = getComments(topLevelComments);
281 }
282
283 private void topLevelComments(GrammarSection section) {
284 section.topLevelComment(getComments(null));
285 }
286
287 private Token lastCommentSourceToken = null;
288
289 private CommentList getComments(CommentList comments) {
290 Token nextToken = getToken(1);
291 if (lastCommentSourceToken != nextToken) {
292 if (lastCommentSourceToken == null)
293 lastCommentSourceToken = token;
294 do {
295 lastCommentSourceToken = lastCommentSourceToken.next;
296 Token t = lastCommentSourceToken.specialToken;
297 if (t != null) {
298 while (t.specialToken != null)
299 t = t.specialToken;
300 if (comments == null)
301 comments = sb.makeCommentList();
302 for (; t != null; t = t.next) {
303 String s = mungeComment(t.image);
304 Location loc = makeLocation(t);
305 if (t.next != null
306 && t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE) {
307 StringBuffer buf = new StringBuffer(s);
308 do {
309 t = t.next;
310 buf.append('\n');
311 buf.append(mungeComment(t.image));
312 } while (t.next != null
313 && t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE);
314 s = buf.toString();
315 }
316 comments.addComment(s, loc);
317 }
318 }
319 } while (lastCommentSourceToken != nextToken);
320 }
321 return comments;
322 }
323
324 private ParsedPattern afterComments(ParsedPattern p) {
325 CommentList comments = getComments(null);
326 if (comments == null)
327 return p;
328 return sb.commentAfter(p, comments);
329 }
330
331 private ParsedNameClass afterComments(ParsedNameClass nc) {
332 CommentList comments = getComments(null);
333 if (comments == null)
334 return nc;
335 return ncb.commentAfter(nc, comments);
336 }
337
338 private static String mungeComment(String image) {
339 int i = image.indexOf('#') + 1;
340 while (i < image.length() && image.charAt(i) == '#')
341 i++;
342 if (i < image.length() && image.charAt(i) == ' ')
343 i++;
344 return image.substring(i);
345 }
346
347 private Annotations getCommentsAsAnnotations() {
348 CommentList comments = getComments();
349 if (comments == null)
350 return null;
351 return sb.makeAnnotations(comments, getContext());
352 }
353
354 private Annotations addCommentsToChildAnnotations(Annotations a) {
355 CommentList comments = getComments();
356 if (comments == null)
357 return a;
358 if (a == null)
359 a = sb.makeAnnotations(null, getContext());
360 a.addComment(comments);
361 return a;
362 }
363
364 private Annotations addCommentsToLeadingAnnotations(Annotations a) {
365 CommentList comments = getComments();
366 if (comments == null)
367 return a;
368 if (a == null)
369 return sb.makeAnnotations(comments, getContext());
370 a.addLeadingComment(comments);
371 return a;
372 }
373
374 private Annotations getTopLevelCommentsAsAnnotations() {
375 CommentList comments = getTopLevelComments();
376 if (comments == null)
377 return null;
378 return sb.makeAnnotations(comments, getContext());
379 }
380
381 private void clearAttributeList() {
382 attributeNameTable.clear();
383 }
384
385 private void addAttribute(Annotations a, String ns, String localName, String prefix, String value, Token tok) {
386 String key = ns + "#" + localName;
387 if (attributeNameTable.get(key) != null)
388 error("duplicate_attribute", ns, localName, tok);
389 else {
390 attributeNameTable.put(key, key);
391 a.addAttribute(ns, localName, prefix, value, makeLocation(tok));
392 }
393 }
394
395 private void checkExcept(Token[] except) {
396 if (except[0] != null)
397 error("except_missing_parentheses", except[0]);
398 }
399
400 private String lookupPrefix(String prefix, Token t) {
401 String ns = (String)namespaceTable.get(prefix);
402 if (ns == null) {
403 error("undeclared_prefix", prefix, t);
404 return "#error";
405 }
406 return ns;
407 }
408 private String lookupDatatype(String prefix, Token t) {
409 String ns = (String)datatypesTable.get(prefix);
410 if (ns == null) {
411 error("undeclared_prefix", prefix, t);
412 return ""; // XXX
413 }
414 return ns;
415 }
416 private String resolve(String str) {
417 try {
418 return new URL(new URL(sourceUri), str).toString();
419 }
420 catch (MalformedURLException e) { }
421 return str;
422 }
423 }
424
425 PARSER_END(CompactSyntax)
426
427 ParsedPattern Input(Scope scope) :
428 {
429 ParsedPattern p;
430 }
431 {
432 Preamble()
433 (LOOKAHEAD(TopLevelLookahead()) p = TopLevelGrammar(scope)
434 | p = Expr(true, scope, null, null) { p = afterComments(p); } <EOF>)
435 { return p; }
436 }
437
438 void TopLevelLookahead() :
439 {}
440 {
441 <PREFIXED_NAME> "["
442 | Identifier() ("[" | "=" | "&=" | "|=")
443 | LookaheadGrammarKeyword()
444 | LookaheadBody() LookaheadAfterAnnotations()
445 | LookaheadDocumentation() (LookaheadBody())? LookaheadAfterAnnotations()
446 }
447
448 void LookaheadAfterAnnotations() :
449 {}
450 {
451 Identifier() ("=" | "&=" | "|=")
452 | LookaheadGrammarKeyword()
453 }
454
455 void LookaheadGrammarKeyword() :
456 {}
457 {
458 "start" | "div" | "include"
459 }
460
461 void LookaheadDocumentation() :
462 {}
463 {
464 ((<DOCUMENTATION> | <DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT>) (<DOCUMENTATION_CONTINUE>)*)+
465 }
466
467 void LookaheadBody() :
468 {}
469 {
470 "["
471 (<PREFIXED_NAME> | UnprefixedName() | "=" | <LITERAL> | "~" | LookaheadBody() )*
472 "]"
473 }
474
475 ParsedPattern IncludedGrammar(IncludedGrammar g) :
476 {
477 Annotations a;
478 ParsedPattern p;
479 }
480 {
481 Preamble()
482 (LOOKAHEAD(TopLevelLookahead()) a = GrammarBody(g, g, getTopLevelCommentsAsAnnotations())
483 | a = Annotations() "grammar" "{" a = GrammarBody(g, g, a) { topLevelComments(g); } "}")
484 { p = afterComments(g.endIncludedGrammar(sb.makeLocation(sourceUri, 1, 1), a)); }
485 <EOF>
486 { return p; }
487 }
488
489 ParsedPattern TopLevelGrammar(Scope scope) :
490 {
491 Annotations a = getTopLevelCommentsAsAnnotations();
492 Grammar g;
493 ParsedPattern p;
494 }
495 {
496 { g = sb.makeGrammar(scope); }
497 a = GrammarBody(g, g, a)
498 { p = afterComments(g.endGrammar(sb.makeLocation(sourceUri, 1, 1), a)); }
499 <EOF>
500 { return p; }
501 }
502
503 void Preamble() :
504 {}
505 {
506 (NamespaceDecl() | DatatypesDecl())*
507 {
508 namespaceTable.put("xml", WellKnownNamespaces.XML);
509 if (datatypesTable.get("xsd") == null)
510 datatypesTable.put("xsd", WellKnownNamespaces.XML_SCHEMA_DATATYPES);
511 }
512 }
513
514 void NamespaceDecl() :
515 {
516 LocatedString prefix = null;
517 boolean isDefault = false;
518 String namespaceName;
519 }
520 {
521 { noteTopLevelComments(); }
522 (("namespace" prefix = UnprefixedName())
523 | ("default" { isDefault = true; }
524 "namespace" (prefix = UnprefixedName())?))
525 "="
526 namespaceName = NamespaceName()
527 {
528 if (isDefault)
529 defaultNamespace = namespaceName;
530 if (prefix != null) {
531 if (prefix.getString().equals("xmlns"))
532 error("xmlns_prefix", prefix.getToken());
533 else if (prefix.getString().equals("xml")) {
534 if (!namespaceName.equals(WellKnownNamespaces.XML))
535 error("xml_prefix_bad_uri", prefix.getToken());
536 }
537 else if (namespaceName.equals(WellKnownNamespaces.XML))
538 error("xml_uri_bad_prefix", prefix.getToken());
539 else {
540 if (namespaceName.equals(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS))
541 compatibilityPrefix = prefix.getString();
542 namespaceTable.put(prefix.getString(), namespaceName);
543 }
544 }
545 }
546 }
547
548 String NamespaceName() :
549 {
550 String r;
551 }
552 {
553 (r = Literal() | "inherit" { r = this.inheritedNs; })
554 { return r; }
555 }
556
557 void DatatypesDecl() :
558 {
559 LocatedString prefix;
560 String uri;
561 }
562 {
563 { noteTopLevelComments(); }
564 "datatypes" prefix = UnprefixedName() "=" uri = Literal()
565 {
566 datatypesTable.put(prefix.getString(), uri);
567 }
568 }
569
570 ParsedPattern AnnotatedPrimaryExpr(boolean topLevel, Scope scope, Token[] except) :
571 {
572 Annotations a;
573 ParsedPattern p;
574 ParsedElementAnnotation e;
575 Token t;
576 }
577 {
578 a = Annotations()
579 p = PrimaryExpr(topLevel, scope, a, except)
580 ( t = <FANNOTATE> e = AnnotationElement(false) {
581 if (topLevel)
582 error("top_level_follow_annotation", t);
583 else
584 p = sb.annotateAfter(p, e);
585 })*
586 { return p; }
587 }
588
589
590 ParsedPattern PrimaryExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) :
591 {
592 ParsedPattern p;
593 }
594 {
595 (p = ElementExpr(scope, a)
596 | p = AttributeExpr(scope, a)
597 | p = GrammarExpr(scope, a)
598 | p = ExternalRefExpr(scope, a)
599 | p = ListExpr(scope, a)
600 | p = MixedExpr(scope, a)
601 | p = ParenExpr(topLevel, scope, a)
602 | p = IdentifierExpr(scope, a)
603 | p = ParentExpr(scope, a)
604 | p = DataExpr(topLevel, scope, a, except)
605 | p = ValueExpr(topLevel, a)
606 | p = TextExpr(a)
607 | p = EmptyExpr(a)
608 | p = NotAllowedExpr(a))
609 { return p; }
610 }
611
612 ParsedPattern EmptyExpr(Annotations a) :
613 {
614 Token t;
615 }
616 {
617 t = "empty"
618 { return sb.makeEmpty(makeLocation(t), a); }
619 }
620
621 ParsedPattern TextExpr(Annotations a) :
622 {
623 Token t;
624 }
625 {
626 t = "text"
627 { return sb.makeText(makeLocation(t), a); }
628 }
629
630 ParsedPattern NotAllowedExpr(Annotations a) :
631 {
632 Token t;
633 }
634 {
635 t = "notAllowed"
636 { return sb.makeNotAllowed(makeLocation(t), a); }
637 }
638
639 ParsedPattern Expr(boolean topLevel, Scope scope, Token t, Annotations a) :
640 {
641 List patterns = new ArrayList();
642 ParsedPattern p;
643 boolean[] hadOccur = new boolean[1];
644 Token[] except = new Token[1];
645 }
646 {
647 p = UnaryExpr(topLevel, scope, hadOccur, except)
648 { patterns.add(p); }
649 (
650 { checkExcept(except); }
651 (t = "|" p = UnaryExpr(topLevel, scope, null, except)
652 { patterns.add(p); checkExcept(except); } )+
653 { p = sb.makeChoice(patterns, makeLocation(t), a); }
654 | (t = "&" p = UnaryExpr(topLevel, scope, null, except)
655 { patterns.add(p); checkExcept(except); } )+
656 { p = sb.makeInterleave(patterns, makeLocation(t), a); }
657 | (t = "," p = UnaryExpr(topLevel, scope, null, except)
658 { patterns.add(p); checkExcept(except); } )+
659 { p = sb.makeGroup(patterns, makeLocation(t), a); }
660 )?
661 {
662 if (patterns.size() == 1 && a != null) {
663 if (hadOccur[0])
664 p = sb.annotate(p, a);
665 else
666 p = sb.makeGroup(patterns, makeLocation(t), a);
667 }
668 return p;
669 }
670 }
671
672 ParsedPattern UnaryExpr(boolean topLevel, Scope scope, boolean[] hadOccur, Token[] except) :
673 {
674 ParsedPattern p;
675 Token t;
676 ParsedElementAnnotation e;
677 }
678 {
679 p = AnnotatedPrimaryExpr(topLevel, scope, except)
680 (
681 {
682 if (hadOccur != null) hadOccur[0] = true;
683 p = afterComments(p);
684 }
685 (t = "+" { checkExcept(except); p = sb.makeOneOrMore(p, makeLocation(t), null); }
686 | t = "?" { checkExcept(except); p = sb.makeOptional(p, makeLocation(t), null); }
687 | t = "*" { checkExcept(except); p = sb.makeZeroOrMore(p, makeLocation(t), null); })
688 ( t = <FANNOTATE> e = AnnotationElement(false) {
689 if (topLevel)
690 error("top_level_follow_annotation", t);
691 else
692 p = sb.annotateAfter(p, e);
693 } )*
694 )?
695 { return p; }
696 }
697
698 ParsedPattern ElementExpr(Scope scope, Annotations a) :
699 {
700 Token t;
701 ParsedNameClass nc;
702 ParsedPattern p;
703 }
704 {
705 t = "element"
706 nc = NameClass(IN_ELEMENT, null)
707 "{"
708 p = Expr(false, scope, null, null)
709 { p = afterComments(p); }
710 "}"
711 { return sb.makeElement(nc, p, makeLocation(t), a); }
712 }
713
714 ParsedPattern AttributeExpr(Scope scope, Annotations a) :
715 {
716 Token t;
717 ParsedNameClass nc;
718 ParsedPattern p;
719 }
720 {
721 t = "attribute"
722 nc = NameClass(IN_ATTRIBUTE, null)
723 "{"
724 p = Expr(false, scope, null, null)
725 { p = afterComments(p); }
726 "}"
727 { return sb.makeAttribute(nc, p, makeLocation(t), a); }
728 }
729
730 ParsedNameClass NameClass(int context, Annotations[] pa) :
731 {
732 Annotations a;
733 ParsedNameClass nc;
734 }
735 {
736 a = Annotations()
737 (nc = PrimaryNameClass(context, a) nc = AnnotateAfter(nc) nc = NameClassAlternatives(context, nc, pa)
738 | nc = AnyNameExceptClass(context, a, pa)
739 | nc = NsNameExceptClass(context, a, pa))
740 { return nc; }
741 }
742
743 ParsedNameClass AnnotateAfter(ParsedNameClass nc) :
744 {
745 ParsedElementAnnotation e;
746 }
747 {
748 ( <FANNOTATE> e = AnnotationElement(false) { nc = ncb.annotateAfter(nc, e); })*
749 { return nc; }
750 }
751
752 ParsedNameClass NameClassAlternatives(int context, ParsedNameClass nc, Annotations[] pa) :
753 {
754 Token t;
755 ParsedNameClass[] nameClasses;
756 int nNameClasses;
757 }
758 {
759 (
760 {
761 nameClasses = new ParsedNameClass[2];
762 nameClasses[0] = nc;
763 nNameClasses = 1;
764 }
765 (t = "|" nc = BasicNameClass(context) nc = AnnotateAfter(nc)
766 {
767 if (nNameClasses >= nameClasses.length) {
768 ParsedNameClass[] oldNameClasses = nameClasses;
769 nameClasses = new ParsedNameClass[oldNameClasses.length*2];
770 System.arraycopy(oldNameClasses, 0, nameClasses, 0, oldNameClasses.length);
771 }
772 nameClasses[nNameClasses++] = nc;
773 })+
774 {
775 Annotations a;
776 if (pa == null)
777 a = null;
778 else {
779 a = pa[0];
780 pa[0] = null;
781 }
782 nc = ncb.makeChoice(Arrays.asList(nameClasses).subList(0,nNameClasses), makeLocation(t), a);
783 }
784 )?
785 { return nc; }
786 }
787
788 ParsedNameClass BasicNameClass(int context) :
789 {
790 Annotations a;
791 ParsedNameClass nc;
792 }
793 {
794 a = Annotations()
795 (nc = PrimaryNameClass(context, a)
796 | nc = OpenNameClass(context, a))
797 { return nc; }
798 }
799
800 ParsedNameClass PrimaryNameClass(int context, Annotations a) :
801 {
802 ParsedNameClass nc;
803 }
804 {
805 (nc = UnprefixedNameClass(context, a)
806 | nc = PrefixedNameClass(a)
807 | nc = ParenNameClass(context, a))
808 { return nc; }
809 }
810
811 ParsedNameClass OpenNameClass(int context, Annotations a) :
812 {
813 Token t;
814 LocatedString ns;
815 }
816 {
817 ns = NsName() { checkNsName(context, ns); return ncb.makeNsName(ns.getString(), ns.getLocation(), a); }
818 | t = "*" { checkAnyName(context, t); return ncb.makeAnyName(makeLocation(t), a); }
819 }
820
821
822 ParsedNameClass UnprefixedNameClass(int context, Annotations a) :
823 {
824 LocatedString name;
825 }
826 {
827 name = UnprefixedName()
828 {
829 String ns;
830 if ((context & (IN_ATTRIBUTE|IN_ELEMENT)) == IN_ATTRIBUTE)
831 ns = "";
832 else
833 ns = defaultNamespace;
834 return ncb.makeName(ns, name.getString(), null, name.getLocation(), a);
835 }
836 }
837
838 ParsedNameClass PrefixedNameClass(Annotations a) :
839 {
840 Token t;
841 }
842 {
843 t = <PREFIXED_NAME>
844 {
845 String qn = t.image;
846 int colon = qn.indexOf(':');
847 String prefix = qn.substring(0, colon);
848 return ncb.makeName(lookupPrefix(prefix, t), qn.substring(colon + 1), prefix, makeLocation(t), a);
849 }
850 }
851
852 ParsedNameClass NsNameExceptClass(int context, Annotations a, Annotations[] pa) :
853 {
854 LocatedString ns;
855 ParsedNameClass nc;
856 }
857 {
858 ns = NsName()
859 { checkNsName(context, ns); }
860 (nc = ExceptNameClass(context | IN_NS_NAME)
861 { nc = ncb.makeNsName(ns.getString(), nc, ns.getLocation(), a); }
862 nc = AnnotateAfter(nc)
863 | { nc = ncb.makeNsName(ns.getString(), ns.getLocation(), a); }
864 nc = AnnotateAfter(nc)
865 nc = NameClassAlternatives(context, nc, pa))
866 { return nc; }
867 }
868
869 LocatedString NsName() :
870 {
871 Token t;
872 }
873 {
874 t = <PREFIX_STAR>
875 {
876 String qn = t.image;
877 String prefix = qn.substring(0, qn.length() - 2);
878 return new LocatedString(lookupPrefix(prefix, t), t);
879 }
880 }
881
882 ParsedNameClass AnyNameExceptClass(int context, Annotations a, Annotations[] pa) :
883 {
884 Token t;
885 ParsedNameClass nc;
886 }
887 {
888 t = "*"
889 { checkAnyName(context, t); }
890 (nc = ExceptNameClass(context | IN_ANY_NAME)
891 { nc = ncb.makeAnyName(nc, makeLocation(t), a); }
892 nc = AnnotateAfter(nc)
893 | { nc = ncb.makeAnyName(makeLocation(t), a); }
894 nc = AnnotateAfter(nc)
895 nc = NameClassAlternatives(context, nc, pa))
896 { return nc; }
897 }
898
899 ParsedNameClass ParenNameClass(int context, Annotations a) :
900 {
901 Token t;
902 ParsedNameClass nc;
903 Annotations[] pa = new Annotations[]{ a };
904 }
905 {
906 t = "(" nc = NameClass(context, pa) { nc = afterComments(nc); } ")"
907 {
908 if (pa[0] != null)
909 nc = ncb.makeChoice(Collections.singletonList(nc), makeLocation(t), pa[0]);
910 return nc;
911 }
912 }
913
914 ParsedNameClass ExceptNameClass(int context) :
915 {
916 ParsedNameClass nc;
917 }
918 {
919 "-" nc = BasicNameClass(context)
920 { return nc; }
921 }
922
923 ParsedPattern ListExpr(Scope scope, Annotations a) :
924 {
925 Token t;
926 ParsedPattern p;
927 }
928 {
929 t = "list"
930 "{"
931 p = Expr(false, scope, null, null)
932 { p = afterComments(p); }
933 "}"
934 { return sb.makeList(p, makeLocation(t), a); }
935 }
936
937 ParsedPattern MixedExpr(Scope scope, Annotations a) :
938 {
939 Token t;
940 ParsedPattern p;
941 }
942 {
943 t = "mixed"
944 "{"
945 p = Expr(false, scope, null, null)
946 { p = afterComments(p); }
947 "}"
948 { return sb.makeMixed(p, makeLocation(t), a); }
949 }
950
951 ParsedPattern GrammarExpr(Scope scope, Annotations a) :
952 {
953 Token t;
954 Grammar g;
955 }
956 {
957 t = "grammar" { g = sb.makeGrammar(scope); }
958 "{" a = GrammarBody(g, g, a) { topLevelComments(g); } "}"
959 { return g.endGrammar(makeLocation(t), a); }
960 }
961
962 ParsedPattern ParenExpr(boolean topLevel, Scope scope, Annotations a) :
963 {
964 Token t;
965 ParsedPattern p;
966 }
967 {
968 t = "(" p = Expr(topLevel, scope, t, a) { p = afterComments(p); } ")"
969 { return p; }
970 }
971
972 Annotations GrammarBody(GrammarSection section, Scope scope, Annotations a) :
973 {
974 ParsedElementAnnotation e;
975 }
976 {
977 (LOOKAHEAD(2) e = AnnotationElementNotKeyword()
978 { if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); })*
979 (GrammarComponent(section, scope))*
980 { return a; }
981 }
982
983 void GrammarComponent(GrammarSection section, Scope scope) :
984 {
985 ParsedElementAnnotation e;
986 Annotations a;
987 }
988 {
989 (a = Annotations()
990 (Definition(section, scope, a)
991 | Include(section, scope, a)
992 | Div(section, scope, a)))
993 (LOOKAHEAD(2) e = AnnotationElementNotKeyword() { section.topLevelAnnotation(e); })*
994 }
995
996 void Definition(GrammarSection section, Scope scope, Annotations a) :
997 {}
998 {
999 (Define(section, scope, a) | Start(section, scope, a))
1000 }
1001
1002 void Start(GrammarSection section, Scope scope, Annotations a) :
1003 {
1004 Token t;
1005 GrammarSection.Combine combine;
1006 ParsedPattern p;
1007 }
1008 {
1009 t = "start" combine = AssignOp() p = Expr(false, scope, null, null)
1010 { section.define(GrammarSection.START, combine, p, makeLocation(t), a); }
1011 }
1012
1013 void Define(GrammarSection section, Scope scope, Annotations a) :
1014 {
1015 LocatedString name;
1016 GrammarSection.Combine combine;
1017 ParsedPattern p;
1018 }
1019 {
1020 name = Identifier() combine = AssignOp() p = Expr(false, scope, null, null)
1021 { section.define(name.getString(), combine, p, name.getLocation(), a); }
1022 }
1023
1024 GrammarSection.Combine AssignOp() :
1025 {}
1026 {
1027 "=" { return null; }
1028 | "|=" { return GrammarSection.COMBINE_CHOICE; }
1029 | "&=" { return GrammarSection.COMBINE_INTERLEAVE; }
1030 }
1031
1032 void Include(GrammarSection section, Scope scope, Annotations a) :
1033 {
1034 Token t;
1035 String href;
1036 String ns;
1037 Include include = section.makeInclude();
1038 }
1039 {
1040 t = "include" href = Literal()
1041 ns = Inherit()
1042 ("{" a = IncludeBody(include, scope, a) { topLevelComments(include); } "}")?
1043 {
1044 try {
1045 include.endInclude(parseable, resolve(href), ns, makeLocation(t), a);
1046 }
1047 catch (IllegalSchemaException e) { }
1048 }
1049 }
1050
1051 Annotations IncludeBody(GrammarSection section, Scope scope, Annotations a) :
1052 {
1053 ParsedElementAnnotation e;
1054 }
1055 {
1056 (LOOKAHEAD(2) e = AnnotationElementNotKeyword()
1057 { if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); })*
1058 (IncludeComponent(section, scope))*
1059 { return a; }
1060 }
1061
1062
1063 void IncludeComponent(GrammarSection section, Scope scope) :
1064 {
1065 ParsedElementAnnotation e;
1066 Annotations a;
1067 }
1068 {
1069 (a = Annotations() (Definition(section, scope, a)
1070 | IncludeDiv(section, scope, a)))
1071 (LOOKAHEAD(2) e = AnnotationElementNotKeyword() { section.topLevelAnnotation(e); })*
1072 }
1073
1074 void Div(GrammarSection section, Scope scope, Annotations a) :
1075 {
1076 Token t;
1077 Div div = section.makeDiv();
1078 }
1079 {
1080 t = "div" "{" a = GrammarBody(div, scope, a) { topLevelComments(div); } "}"
1081 { div.endDiv(makeLocation(t), a); }
1082 }
1083
1084 void IncludeDiv(GrammarSection section, Scope scope, Annotations a) :
1085 {
1086 Token t;
1087 Div div = section.makeDiv();
1088 }
1089 {
1090 t = "div" "{" a = IncludeBody(div, scope, a) { topLevelComments(div); } "}"
1091 { div.endDiv(makeLocation(t), a); }
1092 }
1093
1094 ParsedPattern ExternalRefExpr(Scope scope, Annotations a) :
1095 {
1096 Token t;
1097 String href;
1098 String ns;
1099 }
1100 {
1101 t = "external" href = Literal()
1102 ns = Inherit()
1103 {
1104 try {
1105 return sb.makeExternalRef(parseable, resolve(href), ns, scope, makeLocation(t), a);
1106 }
1107 catch (IllegalSchemaException e) {
1108 return sb.makeErrorPattern();
1109 }
1110 }
1111 }
1112
1113 String Inherit() :
1114 {
1115 String ns = null;
1116 }
1117 {
1118 ("inherit" "=" ns = Prefix())?
1119 {
1120 if (ns == null)
1121 ns = defaultNamespace;
1122 return ns;
1123 }
1124 }
1125
1126 ParsedPattern ParentExpr(Scope scope, Annotations a) :
1127 {
1128 LocatedString name;
1129 }
1130 {
1131 "parent" { a = addCommentsToChildAnnotations(a); } name = Identifier()
1132 {
1133 if(scope==null) {
1134 error("parent_ref_outside_grammar",name.getToken());
1135 return sb.makeErrorPattern();
1136 } else {
1137 return scope.makeParentRef(name.getString(), name.getLocation(), a);
1138 }
1139 }
1140 }
1141
1142 ParsedPattern IdentifierExpr(Scope scope, Annotations a) :
1143 {
1144 LocatedString name;
1145 }
1146 {
1147 name = Identifier()
1148 {
1149 if(scope==null) {
1150 error("ref_outside_grammar",name.getToken());
1151 return sb.makeErrorPattern();
1152 } else {
1153 return scope.makeRef(name.getString(), name.getLocation(), a);
1154 }
1155 }
1156 }
1157
1158 ParsedPattern ValueExpr(boolean topLevel, Annotations a) :
1159 {
1160 LocatedString s;
1161 }
1162 {
1163 s = LocatedLiteral()
1164 {
1165 if (topLevel && annotationsIncludeElements) {
1166 error("top_level_follow_annotation", s.getToken());
1167 a = null;
1168 }
1169 return sb.makeValue("", "token", s.getString(), getContext(), defaultNamespace, s.getLocation(), a);
1170 }
1171 }
1172
1173 ParsedPattern DataExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) :
1174 {
1175 Token datatypeToken;
1176 Location loc;
1177 String datatype;
1178 String datatypeUri = null;
1179 String s = null;
1180 ParsedPattern e = null;
1181 DataPatternBuilder dpb;
1182 }
1183 {
1184 datatypeToken = DatatypeName()
1185 {
1186 datatype = datatypeToken.image;
1187 loc = makeLocation(datatypeToken);
1188 int colon = datatype.indexOf(':');
1189 if (colon < 0)
1190 datatypeUri = "";
1191 else {
1192 String prefix = datatype.substring(0, colon);
1193 datatypeUri = lookupDatatype(prefix, datatypeToken);
1194 datatype = datatype.substring(colon + 1);
1195 }
1196 }
1197 ((s = Literal()
1198 {
1199 if (topLevel && annotationsIncludeElements) {
1200 error("top_level_follow_annotation", datatypeToken);
1201 a = null;
1202 }
1203 return sb.makeValue(datatypeUri, datatype, s, getContext(), defaultNamespace, loc, a);
1204 }
1205 )
1206 | ( { dpb = sb.makeDataPatternBuilder(datatypeUri, datatype, loc); }
1207 ( (Params(dpb) (e = Except(scope, except))?)
1208 | (e = Except(scope, except))?)
1209 { return e == null ? dpb.makePattern(loc, a) : dpb.makePattern(e, loc, a); }))
1210 }
1211
1212 Token DatatypeName() :
1213 {
1214 Token t;
1215 }
1216 {
1217 (t = "string" | t = "token" | t = <PREFIXED_NAME>)
1218 { return t; }
1219 }
1220
1221 LocatedString Identifier() :
1222 {
1223 LocatedString s;
1224 Token t;
1225 }
1226 {
1227 (t = <IDENTIFIER> { s = new LocatedString(t.image, t); }
1228 | t = <ESCAPED_IDENTIFIER> { s = new LocatedString(t.image.substring(1), t); })
1229 { return s; }
1230 }
1231
1232 String Prefix() :
1233 {
1234 Token t;
1235 String prefix;
1236 }
1237 {
1238 (t = <IDENTIFIER> { prefix = t.image; }
1239 | t = <ESCAPED_IDENTIFIER> { prefix = t.image.substring(1); }
1240 | t = Keyword() { prefix = t.image; })
1241 { return lookupPrefix(prefix, t); }
1242 }
1243
1244 LocatedString UnprefixedName() :
1245 {
1246 LocatedString s;
1247 Token t;
1248 }
1249 {
1250 (s = Identifier()
1251 | t = Keyword() { s = new LocatedString(t.image, t); })
1252 { return s; }
1253 }
1254
1255 void Params(DataPatternBuilder dpb) :
1256 {}
1257 {
1258 "{" (Param(dpb))* "}"
1259 }
1260
1261 void Param(DataPatternBuilder dpb) :
1262 {
1263 LocatedString name;
1264 Annotations a;
1265 String value;
1266 }
1267 {
1268 a = Annotations() name = UnprefixedName() "=" { a = addCommentsToLeadingAnnotations(a); } value = Literal()
1269 { dpb.addParam(name.getString(), value, getContext(), defaultNamespace, name.getLocation(), a); }
1270 }
1271
1272 ParsedPattern Except(Scope scope, Token[] except) :
1273 {
1274 Annotations a;
1275 ParsedPattern p;
1276 Token t;
1277 Token[] innerExcept = new Token[1];
1278 }
1279 {
1280 t = "-" a = Annotations() p = PrimaryExpr(false, scope, a, innerExcept)
1281 {
1282 checkExcept(innerExcept);
1283 except[0] = t;
1284 return p;
1285 }
1286 }
1287
1288 ParsedElementAnnotation Documentation() :
1289 {
1290 CommentList comments = getComments();
1291 ElementAnnotationBuilder eab;
1292 Token t;
1293 }
1294 {
1295 (t = <DOCUMENTATION> | t = <DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT>)
1296 {
1297 eab = sb.makeElementAnnotationBuilder(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS,
1298 "documentation",
1299 getCompatibilityPrefix(),
1300 makeLocation(t),
1301 comments,
1302 getContext());
1303 eab.addText(mungeComment(t.image), makeLocation(t), null);
1304 }
1305 (t = <DOCUMENTATION_CONTINUE> { eab.addText("\n" + mungeComment(t.image), makeLocation(t), null); })*
1306 { return eab.makeElementAnnotation(); }
1307 }
1308
1309 Annotations Annotations() :
1310 {
1311 CommentList comments = getComments();
1312 Annotations a = null;
1313 ParsedElementAnnotation e;
1314 }
1315 {
1316 ( { a = sb.makeAnnotations(comments, getContext()); }
1317 (e = Documentation() { a.addElement(e); })+
1318 {
1319 comments = getComments();
1320 if (comments != null)
1321 a.addLeadingComment(comments);
1322 }
1323 )?
1324 ("[" { if (a == null) a = sb.makeAnnotations(comments, getContext()); clearAttributeList(); annotationsIncludeElements = false; }
1325 (LOOKAHEAD(2) PrefixedAnnotationAttribute(a, false) )*
1326 ( e = AnnotationElement(false) { a.addElement(e); annotationsIncludeElements = true; } )*
1327 { a.addComment(getComments()); }
1328 "]")?
1329 {
1330 if (a == null && comments != null)
1331 a = sb.makeAnnotations(comments, getContext());
1332 return a;
1333 }
1334 }
1335
1336 void AnnotationAttribute(Annotations a) :
1337 {}
1338 {
1339 PrefixedAnnotationAttribute(a, true) | UnprefixedAnnotationAttribute(a)
1340 }
1341
1342 void PrefixedAnnotationAttribute(Annotations a, boolean nested) :
1343 {
1344 Token t;
1345 String value;
1346 }
1347 {
1348 t = <PREFIXED_NAME> "=" value = Literal()
1349 {
1350 String qn = t.image;
1351 int colon = qn.indexOf(':');
1352 String prefix = qn.substring(0, colon);
1353 String ns = lookupPrefix(prefix, t);
1354 if (ns == this.inheritedNs)
1355 error("inherited_annotation_namespace", t);
1356 else if (ns.length() == 0 && !nested)
1357 error("unqualified_annotation_attribute", t);
1358 else if (ns.equals(WellKnownNamespaces.RELAX_NG) && !nested)
1359 error("relax_ng_namespace", t);
1360 /*else if (ns.length() == 0
1361 && qn.length() - colon - 1 == 5
1362 && qn.regionMatches(colon + 1, "xmlns", 0, 5))
1363 error("xmlns_annotation_attribute", t);*/
1364 else if (ns.equals(WellKnownNamespaces.XMLNS))
1365 error("xmlns_annotation_attribute_uri", t);
1366 else {
1367 if (ns.length() == 0)
1368 prefix = null;
1369 addAttribute(a, ns, qn.substring(colon + 1), prefix, value, t);
1370 }
1371 }
1372 }
1373
1374 void UnprefixedAnnotationAttribute(Annotations a) :
1375 {
1376 LocatedString name;
1377 String value;
1378 }
1379 {
1380 name = UnprefixedName() "=" value = Literal()
1381 {
1382 if (name.getString().equals("xmlns"))
1383 error("xmlns_annotation_attribute", name.getToken());
1384 else
1385 addAttribute(a, "", name.getString(), null, value, name.getToken());
1386 }
1387 }
1388
1389 ParsedElementAnnotation AnnotationElement(boolean nested) :
1390 {
1391 ParsedElementAnnotation a;
1392 }
1393 {
1394 (a = PrefixedAnnotationElement(nested)
1395 | a = UnprefixedAnnotationElement())
1396 { return a; }
1397 }
1398
1399 ParsedElementAnnotation AnnotationElementNotKeyword() :
1400 {
1401 ParsedElementAnnotation a;
1402 }
1403 {
1404 (a = PrefixedAnnotationElement(false)
1405 | a = IdentifierAnnotationElement())
1406 { return a; }
1407 }
1408
1409 ParsedElementAnnotation PrefixedAnnotationElement(boolean nested) :
1410 {
1411 CommentList comments = getComments();
1412 Token t;
1413 ElementAnnotationBuilder eab;
1414 }
1415 {
1416 t = <PREFIXED_NAME>
1417 {
1418 String qn = t.image;
1419 int colon = qn.indexOf(':');
1420 String prefix = qn.substring(0, colon);
1421 String ns = lookupPrefix(prefix, t);
1422 if (ns == this.inheritedNs) {
1423 error("inherited_annotation_namespace", t);
1424 ns = "";
1425 }
1426 else if (!nested && ns.equals(WellKnownNamespaces.RELAX_NG)) {
1427 error("relax_ng_namespace", t);
1428 ns = "";
1429 }
1430 else {
1431 if (ns.length() == 0)
1432 prefix = null;
1433 }
1434 eab = sb.makeElementAnnotationBuilder(ns, qn.substring(colon + 1), prefix,
1435 makeLocation(t), comments, getContext());
1436 }
1437 AnnotationElementContent(eab)
1438 { return eab.makeElementAnnotation(); }
1439 }
1440
1441 ParsedElementAnnotation UnprefixedAnnotationElement() :
1442 {
1443 CommentList comments = getComments();
1444 LocatedString name;
1445 ElementAnnotationBuilder eab;
1446 }
1447 {
1448 name = UnprefixedName()
1449 {
1450 eab = sb.makeElementAnnotationBuilder("", name.getString(), null,
1451 name.getLocation(), comments, getContext());
1452 }
1453 AnnotationElementContent(eab)
1454 { return eab.makeElementAnnotation(); }
1455 }
1456
1457 ParsedElementAnnotation IdentifierAnnotationElement() :
1458 {
1459 CommentList comments = getComments();
1460 LocatedString name;
1461 ElementAnnotationBuilder eab;
1462 }
1463 {
1464 name = Identifier()
1465 {
1466 eab = sb.makeElementAnnotationBuilder("", name.getString(), null,
1467 name.getLocation(), comments, getContext());
1468 }
1469 AnnotationElementContent(eab)
1470 { return eab.makeElementAnnotation(); }
1471 }
1472
1473 void AnnotationElementContent(ElementAnnotationBuilder eab) :
1474 {
1475 ParsedElementAnnotation e;
1476 }
1477 {
1478 "[" { clearAttributeList(); }
1479 (LOOKAHEAD(2) AnnotationAttribute(eab))*
1480 ((AnnotationElementLiteral(eab)
1481 ("~" AnnotationElementLiteral(eab))*)
1482 | e = AnnotationElement(true) { eab.addElement(e); })*
1483 { eab.addComment(getComments()); }
1484 "]"
1485 }
1486
1487 void AnnotationElementLiteral(ElementAnnotationBuilder eab) :
1488 {
1489 Token t;
1490 CommentList comments = getComments();
1491 }
1492 {
1493 t = <LITERAL> { eab.addText(unquote(t.image), makeLocation(t), comments); }
1494 }
1495
1496 String Literal() :
1497 {
1498 Token t;
1499 String s;
1500 StringBuffer buf;
1501 }
1502 {
1503 t = <LITERAL>
1504 {
1505 s = unquote(t.image);
1506 }
1507 (
1508 { buf = new StringBuffer(s); }
1509 ("~" t = <LITERAL> { buf.append(unquote(t.image)); })+
1510 { s = buf.toString(); }
1511 )?
1512 { return s; }
1513 }
1514
1515 LocatedString LocatedLiteral() :
1516 {
1517 Token t;
1518 Token t2;
1519 String s;
1520 StringBuffer buf;
1521 }
1522 {
1523 t = <LITERAL>
1524 {
1525 s = unquote(t.image);
1526 }
1527 (
1528 { buf = new StringBuffer(s); }
1529 ("~" t2 = <LITERAL> { buf.append(unquote(t2.image)); })+
1530 { s = buf.toString(); }
1531 )?
1532 { return new LocatedString(s, t); }
1533 }
1534
1535 Token Keyword() :
1536 {
1537 Token t;
1538 }
1539 {
1540 (t = "element"
1541 | t = "attribute"
1542 | t = "namespace"
1543 | t = "list"
1544 | t = "mixed"
1545 | t = "grammar"
1546 | t = "empty"
1547 | t = "text"
1548 | t = "parent"
1549 | t = "external"
1550 | t = "notAllowed"
1551 | t = "start"
1552 | t = "include"
1553 | t = "default"
1554 | t = "inherit"
1555 | t = "string"
1556 | t = "token"
1557 | t = "datatypes"
1558 | t = "div")
1559 { return t; }
1560 }
1561
1562 <*>
1563 SKIP: {
1564 < #NEWLINE : [ "\u0000", "\n" ] >
1565 | < #NOT_NEWLINE : ~[ "\u0000", "\n" ] >
1566 | < WS: ([ "\u0000", " ", "\n", "\t" ])+ > : DEFAULT
1567 }
1568
1569 TOKEN :
1570 {
1571 < DOCUMENTATION: "##" (<NOT_NEWLINE>)* > : AFTER_DOCUMENTATION
1572 }
1573
1574 <AFTER_DOCUMENTATION>
1575 TOKEN :
1576 {
1577 < DOCUMENTATION_CONTINUE: <NEWLINE> ([" ", "\t"])* <DOCUMENTATION> >
1578 }
1579
1580 SPECIAL_TOKEN:
1581 {
1582 < SINGLE_LINE_COMMENT: "#" (<NOT_NEWLINE>)* > : AFTER_SINGLE_LINE_COMMENT
1583 }
1584
1585 <AFTER_SINGLE_LINE_COMMENT>
1586 TOKEN :
1587 {
1588 < DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: <NEWLINE> ([" ", "\t"])* <DOCUMENTATION> > : AFTER_DOCUMENTATION
1589 }
1590
1591 <AFTER_SINGLE_LINE_COMMENT>
1592 SPECIAL_TOKEN :
1593 {
1594 < SINGLE_LINE_COMMENT_CONTINUE: <NEWLINE> ([" ", "\t"])* <SINGLE_LINE_COMMENT> >
1595 }
1596
1597 TOKEN :
1598 {
1599 < #BASE_CHAR : [
1600 "\u0041" - "\u005a",
1601 "\u0061" - "\u007a",
1602 "\u00c0" - "\u00d6",
1603 "\u00d8" - "\u00f6",
1604 "\u00f8" - "\u00ff",
1605 "\u0100" - "\u0131",
1606 "\u0134" - "\u013e",
1607 "\u0141" - "\u0148",
1608 "\u014a" - "\u017e",
1609 "\u0180" - "\u01c3",
1610 "\u01cd" - "\u01f0",
1611 "\u01f4" - "\u01f5",
1612 "\u01fa" - "\u0217",
1613 "\u0250" - "\u02a8",
1614 "\u02bb" - "\u02c1",
1615 "\u0386",
1616 "\u0388" - "\u038a",
1617 "\u038c",
1618 "\u038e" - "\u03a1",
1619 "\u03a3" - "\u03ce",
1620 "\u03d0" - "\u03d6",
1621 "\u03da",
1622 "\u03dc",
1623 "\u03de",
1624 "\u03e0",
1625 "\u03e2" - "\u03f3",
1626 "\u0401" - "\u040c",
1627 "\u040e" - "\u044f",
1628 "\u0451" - "\u045c",
1629 "\u045e" - "\u0481",
1630 "\u0490" - "\u04c4",
1631 "\u04c7" - "\u04c8",
1632 "\u04cb" - "\u04cc",
1633 "\u04d0" - "\u04eb",
1634 "\u04ee" - "\u04f5",
1635 "\u04f8" - "\u04f9",
1636 "\u0531" - "\u0556",
1637 "\u0559",
1638 "\u0561" - "\u0586",
1639 "\u05d0" - "\u05ea",
1640 "\u05f0" - "\u05f2",
1641 "\u0621" - "\u063a",
1642 "\u0641" - "\u064a",
1643 "\u0671" - "\u06b7",
1644 "\u06ba" - "\u06be",
1645 "\u06c0" - "\u06ce",
1646 "\u06d0" - "\u06d3",
1647 "\u06d5",
1648 "\u06e5" - "\u06e6",
1649 "\u0905" - "\u0939",
1650 "\u093d",
1651 "\u0958" - "\u0961",
1652 "\u0985" - "\u098c",
1653 "\u098f" - "\u0990",
1654 "\u0993" - "\u09a8",
1655 "\u09aa" - "\u09b0",
1656 "\u09b2",
1657 "\u09b6" - "\u09b9",
1658 "\u09dc" - "\u09dd",
1659 "\u09df" - "\u09e1",
1660 "\u09f0" - "\u09f1",
1661 "\u0a05" - "\u0a0a",
1662 "\u0a0f" - "\u0a10",
1663 "\u0a13" - "\u0a28",
1664 "\u0a2a" - "\u0a30",
1665 "\u0a32" - "\u0a33",
1666 "\u0a35" - "\u0a36",
1667 "\u0a38" - "\u0a39",
1668 "\u0a59" - "\u0a5c",
1669 "\u0a5e",
1670 "\u0a72" - "\u0a74",
1671 "\u0a85" - "\u0a8b",
1672 "\u0a8d",
1673 "\u0a8f" - "\u0a91",
1674 "\u0a93" - "\u0aa8",
1675 "\u0aaa" - "\u0ab0",
1676 "\u0ab2" - "\u0ab3",
1677 "\u0ab5" - "\u0ab9",
1678 "\u0abd",
1679 "\u0ae0",
1680 "\u0b05" - "\u0b0c",
1681 "\u0b0f" - "\u0b10",
1682 "\u0b13" - "\u0b28",
1683 "\u0b2a" - "\u0b30",
1684 "\u0b32" - "\u0b33",
1685 "\u0b36" - "\u0b39",
1686 "\u0b3d",
1687 "\u0b5c" - "\u0b5d",
1688 "\u0b5f" - "\u0b61",
1689 "\u0b85" - "\u0b8a",
1690 "\u0b8e" - "\u0b90",
1691 "\u0b92" - "\u0b95",
1692 "\u0b99" - "\u0b9a",
1693 "\u0b9c",
1694 "\u0b9e" - "\u0b9f",
1695 "\u0ba3" - "\u0ba4",
1696 "\u0ba8" - "\u0baa",
1697 "\u0bae" - "\u0bb5",
1698 "\u0bb7" - "\u0bb9",
1699 "\u0c05" - "\u0c0c",
1700 "\u0c0e" - "\u0c10",
1701 "\u0c12" - "\u0c28",
1702 "\u0c2a" - "\u0c33",
1703 "\u0c35" - "\u0c39",
1704 "\u0c60" - "\u0c61",
1705 "\u0c85" - "\u0c8c",
1706 "\u0c8e" - "\u0c90",
1707 "\u0c92" - "\u0ca8",
1708 "\u0caa" - "\u0cb3",
1709 "\u0cb5" - "\u0cb9",
1710 "\u0cde",
1711 "\u0ce0" - "\u0ce1",
1712 "\u0d05" - "\u0d0c",
1713 "\u0d0e" - "\u0d10",
1714 "\u0d12" - "\u0d28",
1715 "\u0d2a" - "\u0d39",
1716 "\u0d60" - "\u0d61",
1717 "\u0e01" - "\u0e2e",
1718 "\u0e30",
1719 "\u0e32" - "\u0e33",
1720 "\u0e40" - "\u0e45",
1721 "\u0e81" - "\u0e82",
1722 "\u0e84",
1723 "\u0e87" - "\u0e88",
1724 "\u0e8a",
1725 "\u0e8d",
1726 "\u0e94" - "\u0e97",
1727 "\u0e99" - "\u0e9f",
1728 "\u0ea1" - "\u0ea3",
1729 "\u0ea5",
1730 "\u0ea7",
1731 "\u0eaa" - "\u0eab",
1732 "\u0ead" - "\u0eae",
1733 "\u0eb0",
1734 "\u0eb2" - "\u0eb3",
1735 "\u0ebd",
1736 "\u0ec0" - "\u0ec4",
1737 "\u0f40" - "\u0f47",
1738 "\u0f49" - "\u0f69",
1739 "\u10a0" - "\u10c5",
1740 "\u10d0" - "\u10f6",
1741 "\u1100",
1742 "\u1102" - "\u1103",
1743 "\u1105" - "\u1107",
1744 "\u1109",
1745 "\u110b" - "\u110c",
1746 "\u110e" - "\u1112",
1747 "\u113c",
1748 "\u113e",
1749 "\u1140",
1750 "\u114c",
1751 "\u114e",
1752 "\u1150",
1753 "\u1154" - "\u1155",
1754 "\u1159",
1755 "\u115f" - "\u1161",
1756 "\u1163",
1757 "\u1165",
1758 "\u1167",
1759 "\u1169",
1760 "\u116d" - "\u116e",
1761 "\u1172" - "\u1173",
1762 "\u1175",
1763 "\u119e",
1764 "\u11a8",
1765 "\u11ab",
1766 "\u11ae" - "\u11af",
1767 "\u11b7" - "\u11b8",
1768 "\u11ba",
1769 "\u11bc" - "\u11c2",
1770 "\u11eb",
1771 "\u11f0",
1772 "\u11f9",
1773 "\u1e00" - "\u1e9b",
1774 "\u1ea0" - "\u1ef9",
1775 "\u1f00" - "\u1f15",
1776 "\u1f18" - "\u1f1d",
1777 "\u1f20" - "\u1f45",
1778 "\u1f48" - "\u1f4d",
1779 "\u1f50" - "\u1f57",
1780 "\u1f59",
1781 "\u1f5b",
1782 "\u1f5d",
1783 "\u1f5f" - "\u1f7d",
1784 "\u1f80" - "\u1fb4",
1785 "\u1fb6" - "\u1fbc",
1786 "\u1fbe",
1787 "\u1fc2" - "\u1fc4",
1788 "\u1fc6" - "\u1fcc",
1789 "\u1fd0" - "\u1fd3",
1790 "\u1fd6" - "\u1fdb",
1791 "\u1fe0" - "\u1fec",
1792 "\u1ff2" - "\u1ff4",
1793 "\u1ff6" - "\u1ffc",
1794 "\u2126",
1795 "\u212a" - "\u212b",
1796 "\u212e",
1797 "\u2180" - "\u2182",
1798 "\u3041" - "\u3094",
1799 "\u30a1" - "\u30fa",
1800 "\u3105" - "\u312c",
1801 "\uac00" - "\ud7a3"
1802 ] >
1803 | < #IDEOGRAPHIC : [
1804 "\u4e00" - "\u9fa5",
1805 "\u3007",
1806 "\u3021" - "\u3029"
1807 ] >
1808 | < #LETTER : (<BASE_CHAR> | <IDEOGRAPHIC>) >
1809 | < #COMBINING_CHAR : [
1810 "\u0300" - "\u0345",
1811 "\u0360" - "\u0361",
1812 "\u0483" - "\u0486",
1813 "\u0591" - "\u05a1",
1814 "\u05a3" - "\u05b9",
1815 "\u05bb" - "\u05bd",
1816 "\u05bf",
1817 "\u05c1" - "\u05c2",
1818 "\u05c4",
1819 "\u064b" - "\u0652",
1820 "\u0670",
1821 "\u06d6" - "\u06dc",
1822 "\u06dd" - "\u06df",
1823 "\u06e0" - "\u06e4",
1824 "\u06e7" - "\u06e8",
1825 "\u06ea" - "\u06ed",
1826 "\u0901" - "\u0903",
1827 "\u093c",
1828 "\u093e" - "\u094c",
1829 "\u094d",
1830 "\u0951" - "\u0954",
1831 "\u0962" - "\u0963",
1832 "\u0981" - "\u0983",
1833 "\u09bc",
1834 "\u09be",
1835 "\u09bf",
1836 "\u09c0" - "\u09c4",
1837 "\u09c7" - "\u09c8",
1838 "\u09cb" - "\u09cd",
1839 "\u09d7",
1840 "\u09e2" - "\u09e3",
1841 "\u0a02",
1842 "\u0a3c",
1843 "\u0a3e",
1844 "\u0a3f",
1845 "\u0a40" - "\u0a42",
1846 "\u0a47" - "\u0a48",
1847 "\u0a4b" - "\u0a4d",
1848 "\u0a70" - "\u0a71",
1849 "\u0a81" - "\u0a83",
1850 "\u0abc",
1851 "\u0abe" - "\u0ac5",
1852 "\u0ac7" - "\u0ac9",
1853 "\u0acb" - "\u0acd",
1854 "\u0b01" - "\u0b03",
1855 "\u0b3c",
1856 "\u0b3e" - "\u0b43",
1857 "\u0b47" - "\u0b48",
1858 "\u0b4b" - "\u0b4d",
1859 "\u0b56" - "\u0b57",
1860 "\u0b82" - "\u0b83",
1861 "\u0bbe" - "\u0bc2",
1862 "\u0bc6" - "\u0bc8",
1863 "\u0bca" - "\u0bcd",
1864 "\u0bd7",
1865 "\u0c01" - "\u0c03",
1866 "\u0c3e" - "\u0c44",
1867 "\u0c46" - "\u0c48",
1868 "\u0c4a" - "\u0c4d",
1869 "\u0c55" - "\u0c56",
1870 "\u0c82" - "\u0c83",
1871 "\u0cbe" - "\u0cc4",
1872 "\u0cc6" - "\u0cc8",
1873 "\u0cca" - "\u0ccd",
1874 "\u0cd5" - "\u0cd6",
1875 "\u0d02" - "\u0d03",
1876 "\u0d3e" - "\u0d43",
1877 "\u0d46" - "\u0d48",
1878 "\u0d4a" - "\u0d4d",
1879 "\u0d57",
1880 "\u0e31",
1881 "\u0e34" - "\u0e3a",
1882 "\u0e47" - "\u0e4e",
1883 "\u0eb1",
1884 "\u0eb4" - "\u0eb9",
1885 "\u0ebb" - "\u0ebc",
1886 "\u0ec8" - "\u0ecd",
1887 "\u0f18" - "\u0f19",
1888 "\u0f35",
1889 "\u0f37",
1890 "\u0f39",
1891 "\u0f3e",
1892 "\u0f3f",
1893 "\u0f71" - "\u0f84",
1894 "\u0f86" - "\u0f8b",
1895 "\u0f90" - "\u0f95",
1896 "\u0f97",
1897 "\u0f99" - "\u0fad",
1898 "\u0fb1" - "\u0fb7",
1899 "\u0fb9",
1900 "\u20d0" - "\u20dc",
1901 "\u20e1",
1902 "\u302a" - "\u302f",
1903 "\u3099",
1904 "\u309a"
1905 ] >
1906 | < #DIGIT : [
1907 "\u0030" - "\u0039",
1908 "\u0660" - "\u0669",
1909 "\u06f0" - "\u06f9",
1910 "\u0966" - "\u096f",
1911 "\u09e6" - "\u09ef",
1912 "\u0a66" - "\u0a6f",
1913 "\u0ae6" - "\u0aef",
1914 "\u0b66" - "\u0b6f",
1915 "\u0be7" - "\u0bef",
1916 "\u0c66" - "\u0c6f",
1917 "\u0ce6" - "\u0cef",
1918 "\u0d66" - "\u0d6f",
1919 "\u0e50" - "\u0e59",
1920 "\u0ed0" - "\u0ed9",
1921 "\u0f20" - "\u0f29"
1922 ] >
1923 | < #EXTENDER : [
1924 "\u00b7",
1925 "\u02d0",
1926 "\u02d1",
1927 "\u0387",
1928 "\u0640",
1929 "\u0e46",
1930 "\u0ec6",
1931 "\u3005",
1932 "\u3031" - "\u3035",
1933 "\u309d" - "\u309e",
1934 "\u30fc" - "\u30fe"
1935 ] >
1936 | < #NMSTART : (<LETTER> | "_") >
1937 | < #NMCHAR : (<LETTER> | <COMBINING_CHAR> | <EXTENDER> | <DIGIT> | "." | "-" | "_") >
1938 | < #NCNAME: <NMSTART> (<NMCHAR>)* >
1939 }
1940
1941 TOKEN :
1942 {
1943 < IDENTIFIER: <NCNAME> >
1944 | < ESCAPED_IDENTIFIER: "\\" <NCNAME> >
1945 | < PREFIX_STAR: <NCNAME> ":*" >
1946 | < PREFIXED_NAME: <NCNAME> ":" <NCNAME> >
1947 | < LITERAL : ("\"" (~["\u0000", "\""])* "\"")
1948 | ("'" (~["\u0000", "'"])* "'")
1949 | ("\"\"\"" (~["\""]
1950 | ("\"" ~["\""])
1951 | ("\"\"" ~["\""]))* "\"\"\"")
1952 | ("'''" (~["'"]
1953 | ("'" ~["'"])
1954 | ("''" ~["'"]))* "'''") >
1955 | < FANNOTATE : ">>" >
1956 }
1957
1958 /* This avoids lexical errors from JavaCC. */
1959 <*>
1960 TOKEN :
1961 {
1962 < ILLEGAL_CHAR : [ "\u0000" - "\u0008", "\u000b" - "\uffff" ] >
1963 }