Author: shane.bryzak(a)jboss.com Date: 2009-11-29 22:55:25 -0500 (Sun, 29 Nov 2009) New Revision: 11703 Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParser.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserConstants.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserTokenManager.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/JavaCharStream.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/ParseException.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/Token.java modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/TokenMgrError.java modules/trunk/remoting/src/main/javacc/ modules/trunk/remoting/src/main/javacc/AnnotationParser.jj modules/trunk/remoting/src/main/javacc/readme.txt Modified: modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloAction.java modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloQualifier.java modules/trunk/remoting/examples/helloworld/src/main/webapp/helloworld.xhtml modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/Call.java Log: added annotation parsing stuff Modified: modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloAction.java =================================================================== --- modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloAction.java 2009-11-30 03:09:30 UTC (rev 11702) +++ modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloAction.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -2,7 +2,7 @@ import org.jboss.seam.remoting.annotations.WebRemote; -@HelloQualifier +@HelloQualifier(foo = "abc") public class HelloAction { @WebRemote public String sayHello(String name) { Modified: modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloQualifier.java =================================================================== --- modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloQualifier.java 2009-11-30 03:09:30 UTC (rev 11702) +++ modules/trunk/remoting/examples/helloworld/src/main/java/org/jboss/seam/remoting/examples/helloworld/HelloQualifier.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -12,5 +12,5 @@ @Target(TYPE) @Qualifier public @interface HelloQualifier { - + String foo() default "bar"; } Modified: modules/trunk/remoting/examples/helloworld/src/main/webapp/helloworld.xhtml =================================================================== --- modules/trunk/remoting/examples/helloworld/src/main/webapp/helloworld.xhtml 2009-11-30 03:09:30 UTC (rev 11702) +++ modules/trunk/remoting/examples/helloworld/src/main/webapp/helloworld.xhtml 2009-11-30 03:55:25 UTC (rev 11703) @@ -25,7 +25,7 @@ var name = prompt("What is your name?"); if (name == null) return; var callback = function(result) { alert(result); }; - Seam.Component.create("org.jboss.seam.remoting.examples.helloworld.HelloAction", "org.jboss.seam.remoting.examples.helloworld.HelloQualifier").sayHello(name, callback); + Seam.Component.create("org.jboss.seam.remoting.examples.helloworld.HelloAction", &quot;(a)org.jboss.seam.remoting.examples.helloworld.HelloQualifier(foo = \"abc\")").sayHello(name, callback); } </script> Modified: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/Call.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/Call.java 2009-11-30 03:09:30 UTC (rev 11702) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/Call.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -62,6 +62,7 @@ /** * Constructor. */ + @SuppressWarnings("unchecked") public Call(BeanManager beanManager, String id, String beanName, String qualifiers, String methodName) { @@ -85,6 +86,7 @@ } catch (ClassNotFoundException e) { + // TODO improve this e.printStackTrace(); } } Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParser.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParser.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParser.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,600 @@ +/* Generated By:JavaCC: Do not edit this line. AnnotationParser.java */ +package org.jboss.seam.remoting.annotationparser; + +import java.io.*; + +/** + * Grammar to parse Java 1.5 Annotations + * @author Shane Bryzak + */ +public class AnnotationParser implements AnnotationParserConstants { + public AnnotationParser(String fileName) + { + this(System.in); + try { ReInit(new FileInputStream(new File(fileName))); } + catch(Exception e) { e.printStackTrace(); } + } + + public static void main(String args[]) { + AnnotationParser parser; + if (args.length == 0) { + System.out.println("AnnotationParser: Reading from standard input . . ."); + parser = new AnnotationParser(System.in); + } else if (args.length == 1) { + System.out.println("AnnotationParser: Reading from file " + args[0] + " . . ."); + try { + parser = new AnnotationParser(new java.io.FileInputStream(args[0])); + } catch (java.io.FileNotFoundException e) { + System.out.println("AnnotationParser: File " + args[0] + " not found."); + return; + } + } else { + System.out.println("AnnotationParser: Usage is one of:"); + System.out.println(" java AnnotationParser < inputfile"); + System.out.println("OR"); + System.out.println(" java AnnotationParser inputfile"); + return; + } + try { + parser.AnnotationsUnit(); + System.out.println("AnnotationParser: Annotations parsed successfully."); + } catch (ParseException e) { + System.out.println(e.getMessage()); + System.out.println("AnnotationParser: Encountered errors during parse."); + } + } + +/*********************************** + * ANNOTATIONS GRAMMAR STARTS HERE * + ***********************************/ + +/* + * Program structuring syntax follows. + */ + final public void AnnotationsUnit() throws ParseException { + jj_consume_token(LPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AT: + Annotation(); + label_1: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + break label_1; + } + jj_consume_token(COMMA); + Annotation(); + } + break; + default: + ; + } + jj_consume_token(RPAREN); + } + + final public void PrimitiveType() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + jj_consume_token(BOOLEAN); + break; + case CHAR: + jj_consume_token(CHAR); + break; + case BYTE: + jj_consume_token(BYTE); + break; + case SHORT: + jj_consume_token(SHORT); + break; + case INT: + jj_consume_token(INT); + break; + case LONG: + jj_consume_token(LONG); + break; + case FLOAT: + jj_consume_token(FLOAT); + break; + case DOUBLE: + jj_consume_token(DOUBLE); + break; + default: + jj_consume_token(-1); + throw new ParseException(); + } + } + + final public void Name() throws ParseException { + jj_consume_token(IDENTIFIER); + label_2: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case DOT: + ; + break; + default: + break label_2; + } + jj_consume_token(DOT); + jj_consume_token(IDENTIFIER); + } + } + + final public void Literal() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + jj_consume_token(INTEGER_LITERAL); + break; + case FLOATING_POINT_LITERAL: + jj_consume_token(FLOATING_POINT_LITERAL); + break; + case CHARACTER_LITERAL: + jj_consume_token(CHARACTER_LITERAL); + break; + case STRING_LITERAL: + jj_consume_token(STRING_LITERAL); + break; + case FALSE: + case TRUE: + BooleanLiteral(); + break; + case NULL: + NullLiteral(); + break; + default: + jj_consume_token(-1); + throw new ParseException(); + } + } + + final public void BooleanLiteral() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TRUE: + jj_consume_token(TRUE); + break; + case FALSE: + jj_consume_token(FALSE); + break; + default: + jj_consume_token(-1); + throw new ParseException(); + } + } + + final public void NullLiteral() throws ParseException { + jj_consume_token(NULL); + } + +/* Annotation syntax follows. */ + final public void Annotation() throws ParseException { + if (jj_2_1(2147483647)) { + NormalAnnotation(); + } else if (jj_2_2(2147483647)) { + SingleMemberAnnotation(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AT: + MarkerAnnotation(); + break; + default: + jj_consume_token(-1); + throw new ParseException(); + } + } + } + + final public void NormalAnnotation() throws ParseException { + jj_consume_token(AT); + Name(); + jj_consume_token(LPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + MemberValuePairs(); + break; + default: + ; + } + jj_consume_token(RPAREN); + } + + final public void MarkerAnnotation() throws ParseException { + jj_consume_token(AT); + Name(); + } + + final public void SingleMemberAnnotation() throws ParseException { + jj_consume_token(AT); + Name(); + jj_consume_token(LPAREN); + MemberValue(); + jj_consume_token(RPAREN); + } + + final public void MemberValuePairs() throws ParseException { + MemberValuePair(); + label_3: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + break label_3; + } + jj_consume_token(COMMA); + MemberValuePair(); + } + } + + final public void MemberValuePair() throws ParseException { + jj_consume_token(IDENTIFIER); + jj_consume_token(ASSIGN); + MemberValue(); + } + + final public void MemberValue() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AT: + Annotation(); + break; + case LBRACE: + MemberValueArrayInitializer(); + break; + case FALSE: + case NULL: + case TRUE: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + Literal(); + break; + default: + jj_consume_token(-1); + throw new ParseException(); + } + } + + final public void MemberValueArrayInitializer() throws ParseException { + jj_consume_token(LBRACE); + MemberValue(); + label_4: + while (true) { + if (jj_2_3(2)) { + ; + } else { + break label_4; + } + jj_consume_token(COMMA); + MemberValue(); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + jj_consume_token(COMMA); + break; + default: + ; + } + jj_consume_token(RBRACE); + } + + private boolean jj_2_1(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1(); } + catch(LookaheadSuccess ls) { return true; } + } + + private boolean jj_2_2(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_2(); } + catch(LookaheadSuccess ls) { return true; } + } + + private boolean jj_2_3(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_3(); } + catch(LookaheadSuccess ls) { return true; } + } + + private boolean jj_3R_20() { + if (jj_scan_token(AT)) return true; + return false; + } + + private boolean jj_3R_18() { + if (jj_3R_22()) return true; + return false; + } + + private boolean jj_3R_21() { + if (jj_scan_token(AT)) return true; + return false; + } + + private boolean jj_3R_14() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(66)) { + jj_scanpos = xsp; + if (jj_scan_token(70)) { + jj_scanpos = xsp; + if (jj_scan_token(72)) { + jj_scanpos = xsp; + if (jj_scan_token(73)) { + jj_scanpos = xsp; + if (jj_3R_18()) { + jj_scanpos = xsp; + if (jj_scan_token(45)) return true; + } + } + } + } + } + return false; + } + + private boolean jj_3_2() { + if (jj_scan_token(AT)) return true; + if (jj_3R_5()) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + private boolean jj_3R_19() { + if (jj_scan_token(AT)) return true; + return false; + } + + private boolean jj_3_1() { + if (jj_scan_token(AT)) return true; + if (jj_3R_5()) return true; + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_6()) { + jj_scanpos = xsp; + if (jj_scan_token(78)) return true; + } + return false; + } + + private boolean jj_3R_8() { + if (jj_scan_token(DOT)) return true; + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_5() { + if (jj_scan_token(IDENTIFIER)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_8()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_17() { + if (jj_3R_21()) return true; + return false; + } + + private boolean jj_3R_13() { + if (jj_scan_token(LBRACE)) return true; + return false; + } + + private boolean jj_3R_16() { + if (jj_3R_20()) return true; + return false; + } + + private boolean jj_3R_12() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_15()) { + jj_scanpos = xsp; + if (jj_3R_16()) { + jj_scanpos = xsp; + if (jj_3R_17()) return true; + } + } + return false; + } + + private boolean jj_3R_15() { + if (jj_3R_19()) return true; + return false; + } + + private boolean jj_3R_11() { + if (jj_3R_14()) return true; + return false; + } + + private boolean jj_3R_10() { + if (jj_3R_13()) return true; + return false; + } + + private boolean jj_3R_9() { + if (jj_3R_12()) return true; + return false; + } + + private boolean jj_3R_7() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_9()) { + jj_scanpos = xsp; + if (jj_3R_10()) { + jj_scanpos = xsp; + if (jj_3R_11()) return true; + } + } + return false; + } + + private boolean jj_3R_22() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(61)) { + jj_scanpos = xsp; + if (jj_scan_token(30)) return true; + } + return false; + } + + private boolean jj_3R_6() { + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_scan_token(ASSIGN)) return true; + return false; + } + + private boolean jj_3_3() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_7()) return true; + return false; + } + + /** Generated Token Manager. */ + public AnnotationParserTokenManager token_source; + JavaCharStream jj_input_stream; + /** Current token. */ + public Token token; + /** Next token. */ + public Token jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + + /** Constructor with InputStream. */ + public AnnotationParser(java.io.InputStream stream) { + this(stream, null); + } + /** Constructor with InputStream and supplied encoding */ + public AnnotationParser(java.io.InputStream stream, String encoding) { + try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source = new AnnotationParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream) { + ReInit(stream, null); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream, String encoding) { + try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + } + + /** Constructor. */ + public AnnotationParser(java.io.Reader stream) { + jj_input_stream = new JavaCharStream(stream, 1, 1); + token_source = new AnnotationParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + } + + /** Constructor with generated Token Manager. */ + public AnnotationParser(AnnotationParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + } + + /** Reinitialise. */ + public void ReInit(AnnotationParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + } + + private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + return token; + } + token = oldToken; + throw generateParseException(); + } + + static private final class LookaheadSuccess extends java.lang.Error { } + final private LookaheadSuccess jj_ls = new LookaheadSuccess(); + private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_scanpos.kind != kind) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; + return false; + } + + +/** Get the next Token. */ + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + return token; + } + +/** Get the specific Token. */ + final public Token getToken(int index) { + Token t = token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + /** Generate ParseException. */ + public ParseException generateParseException() { + Token errortok = token.next; + int line = errortok.beginLine, column = errortok.beginColumn; + String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image; + return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess); + } + + /** Enable tracing. */ + final public void enable_tracing() { + } + + /** Disable tracing. */ + final public void disable_tracing() { + } + +} Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserConstants.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserConstants.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserConstants.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,373 @@ +/* Generated By:JavaCC: Do not edit this line. AnnotationParserConstants.java */ +package org.jboss.seam.remoting.annotationparser; + + +/** + * Token literal values and constants. + * Generated by org.javacc.parser.OtherFilesGen#start() + */ +public interface AnnotationParserConstants { + + /** End of File. */ + int EOF = 0; + /** RegularExpression Id. */ + int SINGLE_LINE_COMMENT = 9; + /** RegularExpression Id. */ + int FORMAL_COMMENT = 10; + /** RegularExpression Id. */ + int MULTI_LINE_COMMENT = 11; + /** RegularExpression Id. */ + int ABSTRACT = 13; + /** RegularExpression Id. */ + int ASSERT = 14; + /** RegularExpression Id. */ + int BOOLEAN = 15; + /** RegularExpression Id. */ + int BREAK = 16; + /** RegularExpression Id. */ + int BYTE = 17; + /** RegularExpression Id. */ + int CASE = 18; + /** RegularExpression Id. */ + int CATCH = 19; + /** RegularExpression Id. */ + int CHAR = 20; + /** RegularExpression Id. */ + int CLASS = 21; + /** RegularExpression Id. */ + int CONST = 22; + /** RegularExpression Id. */ + int CONTINUE = 23; + /** RegularExpression Id. */ + int _DEFAULT = 24; + /** RegularExpression Id. */ + int DO = 25; + /** RegularExpression Id. */ + int DOUBLE = 26; + /** RegularExpression Id. */ + int ELSE = 27; + /** RegularExpression Id. */ + int ENUM = 28; + /** RegularExpression Id. */ + int EXTENDS = 29; + /** RegularExpression Id. */ + int FALSE = 30; + /** RegularExpression Id. */ + int FINAL = 31; + /** RegularExpression Id. */ + int FINALLY = 32; + /** RegularExpression Id. */ + int FLOAT = 33; + /** RegularExpression Id. */ + int FOR = 34; + /** RegularExpression Id. */ + int GOTO = 35; + /** RegularExpression Id. */ + int IF = 36; + /** RegularExpression Id. */ + int IMPLEMENTS = 37; + /** RegularExpression Id. */ + int IMPORT = 38; + /** RegularExpression Id. */ + int INSTANCEOF = 39; + /** RegularExpression Id. */ + int INT = 40; + /** RegularExpression Id. */ + int INTERFACE = 41; + /** RegularExpression Id. */ + int LONG = 42; + /** RegularExpression Id. */ + int NATIVE = 43; + /** RegularExpression Id. */ + int NEW = 44; + /** RegularExpression Id. */ + int NULL = 45; + /** RegularExpression Id. */ + int PACKAGE = 46; + /** RegularExpression Id. */ + int PRIVATE = 47; + /** RegularExpression Id. */ + int PROTECTED = 48; + /** RegularExpression Id. */ + int PUBLIC = 49; + /** RegularExpression Id. */ + int RETURN = 50; + /** RegularExpression Id. */ + int SHORT = 51; + /** RegularExpression Id. */ + int STATIC = 52; + /** RegularExpression Id. */ + int STRICTFP = 53; + /** RegularExpression Id. */ + int SUPER = 54; + /** RegularExpression Id. */ + int SWITCH = 55; + /** RegularExpression Id. */ + int SYNCHRONIZED = 56; + /** RegularExpression Id. */ + int THIS = 57; + /** RegularExpression Id. */ + int THROW = 58; + /** RegularExpression Id. */ + int THROWS = 59; + /** RegularExpression Id. */ + int TRANSIENT = 60; + /** RegularExpression Id. */ + int TRUE = 61; + /** RegularExpression Id. */ + int TRY = 62; + /** RegularExpression Id. */ + int VOID = 63; + /** RegularExpression Id. */ + int VOLATILE = 64; + /** RegularExpression Id. */ + int WHILE = 65; + /** RegularExpression Id. */ + int INTEGER_LITERAL = 66; + /** RegularExpression Id. */ + int DECIMAL_LITERAL = 67; + /** RegularExpression Id. */ + int HEX_LITERAL = 68; + /** RegularExpression Id. */ + int OCTAL_LITERAL = 69; + /** RegularExpression Id. */ + int FLOATING_POINT_LITERAL = 70; + /** RegularExpression Id. */ + int EXPONENT = 71; + /** RegularExpression Id. */ + int CHARACTER_LITERAL = 72; + /** RegularExpression Id. */ + int STRING_LITERAL = 73; + /** RegularExpression Id. */ + int IDENTIFIER = 74; + /** RegularExpression Id. */ + int LETTER = 75; + /** RegularExpression Id. */ + int DIGIT = 76; + /** RegularExpression Id. */ + int LPAREN = 77; + /** RegularExpression Id. */ + int RPAREN = 78; + /** RegularExpression Id. */ + int LBRACE = 79; + /** RegularExpression Id. */ + int RBRACE = 80; + /** RegularExpression Id. */ + int LBRACKET = 81; + /** RegularExpression Id. */ + int RBRACKET = 82; + /** RegularExpression Id. */ + int SEMICOLON = 83; + /** RegularExpression Id. */ + int COMMA = 84; + /** RegularExpression Id. */ + int DOT = 85; + /** RegularExpression Id. */ + int AT = 86; + /** RegularExpression Id. */ + int ASSIGN = 87; + /** RegularExpression Id. */ + int LT = 88; + /** RegularExpression Id. */ + int BANG = 89; + /** RegularExpression Id. */ + int TILDE = 90; + /** RegularExpression Id. */ + int HOOK = 91; + /** RegularExpression Id. */ + int COLON = 92; + /** RegularExpression Id. */ + int EQ = 93; + /** RegularExpression Id. */ + int LE = 94; + /** RegularExpression Id. */ + int GE = 95; + /** RegularExpression Id. */ + int NE = 96; + /** RegularExpression Id. */ + int SC_OR = 97; + /** RegularExpression Id. */ + int SC_AND = 98; + /** RegularExpression Id. */ + int INCR = 99; + /** RegularExpression Id. */ + int DECR = 100; + /** RegularExpression Id. */ + int PLUS = 101; + /** RegularExpression Id. */ + int MINUS = 102; + /** RegularExpression Id. */ + int STAR = 103; + /** RegularExpression Id. */ + int SLASH = 104; + /** RegularExpression Id. */ + int BIT_AND = 105; + /** RegularExpression Id. */ + int BIT_OR = 106; + /** RegularExpression Id. */ + int XOR = 107; + /** RegularExpression Id. */ + int REM = 108; + /** RegularExpression Id. */ + int LSHIFT = 109; + /** RegularExpression Id. */ + int PLUSASSIGN = 110; + /** RegularExpression Id. */ + int MINUSASSIGN = 111; + /** RegularExpression Id. */ + int STARASSIGN = 112; + /** RegularExpression Id. */ + int SLASHASSIGN = 113; + /** RegularExpression Id. */ + int ANDASSIGN = 114; + /** RegularExpression Id. */ + int ORASSIGN = 115; + /** RegularExpression Id. */ + int XORASSIGN = 116; + /** RegularExpression Id. */ + int REMASSIGN = 117; + /** RegularExpression Id. */ + int LSHIFTASSIGN = 118; + /** RegularExpression Id. */ + int RSIGNEDSHIFTASSIGN = 119; + /** RegularExpression Id. */ + int RUNSIGNEDSHIFTASSIGN = 120; + /** RegularExpression Id. */ + int ELLIPSIS = 121; + + /** Lexical state. */ + int DEFAULT = 0; + /** Lexical state. */ + int IN_SINGLE_LINE_COMMENT = 1; + /** Lexical state. */ + int IN_FORMAL_COMMENT = 2; + /** Lexical state. */ + int IN_MULTI_LINE_COMMENT = 3; + + /** Literal token values. */ + String[] tokenImage = { + "<EOF>", + "\" \"", + "\"\\t\"", + "\"\\n\"", + "\"\\r\"", + "\"\\f\"", + "\"//\"", + "<token of kind 7>", + "\"/*\"", + "<SINGLE_LINE_COMMENT>", + "\"*/\"", + "\"*/\"", + "<token of kind 12>", + "\"abstract\"", + "\"assert\"", + "\"boolean\"", + "\"break\"", + "\"byte\"", + "\"case\"", + "\"catch\"", + "\"char\"", + "\"class\"", + "\"const\"", + "\"continue\"", + "\"default\"", + "\"do\"", + "\"double\"", + "\"else\"", + "\"enum\"", + "\"extends\"", + "\"false\"", + "\"final\"", + "\"finally\"", + "\"float\"", + "\"for\"", + "\"goto\"", + "\"if\"", + "\"implements\"", + "\"import\"", + "\"instanceof\"", + "\"int\"", + "\"interface\"", + "\"long\"", + "\"native\"", + "\"new\"", + "\"null\"", + "\"package\"", + "\"private\"", + "\"protected\"", + "\"public\"", + "\"return\"", + "\"short\"", + "\"static\"", + "\"strictfp\"", + "\"super\"", + "\"switch\"", + "\"synchronized\"", + "\"this\"", + "\"throw\"", + "\"throws\"", + "\"transient\"", + "\"true\"", + "\"try\"", + "\"void\"", + "\"volatile\"", + "\"while\"", + "<INTEGER_LITERAL>", + "<DECIMAL_LITERAL>", + "<HEX_LITERAL>", + "<OCTAL_LITERAL>", + "<FLOATING_POINT_LITERAL>", + "<EXPONENT>", + "<CHARACTER_LITERAL>", + "<STRING_LITERAL>", + "<IDENTIFIER>", + "<LETTER>", + "<DIGIT>", + "\"(\"", + "\")\"", + "\"{\"", + "\"}\"", + "\"[\"", + "\"]\"", + "\";\"", + "\",\"", + "\".\"", + "\"@\"", + "\"=\"", + "\"<\"", + "\"!\"", + "\"~\"", + "\"?\"", + "\":\"", + "\"==\"", + "\"<=\"", + "\">=\"", + "\"!=\"", + "\"||\"", + "\"&&\"", + "\"++\"", + "\"--\"", + "\"+\"", + "\"-\"", + "\"*\"", + "\"/\"", + "\"&\"", + "\"|\"", + "\"^\"", + "\"%\"", + "\"<<\"", + "\"+=\"", + "\"-=\"", + "\"*=\"", + "\"/=\"", + "\"&=\"", + "\"|=\"", + "\"^=\"", + "\"%=\"", + "\"<<=\"", + "\">>=\"", + "\">>>=\"", + "\"...\"", + }; + +} Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserTokenManager.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserTokenManager.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/AnnotationParserTokenManager.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,1745 @@ +/* Generated By:JavaCC: Do not edit this line. AnnotationParserTokenManager.java */ +package org.jboss.seam.remoting.annotationparser; +import java.io.*; + +/** Token Manager. */ +public class AnnotationParserTokenManager implements AnnotationParserConstants +{ + + /** Debug output. */ + public java.io.PrintStream debugStream = System.out; + /** Set debug output. */ + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) +{ + switch (pos) + { + case 0: + if ((active0 & 0x140L) != 0L || (active1 & 0x2010000000000L) != 0L) + return 2; + if ((active1 & 0x200000000200000L) != 0L) + return 8; + if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x3L) != 0L) + { + jjmatchedKind = 74; + return 32; + } + return -1; + case 1: + if ((active0 & 0x100L) != 0L) + return 0; + if ((active0 & 0xffffffeff9ffe000L) != 0L || (active1 & 0x3L) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 74; + jjmatchedPos = 1; + } + return 32; + } + if ((active0 & 0x1006000000L) != 0L) + return 32; + return -1; + case 2: + if ((active0 & 0xbfffecebfdffe000L) != 0L || (active1 & 0x3L) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 74; + jjmatchedPos = 2; + } + return 32; + } + if ((active0 & 0x4000130400000000L) != 0L) + return 32; + return -1; + case 3: + if ((active0 & 0x1dffcae3e5e9e000L) != 0L || (active1 & 0x3L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 3; + return 32; + } + if ((active0 & 0xa200240818160000L) != 0L) + return 32; + return -1; + case 4: + if ((active0 & 0x11b7cae02580e000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 74; + jjmatchedPos = 4; + } + return 32; + } + if ((active0 & 0xc480003c0690000L) != 0L || (active1 & 0x2L) != 0L) + return 32; + return -1; + case 5: + if ((active0 & 0x1121c2a12180a000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 5; + return 32; + } + if ((active0 & 0x896084004004000L) != 0L) + return 32; + return -1; + case 6: + if ((active0 & 0x112102a000802000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 6; + return 32; + } + if ((active0 & 0xc00121008000L) != 0L) + return 32; + return -1; + case 7: + if ((active0 & 0x110102a000000000L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 7; + return 32; + } + if ((active0 & 0x20000000802000L) != 0L || (active1 & 0x1L) != 0L) + return 32; + return -1; + case 8: + if ((active0 & 0x10000a000000000L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 8; + return 32; + } + if ((active0 & 0x1001020000000000L) != 0L) + return 32; + return -1; + case 9: + if ((active0 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 9; + return 32; + } + if ((active0 & 0xa000000000L) != 0L) + return 32; + return -1; + case 10: + if ((active0 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 74; + jjmatchedPos = 10; + return 32; + } + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); +} +private int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 89; + return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000L); + case 37: + jjmatchedKind = 108; + return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L); + case 38: + jjmatchedKind = 105; + return jjMoveStringLiteralDfa1_0(0x0L, 0x4000400000000L); + case 40: + return jjStopAtPos(0, 77); + case 41: + return jjStopAtPos(0, 78); + case 42: + jjmatchedKind = 103; + return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L); + case 43: + jjmatchedKind = 101; + return jjMoveStringLiteralDfa1_0(0x0L, 0x400800000000L); + case 44: + return jjStopAtPos(0, 84); + case 45: + jjmatchedKind = 102; + return jjMoveStringLiteralDfa1_0(0x0L, 0x801000000000L); + case 46: + jjmatchedKind = 85; + return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000000L); + case 47: + jjmatchedKind = 104; + return jjMoveStringLiteralDfa1_0(0x140L, 0x2000000000000L); + case 58: + return jjStopAtPos(0, 92); + case 59: + return jjStopAtPos(0, 83); + case 60: + jjmatchedKind = 88; + return jjMoveStringLiteralDfa1_0(0x0L, 0x40200040000000L); + case 61: + jjmatchedKind = 87; + return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L); + case 62: + return jjMoveStringLiteralDfa1_0(0x0L, 0x180000080000000L); + case 63: + return jjStopAtPos(0, 91); + case 64: + return jjStopAtPos(0, 86); + case 91: + return jjStopAtPos(0, 81); + case 93: + return jjStopAtPos(0, 82); + case 94: + jjmatchedKind = 107; + return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L); + case 97: + return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L); + case 98: + return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L); + case 99: + return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L); + case 100: + return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L); + case 101: + return jjMoveStringLiteralDfa1_0(0x38000000L, 0x0L); + case 102: + return jjMoveStringLiteralDfa1_0(0x7c0000000L, 0x0L); + case 103: + return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L); + case 105: + return jjMoveStringLiteralDfa1_0(0x3f000000000L, 0x0L); + case 108: + return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L); + case 110: + return jjMoveStringLiteralDfa1_0(0x380000000000L, 0x0L); + case 112: + return jjMoveStringLiteralDfa1_0(0x3c00000000000L, 0x0L); + case 114: + return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L); + case 115: + return jjMoveStringLiteralDfa1_0(0x1f8000000000000L, 0x0L); + case 116: + return jjMoveStringLiteralDfa1_0(0x7e00000000000000L, 0x0L); + case 118: + return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x1L); + case 119: + return jjMoveStringLiteralDfa1_0(0x0L, 0x2L); + case 123: + return jjStopAtPos(0, 79); + case 124: + jjmatchedKind = 106; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L); + case 125: + return jjStopAtPos(0, 80); + case 126: + return jjStopAtPos(0, 90); + default : + return jjMoveNfa_0(3, 0); + } +} +private int jjMoveStringLiteralDfa1_0(long active0, long active1) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1); + return 1; + } + switch(curChar) + { + case 38: + if ((active1 & 0x400000000L) != 0L) + return jjStopAtPos(1, 98); + break; + case 42: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_0(1, 8, 0); + break; + case 43: + if ((active1 & 0x800000000L) != 0L) + return jjStopAtPos(1, 99); + break; + case 45: + if ((active1 & 0x1000000000L) != 0L) + return jjStopAtPos(1, 100); + break; + case 46: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L); + case 47: + if ((active0 & 0x40L) != 0L) + return jjStopAtPos(1, 6); + break; + case 60: + if ((active1 & 0x200000000000L) != 0L) + { + jjmatchedKind = 109; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000000L); + case 61: + if ((active1 & 0x20000000L) != 0L) + return jjStopAtPos(1, 93); + else if ((active1 & 0x40000000L) != 0L) + return jjStopAtPos(1, 94); + else if ((active1 & 0x80000000L) != 0L) + return jjStopAtPos(1, 95); + else if ((active1 & 0x100000000L) != 0L) + return jjStopAtPos(1, 96); + else if ((active1 & 0x400000000000L) != 0L) + return jjStopAtPos(1, 110); + else if ((active1 & 0x800000000000L) != 0L) + return jjStopAtPos(1, 111); + else if ((active1 & 0x1000000000000L) != 0L) + return jjStopAtPos(1, 112); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStopAtPos(1, 113); + else if ((active1 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 114); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 115); + else if ((active1 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 116); + else if ((active1 & 0x20000000000000L) != 0L) + return jjStopAtPos(1, 117); + break; + case 62: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x180000000000000L); + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x4800400c0000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0x4100001000000L, active1, 0L); + case 102: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(1, 36, 32); + break; + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0xe08000000100000L, active1, 0x2L); + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x208200000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa2_0(active0, 0x6000000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa2_0(active0, 0x38010000000L, active1, 0L); + case 111: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x8000040c04c08000L, active1, 0x1L); + case 114: + return jjMoveStringLiteralDfa2_0(active0, 0x7001800000010000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa2_0(active0, 0x30000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x42200000000000L, active1, 0L); + case 119: + return jjMoveStringLiteralDfa2_0(active0, 0x80000000000000L, active1, 0L); + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L); + case 121: + return jjMoveStringLiteralDfa2_0(active0, 0x100000000020000L, active1, 0L); + case 124: + if ((active1 & 0x200000000L) != 0L) + return jjStopAtPos(1, 97); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1); +} +private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(0, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1); + return 2; + } + switch(curChar) + { + case 46: + if ((active1 & 0x200000000000000L) != 0L) + return jjStopAtPos(2, 121); + break; + case 61: + if ((active1 & 0x40000000000000L) != 0L) + return jjStopAtPos(2, 118); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStopAtPos(2, 119); + break; + case 62: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100000000000000L); + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x1010000000300000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L); + case 102: + return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa3_0(active0, 0x8280800000000000L, active1, 0x2L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x200040000000L, active1, 0x1L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x100040180c00000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0x9000200008000L, active1, 0L); + case 112: + return jjMoveStringLiteralDfa3_0(active0, 0x40006000000000L, active1, 0L); + case 114: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(2, 34, 32); + return jjMoveStringLiteralDfa3_0(active0, 0xc20000000000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa3_0(active0, 0x8008046000L, active1, 0L); + case 116: + if ((active0 & 0x10000000000L) != 0L) + { + jjmatchedKind = 40; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x40a08200a0000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0x2000000014000000L, active1, 0L); + case 119: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(2, 44, 32); + break; + case 121: + if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 62, 32); + break; + default : + break; + } + return jjStartNfa_0(1, active0, active1); +} +private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(1, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, active1); + return 3; + } + switch(curChar) + { + case 61: + if ((active1 & 0x100000000000000L) != 0L) + return jjStopAtPos(3, 120); + break; + case 97: + return jjMoveStringLiteralDfa4_0(active0, 0x381010000L, active1, 0x1L); + case 98: + return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa4_0(active0, 0x100000000080000L, active1, 0L); + case 100: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 63, 32); + break; + case 101: + if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(3, 17, 32); + else if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(3, 18, 32); + else if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(3, 27, 32); + else if ((active0 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 61, 32); + return jjMoveStringLiteralDfa4_0(active0, 0x40020020004000L, active1, 0L); + case 103: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(3, 42, 32); + break; + case 105: + return jjMoveStringLiteralDfa4_0(active0, 0x20080000000000L, active1, 0L); + case 107: + return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L); + case 108: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(3, 45, 32); + return jjMoveStringLiteralDfa4_0(active0, 0x2002000008000L, active1, 0x2L); + case 109: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(3, 28, 32); + break; + case 110: + return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L); + case 111: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(3, 35, 32); + return jjMoveStringLiteralDfa4_0(active0, 0xc00004000000000L, active1, 0L); + case 114: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(3, 20, 32); + return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L, active1, 0L); + case 115: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 57, 32); + return jjMoveStringLiteralDfa4_0(active0, 0x40600000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x91008000802000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(2, active0, active1); +} +private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(2, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, active1); + return 4; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa5_0(active0, 0xc08000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0xa0000000000000L, active1, 0L); + case 101: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(4, 30, 32); + else if ((active1 & 0x2L) != 0L) + return jjStartNfaWithStates_0(4, 65, 32); + return jjMoveStringLiteralDfa5_0(active0, 0x1002000008000L, active1, 0L); + case 104: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(4, 19, 32); + return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x12000000800000L, active1, 0L); + case 107: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(4, 16, 32); + break; + case 108: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x104000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa5_0(active0, 0x20000000L, active1, 0L); + case 114: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 54, 32); + return jjMoveStringLiteralDfa5_0(active0, 0x4024000006000L, active1, 0L); + case 115: + if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(4, 21, 32); + return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0L); + case 116: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(4, 22, 32); + else if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(4, 33, 32); + else if ((active0 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 51, 32); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L); + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa5_0(active0, 0x80000000000L, active1, 0L); + case 119: + if ((active0 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 58; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(3, active0, active1); +} +private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(3, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, active1); + return 5; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa6_0(active0, 0xa000L, active1, 0L); + case 99: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 49, 32); + else if ((active0 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 52, 32); + return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L, active1, 0L); + case 100: + return jjMoveStringLiteralDfa6_0(active0, 0x20000000L, active1, 0L); + case 101: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(5, 26, 32); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(5, 43, 32); + break; + case 102: + return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L, active1, 0L); + case 103: + return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L); + case 104: + if ((active0 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 55, 32); + break; + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000000L, active1, 0x1L); + case 108: + return jjMoveStringLiteralDfa6_0(active0, 0x101000000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L, active1, 0L); + case 110: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 50, 32); + return jjMoveStringLiteralDfa6_0(active0, 0x8000800000L, active1, 0L); + case 114: + return jjMoveStringLiteralDfa6_0(active0, 0x100000000000000L, active1, 0L); + case 115: + if ((active0 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 59, 32); + break; + case 116: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(5, 14, 32); + else if ((active0 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(5, 38, 32); + return jjMoveStringLiteralDfa6_0(active0, 0x20800000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(4, active0, active1); +} +private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(4, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, active1); + return 6; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa7_0(active0, 0x8000002000L, active1, 0L); + case 101: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(6, 46, 32); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(6, 47, 32); + return jjMoveStringLiteralDfa7_0(active0, 0x1000002000000000L, active1, 0L); + case 102: + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1L); + case 110: + if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(6, 15, 32); + break; + case 111: + return jjMoveStringLiteralDfa7_0(active0, 0x100000000000000L, active1, 0L); + case 115: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(6, 29, 32); + break; + case 116: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(6, 24, 32); + return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x800000L, active1, 0L); + case 121: + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(6, 32, 32); + break; + default : + break; + } + return jjStartNfa_0(5, active0, active1); +} +private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(5, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, active1); + return 7; + } + switch(curChar) + { + case 99: + return jjMoveStringLiteralDfa8_0(active0, 0x20000000000L, active1, 0L); + case 101: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(7, 23, 32); + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_0(7, 64, 32); + return jjMoveStringLiteralDfa8_0(active0, 0x1008000000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa8_0(active0, 0x1100002000000000L, active1, 0L); + case 112: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 53, 32); + break; + case 116: + if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(7, 13, 32); + break; + default : + break; + } + return jjStartNfa_0(6, active0, active1); +} +private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(6, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0, 0L); + return 8; + } + switch(curChar) + { + case 100: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 48, 32); + break; + case 101: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(8, 41, 32); + break; + case 105: + return jjMoveStringLiteralDfa9_0(active0, 0x100000000000000L); + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0x8000000000L); + case 116: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 60, 32); + return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L); + default : + break; + } + return jjStartNfa_0(7, active0, 0L); +} +private int jjMoveStringLiteralDfa9_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(7, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0, 0L); + return 9; + } + switch(curChar) + { + case 102: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(9, 39, 32); + break; + case 115: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(9, 37, 32); + break; + case 122: + return jjMoveStringLiteralDfa10_0(active0, 0x100000000000000L); + default : + break; + } + return jjStartNfa_0(8, active0, 0L); +} +private int jjMoveStringLiteralDfa10_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(8, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0, 0L); + return 10; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa11_0(active0, 0x100000000000000L); + default : + break; + } + return jjStartNfa_0(9, active0, 0L); +} +private int jjMoveStringLiteralDfa11_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(9, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0, 0L); + return 11; + } + switch(curChar) + { + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 56, 32); + break; + default : + break; + } + return jjStartNfa_0(10, active0, 0L); +} +private int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +static final long[] jjbitVec0 = { + 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec2 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec3 = { + 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L +}; +static final long[] jjbitVec4 = { + 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec5 = { + 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec6 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L +}; +static final long[] jjbitVec7 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L +}; +static final long[] jjbitVec8 = { + 0x3fffffffffffL, 0x0L, 0x0L, 0x0L +}; +private int jjMoveNfa_0(int startState, int curPos) +{ + int startsAt = 0; + jjnewStateCnt = 52; + int i = 1; + jjstateSet[0] = startState; + int kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + do + { + switch(jjstateSet[--i]) + { + case 3: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(0, 6); + else if (curChar == 36) + { + if (kind > 74) + kind = 74; + jjCheckNAdd(32); + } + else if (curChar == 34) + jjCheckNAddStates(7, 9); + else if (curChar == 39) + jjAddStates(10, 11); + else if (curChar == 46) + jjCheckNAdd(8); + else if (curChar == 47) + jjstateSet[jjnewStateCnt++] = 2; + if ((0x3fe000000000000L & l) != 0L) + { + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(5, 6); + } + else if (curChar == 48) + { + if (kind > 66) + kind = 66; + jjCheckNAddStates(12, 14); + } + break; + case 0: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if ((0xffff7fffffffffffL & l) != 0L && kind > 7) + kind = 7; + break; + case 2: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 0; + break; + case 4: + if ((0x3fe000000000000L & l) == 0L) + break; + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(5, 6); + break; + case 5: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(5, 6); + break; + case 7: + if (curChar == 46) + jjCheckNAdd(8); + break; + case 8: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(15, 17); + break; + case 10: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(11); + break; + case 11: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddTwoStates(11, 12); + break; + case 13: + if (curChar == 39) + jjAddStates(10, 11); + break; + case 14: + if ((0xffffff7fffffdbffL & l) != 0L) + jjCheckNAdd(15); + break; + case 15: + if (curChar == 39 && kind > 72) + kind = 72; + break; + case 17: + if ((0x8400000000L & l) != 0L) + jjCheckNAdd(15); + break; + case 18: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(19, 15); + break; + case 19: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(15); + break; + case 20: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 21; + break; + case 21: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(19); + break; + case 22: + if (curChar == 34) + jjCheckNAddStates(7, 9); + break; + case 23: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(7, 9); + break; + case 25: + if ((0x8400000000L & l) != 0L) + jjCheckNAddStates(7, 9); + break; + case 26: + if (curChar == 34 && kind > 73) + kind = 73; + break; + case 27: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(18, 21); + break; + case 28: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(7, 9); + break; + case 29: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 30; + break; + case 30: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(28); + break; + case 31: + if (curChar != 36) + break; + if (kind > 74) + kind = 74; + jjCheckNAdd(32); + break; + case 32: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 74) + kind = 74; + jjCheckNAdd(32); + break; + case 33: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(0, 6); + break; + case 34: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(34, 35); + break; + case 35: + if (curChar != 46) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(22, 24); + break; + case 36: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(22, 24); + break; + case 38: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(39); + break; + case 39: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddTwoStates(39, 12); + break; + case 40: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(40, 41); + break; + case 42: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(43); + break; + case 43: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddTwoStates(43, 12); + break; + case 44: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(25, 27); + break; + case 46: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(47); + break; + case 47: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(47, 12); + break; + case 48: + if (curChar != 48) + break; + if (kind > 66) + kind = 66; + jjCheckNAddStates(12, 14); + break; + case 50: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(50, 6); + break; + case 51: + if ((0xff000000000000L & l) == 0L) + break; + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(51, 6); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 3: + case 32: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 74) + kind = 74; + jjCheckNAdd(32); + break; + case 1: + if (kind > 7) + kind = 7; + break; + case 6: + if ((0x100000001000L & l) != 0L && kind > 66) + kind = 66; + break; + case 9: + if ((0x2000000020L & l) != 0L) + jjAddStates(28, 29); + break; + case 12: + if ((0x5000000050L & l) != 0L && kind > 70) + kind = 70; + break; + case 14: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAdd(15); + break; + case 16: + if (curChar == 92) + jjAddStates(30, 32); + break; + case 17: + if ((0x14404410000000L & l) != 0L) + jjCheckNAdd(15); + break; + case 23: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(7, 9); + break; + case 24: + if (curChar == 92) + jjAddStates(33, 35); + break; + case 25: + if ((0x14404410000000L & l) != 0L) + jjCheckNAddStates(7, 9); + break; + case 37: + if ((0x2000000020L & l) != 0L) + jjAddStates(36, 37); + break; + case 41: + if ((0x2000000020L & l) != 0L) + jjAddStates(38, 39); + break; + case 45: + if ((0x2000000020L & l) != 0L) + jjAddStates(40, 41); + break; + case 49: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(50); + break; + case 50: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 66) + kind = 66; + jjCheckNAddTwoStates(50, 6); + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 3: + case 32: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 74) + kind = 74; + jjCheckNAdd(32); + break; + case 1: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7) + kind = 7; + break; + case 14: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 15; + break; + case 23: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(7, 9); + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private int jjMoveStringLiteralDfa0_3() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_3(0x800L); + default : + return 1; + } +} +private int jjMoveStringLiteralDfa1_3(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x800L) != 0L) + return jjStopAtPos(1, 11); + break; + default : + return 2; + } + return 2; +} +private int jjMoveStringLiteralDfa0_1() +{ + return jjMoveNfa_1(0, 0); +} +private int jjMoveNfa_1(int startState, int curPos) +{ + int startsAt = 0; + jjnewStateCnt = 3; + int i = 1; + jjstateSet[0] = startState; + int kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + do + { + switch(jjstateSet[--i]) + { + case 0: + if ((0x2400L & l) != 0L) + { + if (kind > 9) + kind = 9; + } + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if (curChar == 10 && kind > 9) + kind = 9; + break; + case 2: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private int jjMoveStringLiteralDfa0_2() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_2(0x400L); + default : + return 1; + } +} +private int jjMoveStringLiteralDfa1_2(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x400L) != 0L) + return jjStopAtPos(1, 10); + break; + default : + return 2; + } + return 2; +} +static final int[] jjnextStates = { + 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8, + 9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18, + 20, 25, 27, 29, 38, 39, 42, 43, 46, 47, +}; +private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec2[i2] & l2) != 0L); + default : + if ((jjbitVec0[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec4[i2] & l2) != 0L); + case 48: + return ((jjbitVec5[i2] & l2) != 0L); + case 49: + return ((jjbitVec6[i2] & l2) != 0L); + case 51: + return ((jjbitVec7[i2] & l2) != 0L); + case 61: + return ((jjbitVec8[i2] & l2) != 0L); + default : + if ((jjbitVec3[i1] & l1) != 0L) + return true; + return false; + } +} + +/** Token literal values. */ +public static final String[] jjstrLiteralImages = { +"", null, null, null, null, null, null, null, null, null, null, null, null, +"\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156", +"\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", +"\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164", +"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", +"\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145", +"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", +"\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163", +"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", +"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167", +"\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", +"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", +"\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", +"\163\165\160\145\162", "\163\167\151\164\143\150", +"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", +"\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", +"\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, +null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", +"\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", +"\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", +"\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", +"\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", "\56\56\56", }; + +/** Lexer state names. */ +public static final String[] lexStateNames = { + "DEFAULT", + "IN_SINGLE_LINE_COMMENT", + "IN_FORMAL_COMMENT", + "IN_MULTI_LINE_COMMENT", +}; + +/** Lex State array. */ +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; +static final long[] jjtoToken = { + 0xffffffffffffe001L, 0x3ffffffffffe747L, +}; +static final long[] jjtoSkip = { + 0xe3eL, 0x0L, +}; +static final long[] jjtoSpecial = { + 0xe00L, 0x0L, +}; +static final long[] jjtoMore = { + 0x11c0L, 0x0L, +}; +protected JavaCharStream input_stream; +private final int[] jjrounds = new int[52]; +private final int[] jjstateSet = new int[104]; +private final StringBuilder jjimage = new StringBuilder(); +private StringBuilder image = jjimage; +private int jjimageLen; +private int lengthOfMatch; +protected char curChar; +/** Constructor. */ +public AnnotationParserTokenManager(JavaCharStream stream){ + if (JavaCharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} + +/** Constructor. */ +public AnnotationParserTokenManager(JavaCharStream stream, int lexState){ + this(stream); + SwitchTo(lexState); +} + +/** Reinitialise parser. */ +public void ReInit(JavaCharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 52; i-- > 0;) + jjrounds[i] = 0x80000000; +} + +/** Reinitialise parser. */ +public void ReInit(JavaCharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} + +/** Switch to specified lex state. */ +public void SwitchTo(int lexState) +{ + if (lexState >= 4 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +protected Token jjFillToken() +{ + final Token t; + final String curTokenImage; + final int beginLine; + final int endLine; + final int beginColumn; + final int endColumn; + String im = jjstrLiteralImages[jjmatchedKind]; + curTokenImage = (im == null) ? input_stream.GetImage() : im; + beginLine = input_stream.getBeginLine(); + beginColumn = input_stream.getBeginColumn(); + endLine = input_stream.getEndLine(); + endColumn = input_stream.getEndColumn(); + t = Token.newToken(jjmatchedKind, curTokenImage); + + t.beginLine = beginLine; + t.endLine = endLine; + t.beginColumn = beginColumn; + t.endColumn = endColumn; + + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +/** Get the next Token. */ +public Token getNextToken() +{ + Token specialToken = null; + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + return matchedToken; + } + image = jjimage; + image.setLength(0); + jjimageLen = 0; + + for (;;) + { + switch(curLexState) + { + case 0: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 2: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_2(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 3: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_3(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (specialToken == null) + specialToken = matchedToken; + else + { + matchedToken.specialToken = specialToken; + specialToken = (specialToken.next = matchedToken); + } + SkipLexicalActions(matchedToken); + } + else + SkipLexicalActions(null); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + MoreLexicalActions(); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } + } +} + +void SkipLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + default : + break; + } +} +void MoreLexicalActions() +{ + jjimageLen += (lengthOfMatch = jjmatchedPos + 1); + switch(jjmatchedKind) + { + case 7 : + image.append(input_stream.GetSuffix(jjimageLen)); + jjimageLen = 0; + input_stream.backup(1); + break; + default : + break; + } +} +private void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} + +private void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} + +} Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/JavaCharStream.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/JavaCharStream.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/JavaCharStream.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,617 @@ +/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 5.0 */ +/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +package org.jboss.seam.remoting.annotationparser; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (with java-like unicode escape processing). + */ + +public +class JavaCharStream +{ + /** Whether parser is static. */ + public static final boolean staticFlag = false; + + static final int hexval(char c) throws java.io.IOException { + switch(c) + { + case '0' : + return 0; + case '1' : + return 1; + case '2' : + return 2; + case '3' : + return 3; + case '4' : + return 4; + case '5' : + return 5; + case '6' : + return 6; + case '7' : + return 7; + case '8' : + return 8; + case '9' : + return 9; + + case 'a' : + case 'A' : + return 10; + case 'b' : + case 'B' : + return 11; + case 'c' : + case 'C' : + return 12; + case 'd' : + case 'D' : + return 13; + case 'e' : + case 'E' : + return 14; + case 'f' : + case 'F' : + return 15; + } + + throw new java.io.IOException(); // Should never come here + } + +/** Position in buffer. */ + public int bufpos = -1; + int bufsize; + int available; + int tokenBegin; + protected int bufline[]; + protected int bufcolumn[]; + + protected int column = 0; + protected int line = 1; + + protected boolean prevCharIsCR = false; + protected boolean prevCharIsLF = false; + + protected java.io.Reader inputStream; + + protected char[] nextCharBuf; + protected char[] buffer; + protected int maxNextCharInd = 0; + protected int nextCharInd = -1; + protected int inBuf = 0; + protected int tabSize = 8; + + protected void setTabSize(int i) { tabSize = i; } + protected int getTabSize(int i) { return tabSize; } + + protected void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); + bufcolumn = newbufcolumn; + + bufpos += (bufsize - tokenBegin); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + bufpos -= tokenBegin; + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + available = (bufsize += 2048); + tokenBegin = 0; + } + + protected void FillBuff() throws java.io.IOException + { + int i; + if (maxNextCharInd == 4096) + maxNextCharInd = nextCharInd = 0; + + try { + if ((i = inputStream.read(nextCharBuf, maxNextCharInd, + 4096 - maxNextCharInd)) == -1) + { + inputStream.close(); + throw new java.io.IOException(); + } + else + maxNextCharInd += i; + return; + } + catch(java.io.IOException e) { + if (bufpos != 0) + { + --bufpos; + backup(0); + } + else + { + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + throw e; + } + } + + protected char ReadByte() throws java.io.IOException + { + if (++nextCharInd >= maxNextCharInd) + FillBuff(); + + return nextCharBuf[nextCharInd]; + } + +/** @return starting character for token. */ + public char BeginToken() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + tokenBegin = bufpos; + return buffer[bufpos]; + } + + tokenBegin = 0; + bufpos = -1; + + return readChar(); + } + + protected void AdjustBuffSize() + { + if (available == bufsize) + { + if (tokenBegin > 2048) + { + bufpos = 0; + available = tokenBegin; + } + else + ExpandBuff(false); + } + else if (available > tokenBegin) + available = bufsize; + else if ((tokenBegin - available) < 2048) + ExpandBuff(true); + else + available = tokenBegin; + } + + protected void UpdateLineColumn(char c) + { + column++; + + if (prevCharIsLF) + { + prevCharIsLF = false; + line += (column = 1); + } + else if (prevCharIsCR) + { + prevCharIsCR = false; + if (c == '\n') + { + prevCharIsLF = true; + } + else + line += (column = 1); + } + + switch (c) + { + case '\r' : + prevCharIsCR = true; + break; + case '\n' : + prevCharIsLF = true; + break; + case '\t' : + column--; + column += (tabSize - (column % tabSize)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + +/** Read a character. */ + public char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + return buffer[bufpos]; + } + + char c; + + if (++bufpos == available) + AdjustBuffSize(); + + if ((buffer[bufpos] = c = ReadByte()) == '\\') + { + UpdateLineColumn(c); + + int backSlashCnt = 1; + + for (;;) // Read all the backslashes + { + if (++bufpos == available) + AdjustBuffSize(); + + try + { + if ((buffer[bufpos] = c = ReadByte()) != '\\') + { + UpdateLineColumn(c); + // found a non-backslash char. + if ((c == 'u') && ((backSlashCnt & 1) == 1)) + { + if (--bufpos < 0) + bufpos = bufsize - 1; + + break; + } + + backup(backSlashCnt); + return '\\'; + } + } + catch(java.io.IOException e) + { + // We are returning one backslash so we should only backup (count-1) + if (backSlashCnt > 1) + backup(backSlashCnt-1); + + return '\\'; + } + + UpdateLineColumn(c); + backSlashCnt++; + } + + // Here, we have seen an odd number of backslash's followed by a 'u' + try + { + while ((c = ReadByte()) == 'u') + ++column; + + buffer[bufpos] = c = (char)(hexval(c) << 12 | + hexval(ReadByte()) << 8 | + hexval(ReadByte()) << 4 | + hexval(ReadByte())); + + column += 4; + } + catch(java.io.IOException e) + { + throw new Error("Invalid escape character at line " + line + + " column " + column + "."); + } + + if (backSlashCnt == 1) + return c; + else + { + backup(backSlashCnt - 1); + return '\\'; + } + } + else + { + UpdateLineColumn(c); + return c; + } + } + + @Deprecated + /** + * @deprecated + * @see #getEndColumn + */ + public int getColumn() { + return bufcolumn[bufpos]; + } + + @Deprecated + /** + * @deprecated + * @see #getEndLine + */ + public int getLine() { + return bufline[bufpos]; + } + +/** Get end column. */ + public int getEndColumn() { + return bufcolumn[bufpos]; + } + +/** Get end line. */ + public int getEndLine() { + return bufline[bufpos]; + } + +/** @return column of token start */ + public int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + +/** @return line number of token start */ + public int getBeginLine() { + return bufline[tokenBegin]; + } + +/** Retreat. */ + public void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + +/** Constructor. */ + public JavaCharStream(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + +/** Constructor. */ + public JavaCharStream(java.io.Reader dstream, + int startline, int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + +/** Constructor. */ + public JavaCharStream(java.io.Reader dstream) + { + this(dstream, 1, 1, 4096); + } +/** Reinitialise. */ + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + nextCharInd = bufpos = -1; + } + +/** Reinitialise. */ + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + +/** Reinitialise. */ + public void ReInit(java.io.Reader dstream) + { + ReInit(dstream, 1, 1, 4096); + } +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096); + } + +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, startline, startcolumn, 4096); + } + +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, 1, 1, 4096); + } + +/** Constructor. */ + public JavaCharStream(java.io.InputStream dstream) + { + this(dstream, 1, 1, 4096); + } + +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, startline, startcolumn, 4096); + } +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, 1, 1, 4096); + } + +/** Reinitialise. */ + public void ReInit(java.io.InputStream dstream) + { + ReInit(dstream, 1, 1, 4096); + } + + /** @return token image as String */ + public String GetImage() + { + if (bufpos >= tokenBegin) + return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); + else + return new String(buffer, tokenBegin, bufsize - tokenBegin) + + new String(buffer, 0, bufpos + 1); + } + + /** @return suffix */ + public char[] GetSuffix(int len) + { + char[] ret = new char[len]; + + if ((bufpos + 1) >= len) + System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); + else + { + System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, + len - bufpos - 1); + System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); + } + + return ret; + } + + /** Set buffers back to null when finished. */ + public void Done() + { + nextCharBuf = null; + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token. + */ + public void adjustBeginLineColumn(int newLine, int newCol) + { + int start = tokenBegin; + int len; + + if (bufpos >= tokenBegin) + { + len = bufpos - tokenBegin + inBuf + 1; + } + else + { + len = bufsize - tokenBegin + bufpos + 1 + inBuf; + } + + int i = 0, j = 0, k = 0; + int nextColDiff = 0, columnDiff = 0; + + while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) + { + bufline[j] = newLine; + nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; + bufcolumn[j] = newCol + columnDiff; + columnDiff = nextColDiff; + i++; + } + + if (i < len) + { + bufline[j] = newLine++; + bufcolumn[j] = newCol + columnDiff; + + while (i++ < len) + { + if (bufline[j = start % bufsize] != bufline[++start % bufsize]) + bufline[j] = newLine++; + else + bufline[j] = newLine; + } + } + + line = bufline[j]; + column = bufcolumn[j]; + } + +} +/* JavaCC - OriginalChecksum=182365e3286b47c28748722cabea6f07 (do not edit this line) */ Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/ParseException.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/ParseException.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/ParseException.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,187 @@ +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */ +/* JavaCCOptions:KEEP_LINE_COL=null */ +package org.jboss.seam.remoting.annotationparser; + +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends Exception { + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) + { + super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal)); + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + } + + /** Constructor with message. */ + public ParseException(String message) { + super(message); + } + + + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + + /** + * It uses "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser) the correct error message + * gets displayed. + */ + private static String initialise(Token currentToken, + int[][] expectedTokenSequences, + String[] tokenImage) { + String eol = System.getProperty("line.separator", "\n"); + StringBuffer expected = new StringBuffer(); + int maxSize = 0; + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' '); + } + if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + expected.append(eol).append(" "); + } + String retval = "Encountered \""; + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + if (i != 0) retval += " "; + if (tok.kind == 0) { + retval += tokenImage[0]; + break; + } + retval += " " + tokenImage[tok.kind]; + retval += " \""; + retval += add_escapes(tok.image); + retval += " \""; + tok = tok.next; + } + retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; + retval += "." + eol; + if (expectedTokenSequences.length == 1) { + retval += "Was expecting:" + eol + " "; + } else { + retval += "Was expecting one of:" + eol + " "; + } + retval += expected.toString(); + return retval; + } + + /** + * The end of line string for this machine. + */ + protected String eol = System.getProperty("line.separator", "\n"); + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + static String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} +/* JavaCC - OriginalChecksum=3df005c67535972cf450c73c35562a92 (do not edit this line) */ Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/Token.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/Token.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/Token.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,131 @@ +/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */ +/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +package org.jboss.seam.remoting.annotationparser; + +/** + * Describes the input token stream. + */ + +public class Token implements java.io.Serializable { + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** The line number of the first character of this Token. */ + public int beginLine; + /** The column number of the first character of this Token. */ + public int beginColumn; + /** The line number of the last character of this Token. */ + public int endLine; + /** The column number of the last character of this Token. */ + public int endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * An optional attribute value of the Token. + * Tokens which are not used as syntactic sugar will often contain + * meaningful values that will be used later on by the compiler or + * interpreter. This attribute value is often different from the image. + * Any subclass of Token that actually wants to return a non-null value can + * override this method as appropriate. + */ + public Object getValue() { + return null; + } + + /** + * No-argument constructor + */ + public Token() {} + + /** + * Constructs a new token for the specified Image. + */ + public Token(int kind) + { + this(kind, null); + } + + /** + * Constructs a new token for the specified Image and Kind. + */ + public Token(int kind, String image) + { + this.kind = kind; + this.image = image; + } + + /** + * Returns the image. + */ + public String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simply add something like : + * + * case MyParserConstants.ID : return new IDToken(ofKind, image); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use sit in your lexical actions. + */ + public static Token newToken(int ofKind, String image) + { + switch(ofKind) + { + default : return new Token(ofKind, image); + } + } + + public static Token newToken(int ofKind) + { + return newToken(ofKind, null); + } + +} +/* JavaCC - OriginalChecksum=49fd782c1d30df051e10a1c1f0160383 (do not edit this line) */ Added: modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/TokenMgrError.java =================================================================== --- modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/TokenMgrError.java (rev 0) +++ modules/trunk/remoting/src/main/java/org/jboss/seam/remoting/annotationparser/TokenMgrError.java 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,147 @@ +/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */ +/* JavaCCOptions: */ +package org.jboss.seam.remoting.annotationparser; + +/** Token Manager Error. */ +public class TokenMgrError extends Error +{ + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occurred. + */ + static final int LEXICAL_ERROR = 0; + + /** + * An attempt was made to create a second instance of a static token manager. + */ + static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their escaped (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexical error + * curLexState : lexical state in which this error occurred + * errorLine : line number when the error occurred + * errorColumn : column number when the error occurred + * errorAfter : prefix that was seen before this error occurred + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + /** No arg constructor. */ + public TokenMgrError() { + } + + /** Constructor with message and reason. */ + public TokenMgrError(String message, int reason) { + super(message); + errorCode = reason; + } + + /** Full Constructor. */ + public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { + this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} +/* JavaCC - OriginalChecksum=cf2bd704a56c55788afc36f823025214 (do not edit this line) */ Added: modules/trunk/remoting/src/main/javacc/AnnotationParser.jj =================================================================== --- modules/trunk/remoting/src/main/javacc/AnnotationParser.jj (rev 0) +++ modules/trunk/remoting/src/main/javacc/AnnotationParser.jj 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,467 @@ +options { + JAVA_UNICODE_ESCAPE = true; + ERROR_REPORTING = false; + STATIC = false; +} + +PARSER_BEGIN(AnnotationParser) +package org.jboss.seam.remoting.annotationparser; + +import java.io.*; + +/** + * Grammar to parse Java 1.5 Annotations + * @author Shane Bryzak + */ +public class AnnotationParser +{ + public AnnotationParser(String fileName) + { + this(System.in); + try { ReInit(new FileInputStream(new File(fileName))); } + catch(Exception e) { e.printStackTrace(); } + } + + public static void main(String args[]) { + AnnotationParser parser; + if (args.length == 0) { + System.out.println("AnnotationParser: Reading from standard input . . ."); + parser = new AnnotationParser(System.in); + } else if (args.length == 1) { + System.out.println("AnnotationParser: Reading from file " + args[0] + " . . ."); + try { + parser = new AnnotationParser(new java.io.FileInputStream(args[0])); + } catch (java.io.FileNotFoundException e) { + System.out.println("AnnotationParser: File " + args[0] + " not found."); + return; + } + } else { + System.out.println("AnnotationParser: Usage is one of:"); + System.out.println(" java AnnotationParser < inputfile"); + System.out.println("OR"); + System.out.println(" java AnnotationParser inputfile"); + return; + } + try { + parser.AnnotationsUnit(); + System.out.println("AnnotationParser: Annotations parsed successfully."); + } catch (ParseException e) { + System.out.println(e.getMessage()); + System.out.println("AnnotationParser: Encountered errors during parse."); + } + } + +} + +PARSER_END(AnnotationParser) + +/* WHITE SPACE */ + +SKIP : +{ + " " +| "\t" +| "\n" +| "\r" +| "\f" +} + +/* COMMENTS */ + +MORE : +{ + "//" : IN_SINGLE_LINE_COMMENT +| + <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT +| + "/*" : IN_MULTI_LINE_COMMENT +} + +<IN_SINGLE_LINE_COMMENT> +SPECIAL_TOKEN : +{ + <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT +} + +<IN_FORMAL_COMMENT> +SPECIAL_TOKEN : +{ + <FORMAL_COMMENT: "*/" > : DEFAULT +} + +<IN_MULTI_LINE_COMMENT> +SPECIAL_TOKEN : +{ + <MULTI_LINE_COMMENT: "*/" > : DEFAULT +} + +<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT> +MORE : +{ + < ~[] > +} + +/* RESERVED WORDS AND LITERALS */ + +TOKEN : +{ + < ABSTRACT: "abstract" > +| < ASSERT: "assert" > +| < BOOLEAN: "boolean" > +| < BREAK: "break" > +| < BYTE: "byte" > +| < CASE: "case" > +| < CATCH: "catch" > +| < CHAR: "char" > +| < CLASS: "class" > +| < CONST: "const" > +| < CONTINUE: "continue" > +| < _DEFAULT: "default" > +| < DO: "do" > +| < DOUBLE: "double" > +| < ELSE: "else" > +| < ENUM: "enum" > +| < EXTENDS: "extends" > +| < FALSE: "false" > +| < FINAL: "final" > +| < FINALLY: "finally" > +| < FLOAT: "float" > +| < FOR: "for" > +| < GOTO: "goto" > +| < IF: "if" > +| < IMPLEMENTS: "implements" > +| < IMPORT: "import" > +| < INSTANCEOF: "instanceof" > +| < INT: "int" > +| < INTERFACE: "interface" > +| < LONG: "long" > +| < NATIVE: "native" > +| < NEW: "new" > +| < NULL: "null" > +| < PACKAGE: "package"> +| < PRIVATE: "private" > +| < PROTECTED: "protected" > +| < PUBLIC: "public" > +| < RETURN: "return" > +| < SHORT: "short" > +| < STATIC: "static" > +| < STRICTFP: "strictfp" > +| < SUPER: "super" > +| < SWITCH: "switch" > +| < SYNCHRONIZED: "synchronized" > +| < THIS: "this" > +| < THROW: "throw" > +| < THROWS: "throws" > +| < TRANSIENT: "transient" > +| < TRUE: "true" > +| < TRY: "try" > +| < VOID: "void" > +| < VOLATILE: "volatile" > +| < WHILE: "while" > +} + +/* LITERALS */ + +TOKEN : +{ + < INTEGER_LITERAL: + <DECIMAL_LITERAL> (["l","L"])? + | <HEX_LITERAL> (["l","L"])? + | <OCTAL_LITERAL> (["l","L"])? + > +| + < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* > +| + < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ > +| + < #OCTAL_LITERAL: "0" (["0"-"7"])* > +| + < FLOATING_POINT_LITERAL: + (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])? + | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])? + | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])? + | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"] + > +| + < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ > +| + < CHARACTER_LITERAL: + "'" + ( (~["'","\\","\n","\r"]) + | ("\\" + ( ["n","t","b","r","f","\\","'","\""] + | ["0"-"7"] ( ["0"-"7"] )? + | ["0"-"3"] ["0"-"7"] ["0"-"7"] + ) + ) + ) + "'" + > +| + < STRING_LITERAL: + "\"" + ( (~["\"","\\","\n","\r"]) + | ("\\" + ( ["n","t","b","r","f","\\","'","\""] + | ["0"-"7"] ( ["0"-"7"] )? + | ["0"-"3"] ["0"-"7"] ["0"-"7"] + ) + ) + )* + "\"" + > +} + +/* IDENTIFIERS */ + +TOKEN : +{ + < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* > +| + < #LETTER: + [ + "\u0024", + "\u0041"-"\u005a", + "\u005f", + "\u0061"-"\u007a", + "\u00c0"-"\u00d6", + "\u00d8"-"\u00f6", + "\u00f8"-"\u00ff", + "\u0100"-"\u1fff", + "\u3040"-"\u318f", + "\u3300"-"\u337f", + "\u3400"-"\u3d2d", + "\u4e00"-"\u9fff", + "\uf900"-"\ufaff" + ] + > +| + < #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", + "\u1040"-"\u1049" + ] + > +} + +/* SEPARATORS */ + +TOKEN : +{ + < LPAREN: "(" > +| < RPAREN: ")" > +| < LBRACE: "{" > +| < RBRACE: "}" > +| < LBRACKET: "[" > +| < RBRACKET: "]" > +| < SEMICOLON: ";" > +| < COMMA: "," > +| < DOT: "." > +| < AT: "@" > +} + +/* OPERATORS */ + +TOKEN : +{ + < ASSIGN: "=" > +| < LT: "<" > +| < BANG: "!" > +| < TILDE: "~" > +| < HOOK: "?" > +| < COLON: ":" > +| < EQ: "==" > +| < LE: "<=" > +| < GE: ">=" > +| < NE: "!=" > +| < SC_OR: "||" > +| < SC_AND: "&&" > +| < INCR: "++" > +| < DECR: "--" > +| < PLUS: "+" > +| < MINUS: "-" > +| < STAR: "*" > +| < SLASH: "/" > +| < BIT_AND: "&" > +| < BIT_OR: "|" > +| < XOR: "^" > +| < REM: "%" > +| < LSHIFT: "<<" > +| < PLUSASSIGN: "+=" > +| < MINUSASSIGN: "-=" > +| < STARASSIGN: "*=" > +| < SLASHASSIGN: "/=" > +| < ANDASSIGN: "&=" > +| < ORASSIGN: "|=" > +| < XORASSIGN: "^=" > +| < REMASSIGN: "%=" > +| < LSHIFTASSIGN: "<<=" > +| < RSIGNEDSHIFTASSIGN: ">>=" > +| < RUNSIGNEDSHIFTASSIGN: ">>>=" > +| < ELLIPSIS: "..." > +} + +/* >'s need special attention due to generics syntax. */ +TOKEN : +{ + < RUNSIGNEDSHIFT: ">>>" > + { + matchedToken.kind = GT; + ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT; + input_stream.backup(2); + } +| < RSIGNEDSHIFT: ">>" > + { + matchedToken.kind = GT; + ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT; + input_stream.backup(1); + } +| < GT: ">" > +} + + +/*********************************** + * ANNOTATIONS GRAMMAR STARTS HERE * + ***********************************/ + +/* + * Program structuring syntax follows. + */ + +void AnnotationsUnit(): +{} +{ + "(" [ Annotation() ( "," Annotation() )* ] ")" +} + +void PrimitiveType(): +{} +{ + "boolean" +| + "char" +| + "byte" +| + "short" +| + "int" +| + "long" +| + "float" +| + "double" +} + +void Name(): +{} +{ + <IDENTIFIER> + ( "." <IDENTIFIER> + )* +} + +void Literal(): +{} +{ + <INTEGER_LITERAL> +| + <FLOATING_POINT_LITERAL> +| + <CHARACTER_LITERAL> +| + <STRING_LITERAL> +| + BooleanLiteral() +| + NullLiteral() +} + +void BooleanLiteral(): +{} +{ + "true" +| + "false" +} + +void NullLiteral(): +{} +{ + "null" +} + +/* Annotation syntax follows. */ + +void Annotation(): +{} +{ + LOOKAHEAD( "@" Name() "(" ( <IDENTIFIER> "=" | ")" )) + NormalAnnotation() + | + LOOKAHEAD( "@" Name() "(" ) + SingleMemberAnnotation() + | + MarkerAnnotation() +} + +void NormalAnnotation(): +{} +{ + "@" Name() "(" [ MemberValuePairs() ] ")" +} + +void MarkerAnnotation(): +{} +{ + "@" Name() +} + +void SingleMemberAnnotation(): +{} +{ + "@" Name() "(" MemberValue() ")" +} + +void MemberValuePairs(): +{} +{ + MemberValuePair() ( "," MemberValuePair() )* +} + +void MemberValuePair(): +{} +{ + <IDENTIFIER> "=" MemberValue() +} + +void MemberValue(): +{} +{ + Annotation() + | + MemberValueArrayInitializer() + | + Literal() +} + +void MemberValueArrayInitializer(): +{} +{ + "{" MemberValue() ( LOOKAHEAD(2) "," MemberValue() )* [ "," ] "}" +} + Added: modules/trunk/remoting/src/main/javacc/readme.txt =================================================================== --- modules/trunk/remoting/src/main/javacc/readme.txt (rev 0) +++ modules/trunk/remoting/src/main/javacc/readme.txt 2009-11-30 03:55:25 UTC (rev 11703) @@ -0,0 +1,5 @@ +JavaCC grammar file for parsing annotation expressions. + +JavaCC can be downloaded from https://javacc.dev.java.net/. + +Usage: /path/to/javacc AnnotationParser.jj