|
|
Java example source code file (CompactSyntax.jj)
This example Java source code file (CompactSyntax.jj) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The CompactSyntax.jj Java example source code
options {
STATIC = false;
UNICODE_INPUT = true;
JAVA_UNICODE_ESCAPE = true;
}
PARSER_BEGIN(CompactSyntax)
package com.sun.xml.internal.rngom.parse.compact;
import java.io.Reader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import com.sun.xml.internal.rngom.ast.builder.Annotations;
import com.sun.xml.internal.rngom.ast.builder.BuildException;
import com.sun.xml.internal.rngom.ast.builder.CommentList;
import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
import com.sun.xml.internal.rngom.ast.builder.Div;
import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
import com.sun.xml.internal.rngom.ast.builder.Grammar;
import com.sun.xml.internal.rngom.ast.builder.GrammarSection;
import com.sun.xml.internal.rngom.ast.builder.Include;
import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
import com.sun.xml.internal.rngom.ast.builder.Scope;
import com.sun.xml.internal.rngom.ast.om.Location;
import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
import com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
import com.sun.xml.internal.rngom.ast.om.ParsedPattern;
import com.sun.xml.internal.rngom.parse.Context;
import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
import com.sun.xml.internal.rngom.parse.Parseable;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.LocatorImpl;
import com.sun.xml.internal.rngom.util.Localizer;
import com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces;
public class CompactSyntax implements Context {
private static final int IN_ELEMENT = 0;
private static final int IN_ATTRIBUTE = 1;
private static final int IN_ANY_NAME = 2;
private static final int IN_NS_NAME = 4;
private String defaultNamespace;
private String compatibilityPrefix = null;
private SchemaBuilder sb;
private NameClassBuilder ncb;
private String sourceUri;
/**
* This is what we are parsing right now.
*/
private CompactParseable parseable;
private ErrorHandler eh;
private final Hashtable namespaceTable = new Hashtable();
private final Hashtable datatypesTable = new Hashtable();
private boolean hadError = false;
private static final Localizer localizer = new Localizer(new Localizer(Parseable.class),CompactSyntax.class);
private final Hashtable attributeNameTable = new Hashtable();
private boolean annotationsIncludeElements = false;
/**
* String that represents the inherited namespace.
*
* <p>
* HACK: we always allocate a new String instance so that
* we can distinguish inherited value from the explicitly
* given value.
*/
private /*final*/ String inheritedNs; // essentially final but JavaCC don't let us declare it as so.
final class LocatedString {
private final String str;
private final Token tok;
LocatedString(String str, Token tok) {
this.str = str;
this.tok = tok;
}
String getString() {
return str;
}
Location getLocation() {
return makeLocation(tok);
}
Token getToken() {
return tok;
}
}
public CompactSyntax(CompactParseable parseable, Reader r, String sourceUri, SchemaBuilder sb, ErrorHandler eh, String inheritedNs) {
this(r);
this.sourceUri = sourceUri;
this.parseable = parseable;
this.sb = sb;
this.ncb = sb.getNameClassBuilder();
this.eh = eh;
// this causes the root pattern to have non-null annotations
// which is useful because it gives a context to trang
this.topLevelComments = sb.makeCommentList();
this.inheritedNs = defaultNamespace = new String(inheritedNs);
}
ParsedPattern parse(Scope scope) throws IllegalSchemaException {
try {
ParsedPattern p = Input(scope);
if (!hadError)
return p;
}
catch (ParseException e) {
error("syntax_error", e.getMessage(), e.currentToken.next);
}
catch (EscapeSyntaxException e) {
reportEscapeSyntaxException(e);
}
throw new IllegalSchemaException();
}
ParsedPattern parseInclude(IncludedGrammar g) throws IllegalSchemaException {
try {
ParsedPattern p = IncludedGrammar(g);
if (!hadError)
return p;
}
catch (ParseException e) {
error("syntax_error", e.getMessage(), e.currentToken.next);
}
catch (EscapeSyntaxException e) {
reportEscapeSyntaxException(e);
}
throw new IllegalSchemaException();
}
private void checkNsName(int context, LocatedString ns) {
if ((context & IN_NS_NAME) != 0)
error("ns_name_except_contains_ns_name", ns.getToken());
}
private void checkAnyName(int context, Token t) {
if ((context & IN_NS_NAME) != 0)
error("ns_name_except_contains_any_name", t);
if ((context & IN_ANY_NAME) != 0)
error("any_name_except_contains_any_name", t);
}
private void error(String key, Token tok) {
doError(localizer.message(key), tok);
}
private void error(String key, String arg, Token tok) {
doError(localizer.message(key, arg), tok);
}
private void error(String key, String arg1, String arg2, Token tok) {
doError(localizer.message(key, arg1, arg2), tok);
}
private void doError(String message, Token tok) {
hadError = true;
if (eh != null) {
LocatorImpl loc = new LocatorImpl();
loc.setLineNumber(tok.beginLine);
loc.setColumnNumber(tok.beginColumn);
loc.setSystemId(sourceUri);
try {
eh.error(new SAXParseException(message, loc));
}
catch (SAXException se) {
throw new BuildException(se);
}
}
}
private void reportEscapeSyntaxException(EscapeSyntaxException e) {
if (eh != null) {
LocatorImpl loc = new LocatorImpl();
loc.setLineNumber(e.getLineNumber());
loc.setColumnNumber(e.getColumnNumber());
loc.setSystemId(sourceUri);
try {
eh.error(new SAXParseException(localizer.message(e.getKey()), loc));
}
catch (SAXException se) {
throw new BuildException(se);
}
}
}
private static String unquote(String s) {
if (s.length() >= 6 && s.charAt(0) == s.charAt(1)) {
s = s.replace('\u0000', '\n');
return s.substring(3, s.length() - 3);
}
else
return s.substring(1, s.length() - 1);
}
Location makeLocation(Token t) {
return sb.makeLocation(sourceUri, t.beginLine, t.beginColumn);
}
private static ParsedPattern[] addPattern(ParsedPattern[] patterns, int i, ParsedPattern p) {
if (i >= patterns.length) {
ParsedPattern[] oldPatterns = patterns;
patterns = new ParsedPattern[oldPatterns.length*2];
System.arraycopy(oldPatterns, 0, patterns, 0, oldPatterns.length);
}
patterns[i] = p;
return patterns;
}
String getCompatibilityPrefix() {
if (compatibilityPrefix == null) {
compatibilityPrefix = "a";
while (namespaceTable.get(compatibilityPrefix) != null)
compatibilityPrefix = compatibilityPrefix + "a";
}
return compatibilityPrefix;
}
public String resolveNamespacePrefix(String prefix) {
String result = (String)namespaceTable.get(prefix);
if (result.length() == 0)
return null;
return result;
}
public Enumeration prefixes() {
return namespaceTable.keys();
}
public String getBaseUri() {
return sourceUri;
}
public boolean isUnparsedEntity(String entityName) {
return false;
}
public boolean isNotation(String notationName) {
return false;
}
public Context copy() {
return this;
}
private Context getContext() {
return this;
}
private CommentList getComments() {
return getComments(getTopLevelComments());
}
private CommentList topLevelComments;
private CommentList getTopLevelComments() {
CommentList tem = topLevelComments;
topLevelComments = null;
return tem;
}
private void noteTopLevelComments() {
topLevelComments = getComments(topLevelComments);
}
private void topLevelComments(GrammarSection section) {
section.topLevelComment(getComments(null));
}
private Token lastCommentSourceToken = null;
private CommentList getComments(CommentList comments) {
Token nextToken = getToken(1);
if (lastCommentSourceToken != nextToken) {
if (lastCommentSourceToken == null)
lastCommentSourceToken = token;
do {
lastCommentSourceToken = lastCommentSourceToken.next;
Token t = lastCommentSourceToken.specialToken;
if (t != null) {
while (t.specialToken != null)
t = t.specialToken;
if (comments == null)
comments = sb.makeCommentList();
for (; t != null; t = t.next) {
String s = mungeComment(t.image);
Location loc = makeLocation(t);
if (t.next != null
&& t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE) {
StringBuffer buf = new StringBuffer(s);
do {
t = t.next;
buf.append('\n');
buf.append(mungeComment(t.image));
} while (t.next != null
&& t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE);
s = buf.toString();
}
comments.addComment(s, loc);
}
}
} while (lastCommentSourceToken != nextToken);
}
return comments;
}
private ParsedPattern afterComments(ParsedPattern p) {
CommentList comments = getComments(null);
if (comments == null)
return p;
return sb.commentAfter(p, comments);
}
private ParsedNameClass afterComments(ParsedNameClass nc) {
CommentList comments = getComments(null);
if (comments == null)
return nc;
return ncb.commentAfter(nc, comments);
}
private static String mungeComment(String image) {
int i = image.indexOf('#') + 1;
while (i < image.length() && image.charAt(i) == '#')
i++;
if (i < image.length() && image.charAt(i) == ' ')
i++;
return image.substring(i);
}
private Annotations getCommentsAsAnnotations() {
CommentList comments = getComments();
if (comments == null)
return null;
return sb.makeAnnotations(comments, getContext());
}
private Annotations addCommentsToChildAnnotations(Annotations a) {
CommentList comments = getComments();
if (comments == null)
return a;
if (a == null)
a = sb.makeAnnotations(null, getContext());
a.addComment(comments);
return a;
}
private Annotations addCommentsToLeadingAnnotations(Annotations a) {
CommentList comments = getComments();
if (comments == null)
return a;
if (a == null)
return sb.makeAnnotations(comments, getContext());
a.addLeadingComment(comments);
return a;
}
private Annotations getTopLevelCommentsAsAnnotations() {
CommentList comments = getTopLevelComments();
if (comments == null)
return null;
return sb.makeAnnotations(comments, getContext());
}
private void clearAttributeList() {
attributeNameTable.clear();
}
private void addAttribute(Annotations a, String ns, String localName, String prefix, String value, Token tok) {
String key = ns + "#" + localName;
if (attributeNameTable.get(key) != null)
error("duplicate_attribute", ns, localName, tok);
else {
attributeNameTable.put(key, key);
a.addAttribute(ns, localName, prefix, value, makeLocation(tok));
}
}
private void checkExcept(Token[] except) {
if (except[0] != null)
error("except_missing_parentheses", except[0]);
}
private String lookupPrefix(String prefix, Token t) {
String ns = (String)namespaceTable.get(prefix);
if (ns == null) {
error("undeclared_prefix", prefix, t);
return "#error";
}
return ns;
}
private String lookupDatatype(String prefix, Token t) {
String ns = (String)datatypesTable.get(prefix);
if (ns == null) {
error("undeclared_prefix", prefix, t);
return ""; // XXX
}
return ns;
}
private String resolve(String str) {
try {
return new URL(new URL(sourceUri), str).toString();
}
catch (MalformedURLException e) { }
return str;
}
}
PARSER_END(CompactSyntax)
ParsedPattern Input(Scope scope) :
{
ParsedPattern p;
}
{
Preamble()
(LOOKAHEAD(TopLevelLookahead()) p = TopLevelGrammar(scope)
| p = Expr(true, scope, null, null) { p = afterComments(p); } <EOF>)
{ return p; }
}
void TopLevelLookahead() :
{}
{
<PREFIXED_NAME> "["
| Identifier() ("[" | "=" | "&=" | "|=")
| LookaheadGrammarKeyword()
| LookaheadBody() LookaheadAfterAnnotations()
| LookaheadDocumentation() (LookaheadBody())? LookaheadAfterAnnotations()
}
void LookaheadAfterAnnotations() :
{}
{
Identifier() ("=" | "&=" | "|=")
| LookaheadGrammarKeyword()
}
void LookaheadGrammarKeyword() :
{}
{
"start" | "div" | "include"
}
void LookaheadDocumentation() :
{}
{
((<DOCUMENTATION> | ) ()*)+
}
void LookaheadBody() :
{}
{
"["
(<PREFIXED_NAME> | UnprefixedName() | "=" | | "~" | LookaheadBody() )*
"]"
}
ParsedPattern IncludedGrammar(IncludedGrammar g) :
{
Annotations a;
ParsedPattern p;
}
{
Preamble()
(LOOKAHEAD(TopLevelLookahead()) a = GrammarBody(g, g, getTopLevelCommentsAsAnnotations())
| a = Annotations() "grammar" "{" a = GrammarBody(g, g, a) { topLevelComments(g); } "}")
{ p = afterComments(g.endIncludedGrammar(sb.makeLocation(sourceUri, 1, 1), a)); }
<EOF>
{ return p; }
}
ParsedPattern TopLevelGrammar(Scope scope) :
{
Annotations a = getTopLevelCommentsAsAnnotations();
Grammar g;
ParsedPattern p;
}
{
{ g = sb.makeGrammar(scope); }
a = GrammarBody(g, g, a)
{ p = afterComments(g.endGrammar(sb.makeLocation(sourceUri, 1, 1), a)); }
<EOF>
{ return p; }
}
void Preamble() :
{}
{
(NamespaceDecl() | DatatypesDecl())*
{
namespaceTable.put("xml", WellKnownNamespaces.XML);
if (datatypesTable.get("xsd") == null)
datatypesTable.put("xsd", WellKnownNamespaces.XML_SCHEMA_DATATYPES);
}
}
void NamespaceDecl() :
{
LocatedString prefix = null;
boolean isDefault = false;
String namespaceName;
}
{
{ noteTopLevelComments(); }
(("namespace" prefix = UnprefixedName())
| ("default" { isDefault = true; }
"namespace" (prefix = UnprefixedName())?))
"="
namespaceName = NamespaceName()
{
if (isDefault)
defaultNamespace = namespaceName;
if (prefix != null) {
if (prefix.getString().equals("xmlns"))
error("xmlns_prefix", prefix.getToken());
else if (prefix.getString().equals("xml")) {
if (!namespaceName.equals(WellKnownNamespaces.XML))
error("xml_prefix_bad_uri", prefix.getToken());
}
else if (namespaceName.equals(WellKnownNamespaces.XML))
error("xml_uri_bad_prefix", prefix.getToken());
else {
if (namespaceName.equals(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS))
compatibilityPrefix = prefix.getString();
namespaceTable.put(prefix.getString(), namespaceName);
}
}
}
}
String NamespaceName() :
{
String r;
}
{
(r = Literal() | "inherit" { r = this.inheritedNs; })
{ return r; }
}
void DatatypesDecl() :
{
LocatedString prefix;
String uri;
}
{
{ noteTopLevelComments(); }
"datatypes" prefix = UnprefixedName() "=" uri = Literal()
{
datatypesTable.put(prefix.getString(), uri);
}
}
ParsedPattern AnnotatedPrimaryExpr(boolean topLevel, Scope scope, Token[] except) :
{
Annotations a;
ParsedPattern p;
ParsedElementAnnotation e;
Token t;
}
{
a = Annotations()
p = PrimaryExpr(topLevel, scope, a, except)
( t = <FANNOTATE> e = AnnotationElement(false) {
if (topLevel)
error("top_level_follow_annotation", t);
else
p = sb.annotateAfter(p, e);
})*
{ return p; }
}
ParsedPattern PrimaryExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) :
{
ParsedPattern p;
}
{
(p = ElementExpr(scope, a)
| p = AttributeExpr(scope, a)
| p = GrammarExpr(scope, a)
| p = ExternalRefExpr(scope, a)
| p = ListExpr(scope, a)
| p = MixedExpr(scope, a)
| p = ParenExpr(topLevel, scope, a)
| p = IdentifierExpr(scope, a)
| p = ParentExpr(scope, a)
| p = DataExpr(topLevel, scope, a, except)
| p = ValueExpr(topLevel, a)
| p = TextExpr(a)
| p = EmptyExpr(a)
| p = NotAllowedExpr(a))
{ return p; }
}
ParsedPattern EmptyExpr(Annotations a) :
{
Token t;
}
{
t = "empty"
{ return sb.makeEmpty(makeLocation(t), a); }
}
ParsedPattern TextExpr(Annotations a) :
{
Token t;
}
{
t = "text"
{ return sb.makeText(makeLocation(t), a); }
}
ParsedPattern NotAllowedExpr(Annotations a) :
{
Token t;
}
{
t = "notAllowed"
{ return sb.makeNotAllowed(makeLocation(t), a); }
}
ParsedPattern Expr(boolean topLevel, Scope scope, Token t, Annotations a) :
{
List patterns = new ArrayList();
ParsedPattern p;
boolean[] hadOccur = new boolean[1];
Token[] except = new Token[1];
}
{
p = UnaryExpr(topLevel, scope, hadOccur, except)
{ patterns.add(p); }
(
{ checkExcept(except); }
(t = "|" p = UnaryExpr(topLevel, scope, null, except)
{ patterns.add(p); checkExcept(except); } )+
{ p = sb.makeChoice(patterns, makeLocation(t), a); }
| (t = "&" p = UnaryExpr(topLevel, scope, null, except)
{ patterns.add(p); checkExcept(except); } )+
{ p = sb.makeInterleave(patterns, makeLocation(t), a); }
| (t = "," p = UnaryExpr(topLevel, scope, null, except)
{ patterns.add(p); checkExcept(except); } )+
{ p = sb.makeGroup(patterns, makeLocation(t), a); }
)?
{
if (patterns.size() == 1 && a != null) {
if (hadOccur[0])
p = sb.annotate(p, a);
else
p = sb.makeGroup(patterns, makeLocation(t), a);
}
return p;
}
}
ParsedPattern UnaryExpr(boolean topLevel, Scope scope, boolean[] hadOccur, Token[] except) :
{
ParsedPattern p;
Token t;
ParsedElementAnnotation e;
}
{
p = AnnotatedPrimaryExpr(topLevel, scope, except)
(
{
if (hadOccur != null) hadOccur[0] = true;
p = afterComments(p);
}
(t = "+" { checkExcept(except); p = sb.makeOneOrMore(p, makeLocation(t), null); }
| t = "?" { checkExcept(except); p = sb.makeOptional(p, makeLocation(t), null); }
| t = "*" { checkExcept(except); p = sb.makeZeroOrMore(p, makeLocation(t), null); })
( t = <FANNOTATE> e = AnnotationElement(false) {
if (topLevel)
error("top_level_follow_annotation", t);
else
p = sb.annotateAfter(p, e);
} )*
)?
{ return p; }
}
ParsedPattern ElementExpr(Scope scope, Annotations a) :
{
Token t;
ParsedNameClass nc;
ParsedPattern p;
}
{
t = "element"
nc = NameClass(IN_ELEMENT, null)
"{"
p = Expr(false, scope, null, null)
{ p = afterComments(p); }
"}"
{ return sb.makeElement(nc, p, makeLocation(t), a); }
}
ParsedPattern AttributeExpr(Scope scope, Annotations a) :
{
Token t;
ParsedNameClass nc;
ParsedPattern p;
}
{
t = "attribute"
nc = NameClass(IN_ATTRIBUTE, null)
"{"
p = Expr(false, scope, null, null)
{ p = afterComments(p); }
"}"
{ return sb.makeAttribute(nc, p, makeLocation(t), a); }
}
ParsedNameClass NameClass(int context, Annotations[] pa) :
{
Annotations a;
ParsedNameClass nc;
}
{
a = Annotations()
(nc = PrimaryNameClass(context, a) nc = AnnotateAfter(nc) nc = NameClassAlternatives(context, nc, pa)
| nc = AnyNameExceptClass(context, a, pa)
| nc = NsNameExceptClass(context, a, pa))
{ return nc; }
}
ParsedNameClass AnnotateAfter(ParsedNameClass nc) :
{
ParsedElementAnnotation e;
}
{
( <FANNOTATE> e = AnnotationElement(false) { nc = ncb.annotateAfter(nc, e); })*
{ return nc; }
}
ParsedNameClass NameClassAlternatives(int context, ParsedNameClass nc, Annotations[] pa) :
{
Token t;
ParsedNameClass[] nameClasses;
int nNameClasses;
}
{
(
{
nameClasses = new ParsedNameClass[2];
nameClasses[0] = nc;
nNameClasses = 1;
}
(t = "|" nc = BasicNameClass(context) nc = AnnotateAfter(nc)
{
if (nNameClasses >= nameClasses.length) {
ParsedNameClass[] oldNameClasses = nameClasses;
nameClasses = new ParsedNameClass[oldNameClasses.length*2];
System.arraycopy(oldNameClasses, 0, nameClasses, 0, oldNameClasses.length);
}
nameClasses[nNameClasses++] = nc;
})+
{
Annotations a;
if (pa == null)
a = null;
else {
a = pa[0];
pa[0] = null;
}
nc = ncb.makeChoice(Arrays.asList(nameClasses).subList(0,nNameClasses), makeLocation(t), a);
}
)?
{ return nc; }
}
ParsedNameClass BasicNameClass(int context) :
{
Annotations a;
ParsedNameClass nc;
}
{
a = Annotations()
(nc = PrimaryNameClass(context, a)
| nc = OpenNameClass(context, a))
{ return nc; }
}
ParsedNameClass PrimaryNameClass(int context, Annotations a) :
{
ParsedNameClass nc;
}
{
(nc = UnprefixedNameClass(context, a)
| nc = PrefixedNameClass(a)
| nc = ParenNameClass(context, a))
{ return nc; }
}
ParsedNameClass OpenNameClass(int context, Annotations a) :
{
Token t;
LocatedString ns;
}
{
ns = NsName() { checkNsName(context, ns); return ncb.makeNsName(ns.getString(), ns.getLocation(), a); }
| t = "*" { checkAnyName(context, t); return ncb.makeAnyName(makeLocation(t), a); }
}
ParsedNameClass UnprefixedNameClass(int context, Annotations a) :
{
LocatedString name;
}
{
name = UnprefixedName()
{
String ns;
if ((context & (IN_ATTRIBUTE|IN_ELEMENT)) == IN_ATTRIBUTE)
ns = "";
else
ns = defaultNamespace;
return ncb.makeName(ns, name.getString(), null, name.getLocation(), a);
}
}
ParsedNameClass PrefixedNameClass(Annotations a) :
{
Token t;
}
{
t = <PREFIXED_NAME>
{
String qn = t.image;
int colon = qn.indexOf(':');
String prefix = qn.substring(0, colon);
return ncb.makeName(lookupPrefix(prefix, t), qn.substring(colon + 1), prefix, makeLocation(t), a);
}
}
ParsedNameClass NsNameExceptClass(int context, Annotations a, Annotations[] pa) :
{
LocatedString ns;
ParsedNameClass nc;
}
{
ns = NsName()
{ checkNsName(context, ns); }
(nc = ExceptNameClass(context | IN_NS_NAME)
{ nc = ncb.makeNsName(ns.getString(), nc, ns.getLocation(), a); }
nc = AnnotateAfter(nc)
| { nc = ncb.makeNsName(ns.getString(), ns.getLocation(), a); }
nc = AnnotateAfter(nc)
nc = NameClassAlternatives(context, nc, pa))
{ return nc; }
}
LocatedString NsName() :
{
Token t;
}
{
t = <PREFIX_STAR>
{
String qn = t.image;
String prefix = qn.substring(0, qn.length() - 2);
return new LocatedString(lookupPrefix(prefix, t), t);
}
}
ParsedNameClass AnyNameExceptClass(int context, Annotations a, Annotations[] pa) :
{
Token t;
ParsedNameClass nc;
}
{
t = "*"
{ checkAnyName(context, t); }
(nc = ExceptNameClass(context | IN_ANY_NAME)
{ nc = ncb.makeAnyName(nc, makeLocation(t), a); }
nc = AnnotateAfter(nc)
| { nc = ncb.makeAnyName(makeLocation(t), a); }
nc = AnnotateAfter(nc)
nc = NameClassAlternatives(context, nc, pa))
{ return nc; }
}
ParsedNameClass ParenNameClass(int context, Annotations a) :
{
Token t;
ParsedNameClass nc;
Annotations[] pa = new Annotations[]{ a };
}
{
t = "(" nc = NameClass(context, pa) { nc = afterComments(nc); } ")"
{
if (pa[0] != null)
nc = ncb.makeChoice(Collections.singletonList(nc), makeLocation(t), pa[0]);
return nc;
}
}
ParsedNameClass ExceptNameClass(int context) :
{
ParsedNameClass nc;
}
{
"-" nc = BasicNameClass(context)
{ return nc; }
}
ParsedPattern ListExpr(Scope scope, Annotations a) :
{
Token t;
ParsedPattern p;
}
{
t = "list"
"{"
p = Expr(false, scope, null, null)
{ p = afterComments(p); }
"}"
{ return sb.makeList(p, makeLocation(t), a); }
}
ParsedPattern MixedExpr(Scope scope, Annotations a) :
{
Token t;
ParsedPattern p;
}
{
t = "mixed"
"{"
p = Expr(false, scope, null, null)
{ p = afterComments(p); }
"}"
{ return sb.makeMixed(p, makeLocation(t), a); }
}
ParsedPattern GrammarExpr(Scope scope, Annotations a) :
{
Token t;
Grammar g;
}
{
t = "grammar" { g = sb.makeGrammar(scope); }
"{" a = GrammarBody(g, g, a) { topLevelComments(g); } "}"
{ return g.endGrammar(makeLocation(t), a); }
}
ParsedPattern ParenExpr(boolean topLevel, Scope scope, Annotations a) :
{
Token t;
ParsedPattern p;
}
{
t = "(" p = Expr(topLevel, scope, t, a) { p = afterComments(p); } ")"
{ return p; }
}
Annotations GrammarBody(GrammarSection section, Scope scope, Annotations a) :
{
ParsedElementAnnotation e;
}
{
(LOOKAHEAD(2) e = AnnotationElementNotKeyword()
{ if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); })*
(GrammarComponent(section, scope))*
{ return a; }
}
void GrammarComponent(GrammarSection section, Scope scope) :
{
ParsedElementAnnotation e;
Annotations a;
}
{
(a = Annotations()
(Definition(section, scope, a)
| Include(section, scope, a)
| Div(section, scope, a)))
(LOOKAHEAD(2) e = AnnotationElementNotKeyword() { section.topLevelAnnotation(e); })*
}
void Definition(GrammarSection section, Scope scope, Annotations a) :
{}
{
(Define(section, scope, a) | Start(section, scope, a))
}
void Start(GrammarSection section, Scope scope, Annotations a) :
{
Token t;
GrammarSection.Combine combine;
ParsedPattern p;
}
{
t = "start" combine = AssignOp() p = Expr(false, scope, null, null)
{ section.define(GrammarSection.START, combine, p, makeLocation(t), a); }
}
void Define(GrammarSection section, Scope scope, Annotations a) :
{
LocatedString name;
GrammarSection.Combine combine;
ParsedPattern p;
}
{
name = Identifier() combine = AssignOp() p = Expr(false, scope, null, null)
{ section.define(name.getString(), combine, p, name.getLocation(), a); }
}
GrammarSection.Combine AssignOp() :
{}
{
"=" { return null; }
| "|=" { return GrammarSection.COMBINE_CHOICE; }
| "&=" { return GrammarSection.COMBINE_INTERLEAVE; }
}
void Include(GrammarSection section, Scope scope, Annotations a) :
{
Token t;
String href;
String ns;
Include include = section.makeInclude();
}
{
t = "include" href = Literal()
ns = Inherit()
("{" a = IncludeBody(include, scope, a) { topLevelComments(include); } "}")?
{
try {
include.endInclude(parseable, resolve(href), ns, makeLocation(t), a);
}
catch (IllegalSchemaException e) { }
}
}
Annotations IncludeBody(GrammarSection section, Scope scope, Annotations a) :
{
ParsedElementAnnotation e;
}
{
(LOOKAHEAD(2) e = AnnotationElementNotKeyword()
{ if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); })*
(IncludeComponent(section, scope))*
{ return a; }
}
void IncludeComponent(GrammarSection section, Scope scope) :
{
ParsedElementAnnotation e;
Annotations a;
}
{
(a = Annotations() (Definition(section, scope, a)
| IncludeDiv(section, scope, a)))
(LOOKAHEAD(2) e = AnnotationElementNotKeyword() { section.topLevelAnnotation(e); })*
}
void Div(GrammarSection section, Scope scope, Annotations a) :
{
Token t;
Div div = section.makeDiv();
}
{
t = "div" "{" a = GrammarBody(div, scope, a) { topLevelComments(div); } "}"
{ div.endDiv(makeLocation(t), a); }
}
void IncludeDiv(GrammarSection section, Scope scope, Annotations a) :
{
Token t;
Div div = section.makeDiv();
}
{
t = "div" "{" a = IncludeBody(div, scope, a) { topLevelComments(div); } "}"
{ div.endDiv(makeLocation(t), a); }
}
ParsedPattern ExternalRefExpr(Scope scope, Annotations a) :
{
Token t;
String href;
String ns;
}
{
t = "external" href = Literal()
ns = Inherit()
{
try {
return sb.makeExternalRef(parseable, resolve(href), ns, scope, makeLocation(t), a);
}
catch (IllegalSchemaException e) {
return sb.makeErrorPattern();
}
}
}
String Inherit() :
{
String ns = null;
}
{
("inherit" "=" ns = Prefix())?
{
if (ns == null)
ns = defaultNamespace;
return ns;
}
}
ParsedPattern ParentExpr(Scope scope, Annotations a) :
{
LocatedString name;
}
{
"parent" { a = addCommentsToChildAnnotations(a); } name = Identifier()
{
if(scope==null) {
error("parent_ref_outside_grammar",name.getToken());
return sb.makeErrorPattern();
} else {
return scope.makeParentRef(name.getString(), name.getLocation(), a);
}
}
}
ParsedPattern IdentifierExpr(Scope scope, Annotations a) :
{
LocatedString name;
}
{
name = Identifier()
{
if(scope==null) {
error("ref_outside_grammar",name.getToken());
return sb.makeErrorPattern();
} else {
return scope.makeRef(name.getString(), name.getLocation(), a);
}
}
}
ParsedPattern ValueExpr(boolean topLevel, Annotations a) :
{
LocatedString s;
}
{
s = LocatedLiteral()
{
if (topLevel && annotationsIncludeElements) {
error("top_level_follow_annotation", s.getToken());
a = null;
}
return sb.makeValue("", "token", s.getString(), getContext(), defaultNamespace, s.getLocation(), a);
}
}
ParsedPattern DataExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) :
{
Token datatypeToken;
Location loc;
String datatype;
String datatypeUri = null;
String s = null;
ParsedPattern e = null;
DataPatternBuilder dpb;
}
{
datatypeToken = DatatypeName()
{
datatype = datatypeToken.image;
loc = makeLocation(datatypeToken);
int colon = datatype.indexOf(':');
if (colon < 0)
datatypeUri = "";
else {
String prefix = datatype.substring(0, colon);
datatypeUri = lookupDatatype(prefix, datatypeToken);
datatype = datatype.substring(colon + 1);
}
}
((s = Literal()
{
if (topLevel && annotationsIncludeElements) {
error("top_level_follow_annotation", datatypeToken);
a = null;
}
return sb.makeValue(datatypeUri, datatype, s, getContext(), defaultNamespace, loc, a);
}
)
| ( { dpb = sb.makeDataPatternBuilder(datatypeUri, datatype, loc); }
( (Params(dpb) (e = Except(scope, except))?)
| (e = Except(scope, except))?)
{ return e == null ? dpb.makePattern(loc, a) : dpb.makePattern(e, loc, a); }))
}
Token DatatypeName() :
{
Token t;
}
{
(t = "string" | t = "token" | t = <PREFIXED_NAME>)
{ return t; }
}
LocatedString Identifier() :
{
LocatedString s;
Token t;
}
{
(t = <IDENTIFIER> { s = new LocatedString(t.image, t); }
| t = <ESCAPED_IDENTIFIER> { s = new LocatedString(t.image.substring(1), t); })
{ return s; }
}
String Prefix() :
{
Token t;
String prefix;
}
{
(t = <IDENTIFIER> { prefix = t.image; }
| t = <ESCAPED_IDENTIFIER> { prefix = t.image.substring(1); }
| t = Keyword() { prefix = t.image; })
{ return lookupPrefix(prefix, t); }
}
LocatedString UnprefixedName() :
{
LocatedString s;
Token t;
}
{
(s = Identifier()
| t = Keyword() { s = new LocatedString(t.image, t); })
{ return s; }
}
void Params(DataPatternBuilder dpb) :
{}
{
"{" (Param(dpb))* "}"
}
void Param(DataPatternBuilder dpb) :
{
LocatedString name;
Annotations a;
String value;
}
{
a = Annotations() name = UnprefixedName() "=" { a = addCommentsToLeadingAnnotations(a); } value = Literal()
{ dpb.addParam(name.getString(), value, getContext(), defaultNamespace, name.getLocation(), a); }
}
ParsedPattern Except(Scope scope, Token[] except) :
{
Annotations a;
ParsedPattern p;
Token t;
Token[] innerExcept = new Token[1];
}
{
t = "-" a = Annotations() p = PrimaryExpr(false, scope, a, innerExcept)
{
checkExcept(innerExcept);
except[0] = t;
return p;
}
}
ParsedElementAnnotation Documentation() :
{
CommentList comments = getComments();
ElementAnnotationBuilder eab;
Token t;
}
{
(t = <DOCUMENTATION> | t = )
{
eab = sb.makeElementAnnotationBuilder(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS,
"documentation",
getCompatibilityPrefix(),
makeLocation(t),
comments,
getContext());
eab.addText(mungeComment(t.image), makeLocation(t), null);
}
(t = <DOCUMENTATION_CONTINUE> { eab.addText("\n" + mungeComment(t.image), makeLocation(t), null); })*
{ return eab.makeElementAnnotation(); }
}
Annotations Annotations() :
{
CommentList comments = getComments();
Annotations a = null;
ParsedElementAnnotation e;
}
{
( { a = sb.makeAnnotations(comments, getContext()); }
(e = Documentation() { a.addElement(e); })+
{
comments = getComments();
if (comments != null)
a.addLeadingComment(comments);
}
)?
("[" { if (a == null) a = sb.makeAnnotations(comments, getContext()); clearAttributeList(); annotationsIncludeElements = false; }
(LOOKAHEAD(2) PrefixedAnnotationAttribute(a, false) )*
( e = AnnotationElement(false) { a.addElement(e); annotationsIncludeElements = true; } )*
{ a.addComment(getComments()); }
"]")?
{
if (a == null && comments != null)
a = sb.makeAnnotations(comments, getContext());
return a;
}
}
void AnnotationAttribute(Annotations a) :
{}
{
PrefixedAnnotationAttribute(a, true) | UnprefixedAnnotationAttribute(a)
}
void PrefixedAnnotationAttribute(Annotations a, boolean nested) :
{
Token t;
String value;
}
{
t = <PREFIXED_NAME> "=" value = Literal()
{
String qn = t.image;
int colon = qn.indexOf(':');
String prefix = qn.substring(0, colon);
String ns = lookupPrefix(prefix, t);
if (ns == this.inheritedNs)
error("inherited_annotation_namespace", t);
else if (ns.length() == 0 && !nested)
error("unqualified_annotation_attribute", t);
else if (ns.equals(WellKnownNamespaces.RELAX_NG) && !nested)
error("relax_ng_namespace", t);
/*else if (ns.length() == 0
&& qn.length() - colon - 1 == 5
&& qn.regionMatches(colon + 1, "xmlns", 0, 5))
error("xmlns_annotation_attribute", t);*/
else if (ns.equals(WellKnownNamespaces.XMLNS))
error("xmlns_annotation_attribute_uri", t);
else {
if (ns.length() == 0)
prefix = null;
addAttribute(a, ns, qn.substring(colon + 1), prefix, value, t);
}
}
}
void UnprefixedAnnotationAttribute(Annotations a) :
{
LocatedString name;
String value;
}
{
name = UnprefixedName() "=" value = Literal()
{
if (name.getString().equals("xmlns"))
error("xmlns_annotation_attribute", name.getToken());
else
addAttribute(a, "", name.getString(), null, value, name.getToken());
}
}
ParsedElementAnnotation AnnotationElement(boolean nested) :
{
ParsedElementAnnotation a;
}
{
(a = PrefixedAnnotationElement(nested)
| a = UnprefixedAnnotationElement())
{ return a; }
}
ParsedElementAnnotation AnnotationElementNotKeyword() :
{
ParsedElementAnnotation a;
}
{
(a = PrefixedAnnotationElement(false)
| a = IdentifierAnnotationElement())
{ return a; }
}
ParsedElementAnnotation PrefixedAnnotationElement(boolean nested) :
{
CommentList comments = getComments();
Token t;
ElementAnnotationBuilder eab;
}
{
t = <PREFIXED_NAME>
{
String qn = t.image;
int colon = qn.indexOf(':');
String prefix = qn.substring(0, colon);
String ns = lookupPrefix(prefix, t);
if (ns == this.inheritedNs) {
error("inherited_annotation_namespace", t);
ns = "";
}
else if (!nested && ns.equals(WellKnownNamespaces.RELAX_NG)) {
error("relax_ng_namespace", t);
ns = "";
}
else {
if (ns.length() == 0)
prefix = null;
}
eab = sb.makeElementAnnotationBuilder(ns, qn.substring(colon + 1), prefix,
makeLocation(t), comments, getContext());
}
AnnotationElementContent(eab)
{ return eab.makeElementAnnotation(); }
}
ParsedElementAnnotation UnprefixedAnnotationElement() :
{
CommentList comments = getComments();
LocatedString name;
ElementAnnotationBuilder eab;
}
{
name = UnprefixedName()
{
eab = sb.makeElementAnnotationBuilder("", name.getString(), null,
name.getLocation(), comments, getContext());
}
AnnotationElementContent(eab)
{ return eab.makeElementAnnotation(); }
}
ParsedElementAnnotation IdentifierAnnotationElement() :
{
CommentList comments = getComments();
LocatedString name;
ElementAnnotationBuilder eab;
}
{
name = Identifier()
{
eab = sb.makeElementAnnotationBuilder("", name.getString(), null,
name.getLocation(), comments, getContext());
}
AnnotationElementContent(eab)
{ return eab.makeElementAnnotation(); }
}
void AnnotationElementContent(ElementAnnotationBuilder eab) :
{
ParsedElementAnnotation e;
}
{
"[" { clearAttributeList(); }
(LOOKAHEAD(2) AnnotationAttribute(eab))*
((AnnotationElementLiteral(eab)
("~" AnnotationElementLiteral(eab))*)
| e = AnnotationElement(true) { eab.addElement(e); })*
{ eab.addComment(getComments()); }
"]"
}
void AnnotationElementLiteral(ElementAnnotationBuilder eab) :
{
Token t;
CommentList comments = getComments();
}
{
t = <LITERAL> { eab.addText(unquote(t.image), makeLocation(t), comments); }
}
String Literal() :
{
Token t;
String s;
StringBuffer buf;
}
{
t = <LITERAL>
{
s = unquote(t.image);
}
(
{ buf = new StringBuffer(s); }
("~" t = <LITERAL> { buf.append(unquote(t.image)); })+
{ s = buf.toString(); }
)?
{ return s; }
}
LocatedString LocatedLiteral() :
{
Token t;
Token t2;
String s;
StringBuffer buf;
}
{
t = <LITERAL>
{
s = unquote(t.image);
}
(
{ buf = new StringBuffer(s); }
("~" t2 = <LITERAL> { buf.append(unquote(t2.image)); })+
{ s = buf.toString(); }
)?
{ return new LocatedString(s, t); }
}
Token Keyword() :
{
Token t;
}
{
(t = "element"
| t = "attribute"
| t = "namespace"
| t = "list"
| t = "mixed"
| t = "grammar"
| t = "empty"
| t = "text"
| t = "parent"
| t = "external"
| t = "notAllowed"
| t = "start"
| t = "include"
| t = "default"
| t = "inherit"
| t = "string"
| t = "token"
| t = "datatypes"
| t = "div")
{ return t; }
}
<*>
SKIP: {
< #NEWLINE : [ "\u0000", "\n" ] >
| < #NOT_NEWLINE : ~[ "\u0000", "\n" ] >
| < WS: ([ "\u0000", " ", "\n", "\t" ])+ > : DEFAULT
}
TOKEN :
{
< DOCUMENTATION: "##" ( : AFTER_DOCUMENTATION
}
<AFTER_DOCUMENTATION>
TOKEN :
{
< DOCUMENTATION_CONTINUE: >
}
SPECIAL_TOKEN:
{
< SINGLE_LINE_COMMENT: "#" ( : AFTER_SINGLE_LINE_COMMENT
}
<AFTER_SINGLE_LINE_COMMENT>
TOKEN :
{
< DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: > : AFTER_DOCUMENTATION
}
<AFTER_SINGLE_LINE_COMMENT>
SPECIAL_TOKEN :
{
< SINGLE_LINE_COMMENT_CONTINUE: >
}
TOKEN :
{
< #BASE_CHAR : [
"\u0041" - "\u005a",
"\u0061" - "\u007a",
"\u00c0" - "\u00d6",
"\u00d8" - "\u00f6",
"\u00f8" - "\u00ff",
"\u0100" - "\u0131",
"\u0134" - "\u013e",
"\u0141" - "\u0148",
"\u014a" - "\u017e",
"\u0180" - "\u01c3",
"\u01cd" - "\u01f0",
"\u01f4" - "\u01f5",
"\u01fa" - "\u0217",
"\u0250" - "\u02a8",
"\u02bb" - "\u02c1",
"\u0386",
"\u0388" - "\u038a",
"\u038c",
"\u038e" - "\u03a1",
"\u03a3" - "\u03ce",
"\u03d0" - "\u03d6",
"\u03da",
"\u03dc",
"\u03de",
"\u03e0",
"\u03e2" - "\u03f3",
"\u0401" - "\u040c",
"\u040e" - "\u044f",
"\u0451" - "\u045c",
"\u045e" - "\u0481",
"\u0490" - "\u04c4",
"\u04c7" - "\u04c8",
"\u04cb" - "\u04cc",
"\u04d0" - "\u04eb",
"\u04ee" - "\u04f5",
"\u04f8" - "\u04f9",
"\u0531" - "\u0556",
"\u0559",
"\u0561" - "\u0586",
"\u05d0" - "\u05ea",
"\u05f0" - "\u05f2",
"\u0621" - "\u063a",
"\u0641" - "\u064a",
"\u0671" - "\u06b7",
"\u06ba" - "\u06be",
"\u06c0" - "\u06ce",
"\u06d0" - "\u06d3",
"\u06d5",
"\u06e5" - "\u06e6",
"\u0905" - "\u0939",
"\u093d",
"\u0958" - "\u0961",
"\u0985" - "\u098c",
"\u098f" - "\u0990",
"\u0993" - "\u09a8",
"\u09aa" - "\u09b0",
"\u09b2",
"\u09b6" - "\u09b9",
"\u09dc" - "\u09dd",
"\u09df" - "\u09e1",
"\u09f0" - "\u09f1",
"\u0a05" - "\u0a0a",
"\u0a0f" - "\u0a10",
"\u0a13" - "\u0a28",
"\u0a2a" - "\u0a30",
"\u0a32" - "\u0a33",
"\u0a35" - "\u0a36",
"\u0a38" - "\u0a39",
"\u0a59" - "\u0a5c",
"\u0a5e",
"\u0a72" - "\u0a74",
"\u0a85" - "\u0a8b",
"\u0a8d",
"\u0a8f" - "\u0a91",
"\u0a93" - "\u0aa8",
"\u0aaa" - "\u0ab0",
"\u0ab2" - "\u0ab3",
"\u0ab5" - "\u0ab9",
"\u0abd",
"\u0ae0",
"\u0b05" - "\u0b0c",
"\u0b0f" - "\u0b10",
"\u0b13" - "\u0b28",
"\u0b2a" - "\u0b30",
"\u0b32" - "\u0b33",
"\u0b36" - "\u0b39",
"\u0b3d",
"\u0b5c" - "\u0b5d",
"\u0b5f" - "\u0b61",
"\u0b85" - "\u0b8a",
"\u0b8e" - "\u0b90",
"\u0b92" - "\u0b95",
"\u0b99" - "\u0b9a",
"\u0b9c",
"\u0b9e" - "\u0b9f",
"\u0ba3" - "\u0ba4",
"\u0ba8" - "\u0baa",
"\u0bae" - "\u0bb5",
"\u0bb7" - "\u0bb9",
"\u0c05" - "\u0c0c",
"\u0c0e" - "\u0c10",
"\u0c12" - "\u0c28",
"\u0c2a" - "\u0c33",
"\u0c35" - "\u0c39",
"\u0c60" - "\u0c61",
"\u0c85" - "\u0c8c",
"\u0c8e" - "\u0c90",
"\u0c92" - "\u0ca8",
"\u0caa" - "\u0cb3",
"\u0cb5" - "\u0cb9",
"\u0cde",
"\u0ce0" - "\u0ce1",
"\u0d05" - "\u0d0c",
"\u0d0e" - "\u0d10",
"\u0d12" - "\u0d28",
"\u0d2a" - "\u0d39",
"\u0d60" - "\u0d61",
"\u0e01" - "\u0e2e",
"\u0e30",
"\u0e32" - "\u0e33",
"\u0e40" - "\u0e45",
"\u0e81" - "\u0e82",
"\u0e84",
"\u0e87" - "\u0e88",
"\u0e8a",
"\u0e8d",
"\u0e94" - "\u0e97",
"\u0e99" - "\u0e9f",
"\u0ea1" - "\u0ea3",
"\u0ea5",
"\u0ea7",
"\u0eaa" - "\u0eab",
"\u0ead" - "\u0eae",
"\u0eb0",
"\u0eb2" - "\u0eb3",
"\u0ebd",
"\u0ec0" - "\u0ec4",
"\u0f40" - "\u0f47",
"\u0f49" - "\u0f69",
"\u10a0" - "\u10c5",
"\u10d0" - "\u10f6",
"\u1100",
"\u1102" - "\u1103",
"\u1105" - "\u1107",
"\u1109",
"\u110b" - "\u110c",
"\u110e" - "\u1112",
"\u113c",
"\u113e",
"\u1140",
"\u114c",
"\u114e",
"\u1150",
"\u1154" - "\u1155",
"\u1159",
"\u115f" - "\u1161",
"\u1163",
"\u1165",
"\u1167",
"\u1169",
"\u116d" - "\u116e",
"\u1172" - "\u1173",
"\u1175",
"\u119e",
"\u11a8",
"\u11ab",
"\u11ae" - "\u11af",
"\u11b7" - "\u11b8",
"\u11ba",
"\u11bc" - "\u11c2",
"\u11eb",
"\u11f0",
"\u11f9",
"\u1e00" - "\u1e9b",
"\u1ea0" - "\u1ef9",
"\u1f00" - "\u1f15",
"\u1f18" - "\u1f1d",
"\u1f20" - "\u1f45",
"\u1f48" - "\u1f4d",
"\u1f50" - "\u1f57",
"\u1f59",
"\u1f5b",
"\u1f5d",
"\u1f5f" - "\u1f7d",
"\u1f80" - "\u1fb4",
"\u1fb6" - "\u1fbc",
"\u1fbe",
"\u1fc2" - "\u1fc4",
"\u1fc6" - "\u1fcc",
"\u1fd0" - "\u1fd3",
"\u1fd6" - "\u1fdb",
"\u1fe0" - "\u1fec",
"\u1ff2" - "\u1ff4",
"\u1ff6" - "\u1ffc",
"\u2126",
"\u212a" - "\u212b",
"\u212e",
"\u2180" - "\u2182",
"\u3041" - "\u3094",
"\u30a1" - "\u30fa",
"\u3105" - "\u312c",
"\uac00" - "\ud7a3"
] >
| < #IDEOGRAPHIC : [
"\u4e00" - "\u9fa5",
"\u3007",
"\u3021" - "\u3029"
] >
| < #LETTER : () >
| < #COMBINING_CHAR : [
"\u0300" - "\u0345",
"\u0360" - "\u0361",
"\u0483" - "\u0486",
"\u0591" - "\u05a1",
"\u05a3" - "\u05b9",
"\u05bb" - "\u05bd",
"\u05bf",
"\u05c1" - "\u05c2",
"\u05c4",
"\u064b" - "\u0652",
"\u0670",
"\u06d6" - "\u06dc",
"\u06dd" - "\u06df",
"\u06e0" - "\u06e4",
"\u06e7" - "\u06e8",
"\u06ea" - "\u06ed",
"\u0901" - "\u0903",
"\u093c",
"\u093e" - "\u094c",
"\u094d",
"\u0951" - "\u0954",
"\u0962" - "\u0963",
"\u0981" - "\u0983",
"\u09bc",
"\u09be",
"\u09bf",
"\u09c0" - "\u09c4",
"\u09c7" - "\u09c8",
"\u09cb" - "\u09cd",
"\u09d7",
"\u09e2" - "\u09e3",
"\u0a02",
"\u0a3c",
"\u0a3e",
"\u0a3f",
"\u0a40" - "\u0a42",
"\u0a47" - "\u0a48",
"\u0a4b" - "\u0a4d",
"\u0a70" - "\u0a71",
"\u0a81" - "\u0a83",
"\u0abc",
"\u0abe" - "\u0ac5",
"\u0ac7" - "\u0ac9",
"\u0acb" - "\u0acd",
"\u0b01" - "\u0b03",
"\u0b3c",
"\u0b3e" - "\u0b43",
"\u0b47" - "\u0b48",
"\u0b4b" - "\u0b4d",
"\u0b56" - "\u0b57",
"\u0b82" - "\u0b83",
"\u0bbe" - "\u0bc2",
"\u0bc6" - "\u0bc8",
"\u0bca" - "\u0bcd",
"\u0bd7",
"\u0c01" - "\u0c03",
"\u0c3e" - "\u0c44",
"\u0c46" - "\u0c48",
"\u0c4a" - "\u0c4d",
"\u0c55" - "\u0c56",
"\u0c82" - "\u0c83",
"\u0cbe" - "\u0cc4",
"\u0cc6" - "\u0cc8",
"\u0cca" - "\u0ccd",
"\u0cd5" - "\u0cd6",
"\u0d02" - "\u0d03",
"\u0d3e" - "\u0d43",
"\u0d46" - "\u0d48",
"\u0d4a" - "\u0d4d",
"\u0d57",
"\u0e31",
"\u0e34" - "\u0e3a",
"\u0e47" - "\u0e4e",
"\u0eb1",
"\u0eb4" - "\u0eb9",
"\u0ebb" - "\u0ebc",
"\u0ec8" - "\u0ecd",
"\u0f18" - "\u0f19",
"\u0f35",
"\u0f37",
"\u0f39",
"\u0f3e",
"\u0f3f",
"\u0f71" - "\u0f84",
"\u0f86" - "\u0f8b",
"\u0f90" - "\u0f95",
"\u0f97",
"\u0f99" - "\u0fad",
"\u0fb1" - "\u0fb7",
"\u0fb9",
"\u20d0" - "\u20dc",
"\u20e1",
"\u302a" - "\u302f",
"\u3099",
"\u309a"
] >
| < #DIGIT : [
"\u0030" - "\u0039",
"\u0660" - "\u0669",
"\u06f0" - "\u06f9",
"\u0966" - "\u096f",
"\u09e6" - "\u09ef",
"\u0a66" - "\u0a6f",
"\u0ae6" - "\u0aef",
"\u0b66" - "\u0b6f",
"\u0be7" - "\u0bef",
"\u0c66" - "\u0c6f",
"\u0ce6" - "\u0cef",
"\u0d66" - "\u0d6f",
"\u0e50" - "\u0e59",
"\u0ed0" - "\u0ed9",
"\u0f20" - "\u0f29"
] >
| < #EXTENDER : [
"\u00b7",
"\u02d0",
"\u02d1",
"\u0387",
"\u0640",
"\u0e46",
"\u0ec6",
"\u3005",
"\u3031" - "\u3035",
"\u309d" - "\u309e",
"\u30fc" - "\u30fe"
] >
| < #NMSTART : (
| < #NMCHAR : ( | | | "." | "-" | "_") >
| < #NCNAME: )* >
}
TOKEN :
{
< IDENTIFIER:
| < ESCAPED_IDENTIFIER: "\\"
| < PREFIX_STAR:
| < PREFIXED_NAME: >
| < LITERAL : ("\"" (~["\u0000", "\""])* "\"")
| ("'" (~["\u0000", "'"])* "'")
| ("\"\"\"" (~["\""]
| ("\"" ~["\""])
| ("\"\"" ~["\""]))* "\"\"\"")
| ("'''" (~["'"]
| ("'" ~["'"])
| ("''" ~["'"]))* "'''") >
| < FANNOTATE : ">>" >
}
/* This avoids lexical errors from JavaCC. */
<*>
TOKEN :
{
< ILLEGAL_CHAR : [ "\u0000" - "\u0008", "\u000b" - "\uffff" ] >
}
Other Java examples (source code examples)
Here is a short list of links related to this Java CompactSyntax.jj source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project
