From: Peizhao Ou Date: Wed, 9 Oct 2013 04:01:53 +0000 (-0700) Subject: add setup-env.sh X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=3914e7a0a051d03bde44122f970d0549ef1b7dbf;p=cdsspec-compiler.git add setup-env.sh --- diff --git a/run-javacc.sh b/run-javacc.sh index 308dee7..a8484bd 100755 --- a/run-javacc.sh +++ b/run-javacc.sh @@ -1,12 +1,15 @@ #!/bin/bash -JAVACC_PATH=/home/peizhaoo/spec-checker-compiler/javacc-6.0/bin/lib +if [ -z $SPEC_COMPILER_HOME ]; then + SPEC_COMPILER_HOME=~/spec-checker-compiler +fi + +JAVACC_PATH=$SPEC_COMPILER_HOME/lib -SRC_PATH=/home/peizhaoo/spec-checker-compiler/src -OUTPUT_PATH=$SRC_PATH/edu/uci/eecs/specCompiler/grammerParser +OUTPUT_PATH=$SPEC_COMPILER_HOME/src/edu/uci/eecs/specCompiler/grammerParser mkdir -p $OUTPUT_PATH -GRAMMER_FILE=$SRC_PATH/../grammer/spec-compiler.jj +GRAMMER_FILE=$SPEC_COMPILER_HOME/grammer/spec-compiler.jj if [ -z $1 ]; then echo "Using the default grammer file: $GRAMMER_FILE." diff --git a/setup-env.sh b/setup-env.sh new file mode 100644 index 0000000..4946f85 --- /dev/null +++ b/setup-env.sh @@ -0,0 +1,7 @@ +#!/bin/bash + +if [ -z $1 ]; then + export SPEC_COMPILER_HOME=~/spec-compiler-home +else + export SPEC_COMPILER_HOME=$1 +fi diff --git a/src/edu/uci/eecs/specCompiler/Init.java b/src/edu/uci/eecs/specCompiler/Init.java deleted file mode 100644 index f61647f..0000000 --- a/src/edu/uci/eecs/specCompiler/Init.java +++ /dev/null @@ -1,20 +0,0 @@ -package edu.uci.eecs.specCompiler; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; - -import org.javacc.parser.JavaCCParser; - -public class Init { - public static void main(String[] argvs) { - File grammerFile = new File("grammer/spec-compiler.jj"); - FileInputStream fis; - try { - fis = new FileInputStream(grammerFile); - JavaCCParser parser = new JavaCCParser(fis); - } catch (FileNotFoundException e) { - e.printStackTrace(); - } - } -} \ No newline at end of file diff --git a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParser.java b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParser.java index f5aa21a..4d4e2d3 100644 --- a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParser.java +++ b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParser.java @@ -145,7 +145,7 @@ package edu.uci.eecs.specCompiler.grammerParser; /** Generate ParseException. */ public ParseException generateParseException() { jj_expentries.clear(); - boolean[] la1tokens = new boolean[11]; + boolean[] la1tokens = new boolean[21]; if (jj_kind >= 0) { la1tokens[jj_kind] = true; jj_kind = -1; @@ -159,7 +159,7 @@ package edu.uci.eecs.specCompiler.grammerParser; } } } - for (int i = 0; i < 11; i++) { + for (int i = 0; i < 21; i++) { if (la1tokens[i]) { jj_expentry = new int[1]; jj_expentry[0] = i; diff --git a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserConstants.java b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserConstants.java index 3e64f04..aadfd4f 100644 --- a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserConstants.java +++ b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserConstants.java @@ -13,15 +13,35 @@ public interface SpecParserConstants { /** RegularExpression Id. */ int SPACE = 5; /** RegularExpression Id. */ - int HEAD = 6; + int COMMENT = 6; /** RegularExpression Id. */ - int TAIL = 7; + int HEAD = 7; /** RegularExpression Id. */ - int BEGIN = 8; + int TAIL = 8; /** RegularExpression Id. */ - int END = 9; + int BEGIN = 9; /** RegularExpression Id. */ - int COMMENT = 10; + int END = 10; + /** RegularExpression Id. */ + int ID = 11; + /** RegularExpression Id. */ + int CONDITION = 12; + /** RegularExpression Id. */ + int CHECK = 13; + /** RegularExpression Id. */ + int ACTION = 14; + /** RegularExpression Id. */ + int POST_ACTION = 15; + /** RegularExpression Id. */ + int POST_CHECK = 16; + /** RegularExpression Id. */ + int GLOBAL_DEFINE = 17; + /** RegularExpression Id. */ + int HAPPENS_BEFORE = 18; + /** RegularExpression Id. */ + int INTERFACE_CLUSTER = 19; + /** RegularExpression Id. */ + int POTENTIAL_COMMIT_POINT = 20; /** Lexical state. */ int DEFAULT = 0; @@ -34,11 +54,21 @@ public interface SpecParserConstants { "\"\\r\"", "\"\\r\\n\"", "", + "", "\"/**\"", "\"*/\"", "\"@Begin\"", "\"@End\"", - "", + "\"@ID:\"", + "\"@Condition:\"", + "\"@Check:\"", + "\"@Action:\"", + "\"@Post_action:\"", + "\"@Post_check:\"", + "\"@Global_define:\"", + "\"@Happens_before:\"", + "\"@Interface_cluster:\"", + "\"@Potential_commit_point:\"", }; } diff --git a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserTokenManager.java b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserTokenManager.java index f83e7c9..d710afc 100644 --- a/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserTokenManager.java +++ b/src/edu/uci/eecs/specCompiler/grammerParser/SpecParserTokenManager.java @@ -38,11 +38,11 @@ private int jjMoveStringLiteralDfa0_0(){ case 32: return jjStartNfaWithStates_0(0, 1, 6); case 42: - return jjMoveStringLiteralDfa1_0(0x80L); + return jjMoveStringLiteralDfa1_0(0x100L); case 47: - return jjMoveStringLiteralDfa1_0(0x40L); + return jjMoveStringLiteralDfa1_0(0x80L); case 64: - return jjMoveStringLiteralDfa1_0(0x300L); + return jjMoveStringLiteralDfa1_0(0x1ffe00L); default : return jjMoveNfa_0(0, 0); } @@ -60,15 +60,27 @@ private int jjMoveStringLiteralDfa1_0(long active0){ return jjStopAtPos(1, 4); break; case 42: - return jjMoveStringLiteralDfa2_0(active0, 0x40L); + return jjMoveStringLiteralDfa2_0(active0, 0x80L); case 47: - if ((active0 & 0x80L) != 0L) - return jjStopAtPos(1, 7); + if ((active0 & 0x100L) != 0L) + return jjStopAtPos(1, 8); break; + case 65: + return jjMoveStringLiteralDfa2_0(active0, 0x4000L); case 66: - return jjMoveStringLiteralDfa2_0(active0, 0x100L); - case 69: return jjMoveStringLiteralDfa2_0(active0, 0x200L); + case 67: + return jjMoveStringLiteralDfa2_0(active0, 0x3000L); + case 69: + return jjMoveStringLiteralDfa2_0(active0, 0x400L); + case 71: + return jjMoveStringLiteralDfa2_0(active0, 0x20000L); + case 72: + return jjMoveStringLiteralDfa2_0(active0, 0x40000L); + case 73: + return jjMoveStringLiteralDfa2_0(active0, 0x80800L); + case 80: + return jjMoveStringLiteralDfa2_0(active0, 0x118000L); default : break; } @@ -85,13 +97,25 @@ private int jjMoveStringLiteralDfa2_0(long old0, long active0){ switch(curChar) { case 42: - if ((active0 & 0x40L) != 0L) - return jjStopAtPos(2, 6); + if ((active0 & 0x80L) != 0L) + return jjStopAtPos(2, 7); break; + case 68: + return jjMoveStringLiteralDfa3_0(active0, 0x800L); + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x40000L); + case 99: + return jjMoveStringLiteralDfa3_0(active0, 0x4000L); case 101: - return jjMoveStringLiteralDfa3_0(active0, 0x100L); - case 110: return jjMoveStringLiteralDfa3_0(active0, 0x200L); + case 104: + return jjMoveStringLiteralDfa3_0(active0, 0x2000L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x20000L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x80400L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0x119000L); default : break; } @@ -107,12 +131,28 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0){ } switch(curChar) { + case 58: + if ((active0 & 0x800L) != 0L) + return jjStopAtPos(3, 11); + break; case 100: - if ((active0 & 0x200L) != 0L) - return jjStopAtPos(3, 9); + if ((active0 & 0x400L) != 0L) + return jjStopAtPos(3, 10); break; + case 101: + return jjMoveStringLiteralDfa4_0(active0, 0x2000L); case 103: - return jjMoveStringLiteralDfa4_0(active0, 0x100L); + return jjMoveStringLiteralDfa4_0(active0, 0x200L); + case 110: + return jjMoveStringLiteralDfa4_0(active0, 0x1000L); + case 111: + return jjMoveStringLiteralDfa4_0(active0, 0x20000L); + case 112: + return jjMoveStringLiteralDfa4_0(active0, 0x40000L); + case 115: + return jjMoveStringLiteralDfa4_0(active0, 0x18000L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x184000L); default : break; } @@ -128,8 +168,20 @@ private int jjMoveStringLiteralDfa4_0(long old0, long active0){ } switch(curChar) { + case 98: + return jjMoveStringLiteralDfa5_0(active0, 0x20000L); + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0x2000L); + case 100: + return jjMoveStringLiteralDfa5_0(active0, 0x1000L); + case 101: + return jjMoveStringLiteralDfa5_0(active0, 0x180000L); case 105: - return jjMoveStringLiteralDfa5_0(active0, 0x100L); + return jjMoveStringLiteralDfa5_0(active0, 0x4200L); + case 112: + return jjMoveStringLiteralDfa5_0(active0, 0x40000L); + case 116: + return jjMoveStringLiteralDfa5_0(active0, 0x18000L); default : break; } @@ -145,15 +197,445 @@ private int jjMoveStringLiteralDfa5_0(long old0, long active0){ } switch(curChar) { + case 95: + return jjMoveStringLiteralDfa6_0(active0, 0x18000L); + case 97: + return jjMoveStringLiteralDfa6_0(active0, 0x20000L); + case 101: + return jjMoveStringLiteralDfa6_0(active0, 0x40000L); + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x1000L); + case 107: + return jjMoveStringLiteralDfa6_0(active0, 0x2000L); case 110: - if ((active0 & 0x100L) != 0L) - return jjStopAtPos(5, 8); - break; + if ((active0 & 0x200L) != 0L) + return jjStopAtPos(5, 9); + return jjMoveStringLiteralDfa6_0(active0, 0x100000L); + case 111: + return jjMoveStringLiteralDfa6_0(active0, 0x4000L); + case 114: + return jjMoveStringLiteralDfa6_0(active0, 0x80000L); default : break; } return jjStartNfa_0(4, active0); } +private int jjMoveStringLiteralDfa6_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(4, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0); + return 6; + } + switch(curChar) + { + case 58: + if ((active0 & 0x2000L) != 0L) + return jjStopAtPos(6, 13); + break; + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x8000L); + case 99: + return jjMoveStringLiteralDfa7_0(active0, 0x10000L); + case 102: + return jjMoveStringLiteralDfa7_0(active0, 0x80000L); + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0x20000L); + case 110: + return jjMoveStringLiteralDfa7_0(active0, 0x44000L); + case 116: + return jjMoveStringLiteralDfa7_0(active0, 0x101000L); + default : + break; + } + return jjStartNfa_0(5, active0); +} +private int jjMoveStringLiteralDfa7_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(5, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0); + return 7; + } + switch(curChar) + { + case 58: + if ((active0 & 0x4000L) != 0L) + return jjStopAtPos(7, 14); + break; + case 95: + return jjMoveStringLiteralDfa8_0(active0, 0x20000L); + case 97: + return jjMoveStringLiteralDfa8_0(active0, 0x80000L); + case 99: + return jjMoveStringLiteralDfa8_0(active0, 0x8000L); + case 104: + return jjMoveStringLiteralDfa8_0(active0, 0x10000L); + case 105: + return jjMoveStringLiteralDfa8_0(active0, 0x101000L); + case 115: + return jjMoveStringLiteralDfa8_0(active0, 0x40000L); + default : + break; + } + return jjStartNfa_0(6, active0); +} +private int jjMoveStringLiteralDfa8_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(6, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_0(active0, 0x40000L); + case 97: + return jjMoveStringLiteralDfa9_0(active0, 0x100000L); + case 99: + return jjMoveStringLiteralDfa9_0(active0, 0x80000L); + case 100: + return jjMoveStringLiteralDfa9_0(active0, 0x20000L); + case 101: + return jjMoveStringLiteralDfa9_0(active0, 0x10000L); + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0x1000L); + case 116: + return jjMoveStringLiteralDfa9_0(active0, 0x8000L); + default : + break; + } + return jjStartNfa_0(7, active0); +} +private int jjMoveStringLiteralDfa9_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(7, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0); + return 9; + } + switch(curChar) + { + case 98: + return jjMoveStringLiteralDfa10_0(active0, 0x40000L); + case 99: + return jjMoveStringLiteralDfa10_0(active0, 0x10000L); + case 101: + return jjMoveStringLiteralDfa10_0(active0, 0xa0000L); + case 105: + return jjMoveStringLiteralDfa10_0(active0, 0x8000L); + case 108: + return jjMoveStringLiteralDfa10_0(active0, 0x100000L); + case 110: + return jjMoveStringLiteralDfa10_0(active0, 0x1000L); + default : + break; + } + return jjStartNfa_0(8, active0); +} +private int jjMoveStringLiteralDfa10_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(8, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0); + return 10; + } + switch(curChar) + { + case 58: + if ((active0 & 0x1000L) != 0L) + return jjStopAtPos(10, 12); + break; + case 95: + return jjMoveStringLiteralDfa11_0(active0, 0x180000L); + case 101: + return jjMoveStringLiteralDfa11_0(active0, 0x40000L); + case 102: + return jjMoveStringLiteralDfa11_0(active0, 0x20000L); + case 107: + return jjMoveStringLiteralDfa11_0(active0, 0x10000L); + case 111: + return jjMoveStringLiteralDfa11_0(active0, 0x8000L); + default : + break; + } + return jjStartNfa_0(9, active0); +} +private int jjMoveStringLiteralDfa11_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(9, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0); + return 11; + } + switch(curChar) + { + case 58: + if ((active0 & 0x10000L) != 0L) + return jjStopAtPos(11, 16); + break; + case 99: + return jjMoveStringLiteralDfa12_0(active0, 0x180000L); + case 102: + return jjMoveStringLiteralDfa12_0(active0, 0x40000L); + case 105: + return jjMoveStringLiteralDfa12_0(active0, 0x20000L); + case 110: + return jjMoveStringLiteralDfa12_0(active0, 0x8000L); + default : + break; + } + return jjStartNfa_0(10, active0); +} +private int jjMoveStringLiteralDfa12_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(10, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(11, active0); + return 12; + } + switch(curChar) + { + case 58: + if ((active0 & 0x8000L) != 0L) + return jjStopAtPos(12, 15); + break; + case 108: + return jjMoveStringLiteralDfa13_0(active0, 0x80000L); + case 110: + return jjMoveStringLiteralDfa13_0(active0, 0x20000L); + case 111: + return jjMoveStringLiteralDfa13_0(active0, 0x140000L); + default : + break; + } + return jjStartNfa_0(11, active0); +} +private int jjMoveStringLiteralDfa13_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(11, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(12, active0); + return 13; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa14_0(active0, 0x20000L); + case 109: + return jjMoveStringLiteralDfa14_0(active0, 0x100000L); + case 114: + return jjMoveStringLiteralDfa14_0(active0, 0x40000L); + case 117: + return jjMoveStringLiteralDfa14_0(active0, 0x80000L); + default : + break; + } + return jjStartNfa_0(12, active0); +} +private int jjMoveStringLiteralDfa14_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(12, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(13, active0); + return 14; + } + switch(curChar) + { + case 58: + if ((active0 & 0x20000L) != 0L) + return jjStopAtPos(14, 17); + break; + case 101: + return jjMoveStringLiteralDfa15_0(active0, 0x40000L); + case 109: + return jjMoveStringLiteralDfa15_0(active0, 0x100000L); + case 115: + return jjMoveStringLiteralDfa15_0(active0, 0x80000L); + default : + break; + } + return jjStartNfa_0(13, active0); +} +private int jjMoveStringLiteralDfa15_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(13, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(14, active0); + return 15; + } + switch(curChar) + { + case 58: + if ((active0 & 0x40000L) != 0L) + return jjStopAtPos(15, 18); + break; + case 105: + return jjMoveStringLiteralDfa16_0(active0, 0x100000L); + case 116: + return jjMoveStringLiteralDfa16_0(active0, 0x80000L); + default : + break; + } + return jjStartNfa_0(14, active0); +} +private int jjMoveStringLiteralDfa16_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(14, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(15, active0); + return 16; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa17_0(active0, 0x80000L); + case 116: + return jjMoveStringLiteralDfa17_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(15, active0); +} +private int jjMoveStringLiteralDfa17_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(15, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(16, active0); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_0(active0, 0x100000L); + case 114: + return jjMoveStringLiteralDfa18_0(active0, 0x80000L); + default : + break; + } + return jjStartNfa_0(16, active0); +} +private int jjMoveStringLiteralDfa18_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(16, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(17, active0); + return 18; + } + switch(curChar) + { + case 58: + if ((active0 & 0x80000L) != 0L) + return jjStopAtPos(18, 19); + break; + case 112: + return jjMoveStringLiteralDfa19_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(17, active0); +} +private int jjMoveStringLiteralDfa19_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(17, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(18, active0); + return 19; + } + switch(curChar) + { + case 111: + return jjMoveStringLiteralDfa20_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(18, active0); +} +private int jjMoveStringLiteralDfa20_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(18, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(19, active0); + return 20; + } + switch(curChar) + { + case 105: + return jjMoveStringLiteralDfa21_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(19, active0); +} +private int jjMoveStringLiteralDfa21_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(19, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(20, active0); + return 21; + } + switch(curChar) + { + case 110: + return jjMoveStringLiteralDfa22_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(20, active0); +} +private int jjMoveStringLiteralDfa22_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(20, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(21, active0); + return 22; + } + switch(curChar) + { + case 116: + return jjMoveStringLiteralDfa23_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(21, active0); +} +private int jjMoveStringLiteralDfa23_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(21, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(22, active0); + return 23; + } + switch(curChar) + { + case 58: + if ((active0 & 0x100000L) != 0L) + return jjStopAtPos(23, 20); + break; + default : + break; + } + return jjStartNfa_0(22, active0); +} private int jjStartNfaWithStates_0(int pos, int kind, int state) { jjmatchedKind = kind; @@ -226,7 +708,7 @@ private int jjMoveNfa_0(int startState, int curPos) break; case 5: if ((0x2400L & l) != 0L) - kind = 10; + kind = 6; break; default : break; } @@ -296,8 +778,13 @@ private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, lo /** Token literal values. */ public static final String[] jjstrLiteralImages = { -"", null, null, null, null, null, "\57\52\52", "\52\57", -"\100\102\145\147\151\156", "\100\105\156\144", null, }; +"", null, null, null, null, null, null, "\57\52\52", "\52\57", +"\100\102\145\147\151\156", "\100\105\156\144", "\100\111\104\72", +"\100\103\157\156\144\151\164\151\157\156\72", "\100\103\150\145\143\153\72", "\100\101\143\164\151\157\156\72", +"\100\120\157\163\164\137\141\143\164\151\157\156\72", "\100\120\157\163\164\137\143\150\145\143\153\72", +"\100\107\154\157\142\141\154\137\144\145\146\151\156\145\72", "\100\110\141\160\160\145\156\163\137\142\145\146\157\162\145\72", +"\100\111\156\164\145\162\146\141\143\145\137\143\154\165\163\164\145\162\72", +"\100\120\157\164\145\156\164\151\141\154\137\143\157\155\155\151\164\137\160\157\151\156\164\72", }; protected Token jjFillToken() { final Token t; @@ -475,7 +962,7 @@ public static final String[] lexStateNames = { "DEFAULT", }; static final long[] jjtoToken = { - 0x7e1L, + 0x1fffe1L, }; static final long[] jjtoSkip = { 0x1eL,