Home Explore Help
Register Sign In
Apq
/
CMake
mirror of https://github.com/Kitware/CMake.git
1
0
Fork 0
Files Issues 0 Wiki
Browse Source

COMP: Remove more warnings/errors

Andy Cedilnik 21 years ago
parent
562b0b820f
commit
759ef8d424
5 changed files with 1021 additions and 1015 deletions
Split View Show Diff Stats
  1. 103 103
      Source/cmDependsJavaLexer.cxx
  2. 105 105
      Source/cmDependsJavaLexer.in.l
  3. 323 317
      Source/cmDependsJavaParser.cxx
  4. 284 284
      Source/cmDependsJavaParser.y
  5. 206 206
      Source/cmDependsJavaParserTokens.h

+ 103 - 103
Source/cmDependsJavaLexer.cxx
View File 

@@ -1039,7 +1039,7 @@ YY_RULE_SETUP
 
 case 5:
 
 YY_RULE_SETUP
 
 #line 94 "cmDependsJavaLexer.in.l"
 
-{ BEGIN(INITIAL); return STRINGLITERAL; }
 
+{ BEGIN(INITIAL); return jp_STRINGLITERAL; }
 
   YY_BREAK
 
 case 6:
 
 YY_RULE_SETUP
 
@@ -1049,510 +1049,510 @@ YY_RULE_SETUP
 
 case 7:
 
 YY_RULE_SETUP
 
 #line 97 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return ABSTRACT; }
 
+{ KEYWORD; return jp_ABSTRACT; }
 
   YY_BREAK
 
 case 8:
 
 YY_RULE_SETUP
 
 #line 98 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return ASSERT; }
 
+{ KEYWORD; return jp_ASSERT; }
 
   YY_BREAK
 
 case 9:
 
 YY_RULE_SETUP
 
 #line 99 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return BOOLEAN_TYPE; }
 
+{ KEYWORD; return jp_BOOLEAN_TYPE; }
 
   YY_BREAK
 
 case 10:
 
 YY_RULE_SETUP
 
 #line 100 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return BREAK; }
 
+{ KEYWORD; return jp_BREAK; }
 
   YY_BREAK
 
 case 11:
 
 YY_RULE_SETUP
 
 #line 101 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return BYTE_TYPE; }
 
+{ KEYWORD; return jp_BYTE_TYPE; }
 
   YY_BREAK
 
 case 12:
 
 YY_RULE_SETUP
 
 #line 102 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return CASE; }
 
+{ KEYWORD; return jp_CASE; }
 
   YY_BREAK
 
 case 13:
 
 YY_RULE_SETUP
 
 #line 103 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return CATCH; }
 
+{ KEYWORD; return jp_CATCH; }
 
   YY_BREAK
 
 case 14:
 
 YY_RULE_SETUP
 
 #line 104 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return CHAR_TYPE; }
 
+{ KEYWORD; return jp_CHAR_TYPE; }
 
   YY_BREAK
 
 case 15:
 
 YY_RULE_SETUP
 
 #line 105 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return CLASS; }
 
+{ KEYWORD; return jp_CLASS; }
 
   YY_BREAK
 
 case 16:
 
 YY_RULE_SETUP
 
 #line 106 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return CONTINUE; }
 
+{ KEYWORD; return jp_CONTINUE; }
 
   YY_BREAK
 
 case 17:
 
 YY_RULE_SETUP
 
 #line 107 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return DEFAULT; }
 
+{ KEYWORD; return jp_DEFAULT; }
 
   YY_BREAK
 
 case 18:
 
 YY_RULE_SETUP
 
 #line 108 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return DO; }
 
+{ KEYWORD; return jp_DO; }
 
   YY_BREAK
 
 case 19:
 
 YY_RULE_SETUP
 
 #line 109 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return DOUBLE_TYPE; }
 
+{ KEYWORD; return jp_DOUBLE_TYPE; }
 
   YY_BREAK
 
 case 20:
 
 YY_RULE_SETUP
 
 #line 110 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return ELSE; }
 
+{ KEYWORD; return jp_ELSE; }
 
   YY_BREAK
 
 case 21:
 
 YY_RULE_SETUP
 
 #line 111 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return EXTENDS; }
 
+{ KEYWORD; return jp_EXTENDS; }
 
   YY_BREAK
 
 case 22:
 
 YY_RULE_SETUP
 
 #line 112 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return FINAL; }
 
+{ KEYWORD; return jp_FINAL; }
 
   YY_BREAK
 
 case 23:
 
 YY_RULE_SETUP
 
 #line 113 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return FINALLY; }
 
+{ KEYWORD; return jp_FINALLY; }
 
   YY_BREAK
 
 case 24:
 
 YY_RULE_SETUP
 
 #line 114 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return FLOAT_TYPE; }
 
+{ KEYWORD; return jp_FLOAT_TYPE; }
 
   YY_BREAK
 
 case 25:
 
 YY_RULE_SETUP
 
 #line 115 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return FOR; }
 
+{ KEYWORD; return jp_FOR; }
 
   YY_BREAK
 
 case 26:
 
 YY_RULE_SETUP
 
 #line 116 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return IF; }
 
+{ KEYWORD; return jp_IF; }
 
   YY_BREAK
 
 case 27:
 
 YY_RULE_SETUP
 
 #line 117 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return IMPLEMENTS; }
 
+{ KEYWORD; return jp_IMPLEMENTS; }
 
   YY_BREAK
 
 case 28:
 
 YY_RULE_SETUP
 
 #line 118 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return IMPORT; }
 
+{ KEYWORD; return jp_IMPORT; }
 
   YY_BREAK
 
 case 29:
 
 YY_RULE_SETUP
 
 #line 119 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return INSTANCEOF; }
 
+{ KEYWORD; return jp_INSTANCEOF; }
 
   YY_BREAK
 
 case 30:
 
 YY_RULE_SETUP
 
 #line 120 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return INT_TYPE; }
 
+{ KEYWORD; return jp_INT_TYPE; }
 
   YY_BREAK
 
 case 31:
 
 YY_RULE_SETUP
 
 #line 121 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return INTERFACE; }
 
+{ KEYWORD; return jp_INTERFACE; }
 
   YY_BREAK
 
 case 32:
 
 YY_RULE_SETUP
 
 #line 122 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return LONG_TYPE; }
 
+{ KEYWORD; return jp_LONG_TYPE; }
 
   YY_BREAK
 
 case 33:
 
 YY_RULE_SETUP
 
 #line 123 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return NATIVE; }
 
+{ KEYWORD; return jp_NATIVE; }
 
   YY_BREAK
 
 case 34:
 
 YY_RULE_SETUP
 
 #line 124 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return NEW; }
 
+{ KEYWORD; return jp_NEW; }
 
   YY_BREAK
 
 case 35:
 
 YY_RULE_SETUP
 
 #line 125 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return PACKAGE; }
 
+{ KEYWORD; return jp_PACKAGE; }
 
   YY_BREAK
 
 case 36:
 
 YY_RULE_SETUP
 
 #line 126 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return PRIVATE; }
 
+{ KEYWORD; return jp_PRIVATE; }
 
   YY_BREAK
 
 case 37:
 
 YY_RULE_SETUP
 
 #line 127 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return PROTECTED; }
 
+{ KEYWORD; return jp_PROTECTED; }
 
   YY_BREAK
 
 case 38:
 
 YY_RULE_SETUP
 
 #line 128 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return PUBLIC; }
 
+{ KEYWORD; return jp_PUBLIC; }
 
   YY_BREAK
 
 case 39:
 
 YY_RULE_SETUP
 
 #line 129 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return RETURN; }
 
+{ KEYWORD; return jp_RETURN; }
 
   YY_BREAK
 
 case 40:
 
 YY_RULE_SETUP
 
 #line 130 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return SHORT_TYPE; }
 
+{ KEYWORD; return jp_SHORT_TYPE; }
 
   YY_BREAK
 
 case 41:
 
 YY_RULE_SETUP
 
 #line 131 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return STATIC; }
 
+{ KEYWORD; return jp_STATIC; }
 
   YY_BREAK
 
 case 42:
 
 YY_RULE_SETUP
 
 #line 132 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return STRICTFP; }
 
+{ KEYWORD; return jp_STRICTFP; }
 
   YY_BREAK
 
 case 43:
 
 YY_RULE_SETUP
 
 #line 133 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return SUPER; }
 
+{ KEYWORD; return jp_SUPER; }
 
   YY_BREAK
 
 case 44:
 
 YY_RULE_SETUP
 
 #line 134 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return SWITCH; }
 
+{ KEYWORD; return jp_SWITCH; }
 
   YY_BREAK
 
 case 45:
 
 YY_RULE_SETUP
 
 #line 135 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return SYNCHRONIZED; }
 
+{ KEYWORD; return jp_SYNCHRONIZED; }
 
   YY_BREAK
 
 case 46:
 
 YY_RULE_SETUP
 
 #line 136 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return THIS; }
 
+{ KEYWORD; return jp_THIS; }
 
   YY_BREAK
 
 case 47:
 
 YY_RULE_SETUP
 
 #line 137 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return THROW; }
 
+{ KEYWORD; return jp_THROW; }
 
   YY_BREAK
 
 case 48:
 
 YY_RULE_SETUP
 
 #line 138 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return THROWS; }
 
+{ KEYWORD; return jp_THROWS; }
 
   YY_BREAK
 
 case 49:
 
 YY_RULE_SETUP
 
 #line 139 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return TRANSIENT; }
 
+{ KEYWORD; return jp_TRANSIENT; }
 
   YY_BREAK
 
 case 50:
 
 YY_RULE_SETUP
 
 #line 140 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return TRY; }
 
+{ KEYWORD; return jp_TRY; }
 
   YY_BREAK
 
 case 51:
 
 YY_RULE_SETUP
 
 #line 141 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return VOID; }
 
+{ KEYWORD; return jp_VOID; }
 
   YY_BREAK
 
 case 52:
 
 YY_RULE_SETUP
 
 #line 142 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return VOLATILE; }
 
+{ KEYWORD; return jp_VOLATILE; }
 
   YY_BREAK
 
 case 53:
 
 YY_RULE_SETUP
 
 #line 143 "cmDependsJavaLexer.in.l"
 
-{ KEYWORD; return WHILE; }
 
+{ KEYWORD; return jp_WHILE; }
 
   YY_BREAK
 
 case 54:
 
 YY_RULE_SETUP
 
 #line 145 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return BOOLEANLITERAL; }
 
+{ PRIMITIVE; return jp_BOOLEANLITERAL; }
 
   YY_BREAK
 
 case 55:
 
 /* rule 55 can match eol */
 
 YY_RULE_SETUP
 
 #line 146 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return CHARACTERLITERAL; }
 
+{ PRIMITIVE; return jp_CHARACTERLITERAL; }
 
   YY_BREAK
 
 case 56:
 
 YY_RULE_SETUP
 
 #line 147 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return DECIMALINTEGERLITERAL; }
 
+{ PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
 
   YY_BREAK
 
 case 57:
 
 YY_RULE_SETUP
 
 #line 148 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return FLOATINGPOINTLITERAL; }
 
+{ PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
 
   YY_BREAK
 
 case 58:
 
 YY_RULE_SETUP
 
 #line 149 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return HEXINTEGERLITERAL; }
 
+{ PRIMITIVE; return jp_HEXINTEGERLITERAL; }
 
   YY_BREAK
 
 case 59:
 
 YY_RULE_SETUP
 
 #line 150 "cmDependsJavaLexer.in.l"
 
-{ PRIMITIVE; return NULLLITERAL; }
 
+{ PRIMITIVE; return jp_NULLLITERAL; }
 
   YY_BREAK
 
 case 60:
 
 YY_RULE_SETUP
 
 #line 152 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return AND; }
 
+{ SYMBOL; return jp_AND; }
 
   YY_BREAK
 
 case 61:
 
 YY_RULE_SETUP
 
 #line 153 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return ANDAND; }
 
+{ SYMBOL; return jp_ANDAND; }
 
   YY_BREAK
 
 case 62:
 
 YY_RULE_SETUP
 
 #line 154 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return ANDEQUALS; }
 
+{ SYMBOL; return jp_ANDEQUALS; }
 
   YY_BREAK
 
 case 63:
 
 YY_RULE_SETUP
 
 #line 155 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return BRACKETEND; }
 
+{ SYMBOL; return jp_BRACKETEND; }
 
   YY_BREAK
 
 case 64:
 
 YY_RULE_SETUP
 
 #line 156 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return BRACKETSTART; }
 
+{ SYMBOL; return jp_BRACKETSTART; }
 
   YY_BREAK
 
 case 65:
 
 YY_RULE_SETUP
 
 #line 157 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return CARROT; }
 
+{ SYMBOL; return jp_CARROT; }
 
   YY_BREAK
 
 case 66:
 
 YY_RULE_SETUP
 
 #line 158 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return CARROTEQUALS; }
 
+{ SYMBOL; return jp_CARROTEQUALS; }
 
   YY_BREAK
 
 case 67:
 
 YY_RULE_SETUP
 
 #line 159 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return COLON; }
 
+{ SYMBOL; return jp_COLON; }
 
   YY_BREAK
 
 case 68:
 
 YY_RULE_SETUP
 
 #line 160 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return COMMA; }
 
+{ SYMBOL; return jp_COMMA; }
 
   YY_BREAK
 
 case 69:
 
 YY_RULE_SETUP
 
 #line 161 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return CURLYEND; }
 
+{ SYMBOL; return jp_CURLYEND; }
 
   YY_BREAK
 
 case 70:
 
 YY_RULE_SETUP
 
 #line 162 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return CURLYSTART; }
 
+{ SYMBOL; return jp_CURLYSTART; }
 
   YY_BREAK
 
 case 71:
 
 YY_RULE_SETUP
 
 #line 163 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return DIVIDE; }
 
+{ SYMBOL; return jp_DIVIDE; }
 
   YY_BREAK
 
 case 72:
 
 YY_RULE_SETUP
 
 #line 164 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return DIVIDEEQUALS; }
 
+{ SYMBOL; return jp_DIVIDEEQUALS; }
 
   YY_BREAK
 
 case 73:
 
 YY_RULE_SETUP
 
 #line 165 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return DOLLAR; }
 
+{ SYMBOL; return jp_DOLLAR; }
 
   YY_BREAK
 
 case 74:
 
 YY_RULE_SETUP
 
 #line 166 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return DOT; }
 
+{ SYMBOL; return jp_DOT; }
 
   YY_BREAK
 
 case 75:
 
 YY_RULE_SETUP
 
 #line 167 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return EQUALS; }
 
+{ SYMBOL; return jp_EQUALS; }
 
   YY_BREAK
 
 case 76:
 
 YY_RULE_SETUP
 
 #line 168 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return EQUALSEQUALS; }
 
+{ SYMBOL; return jp_EQUALSEQUALS; }
 
   YY_BREAK
 
 case 77:
 
 YY_RULE_SETUP
 
 #line 169 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return EXCLAMATION; }
 
+{ SYMBOL; return jp_EXCLAMATION; }
 
   YY_BREAK
 
 case 78:
 
 YY_RULE_SETUP
 
 #line 170 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return EXCLAMATIONEQUALS; }
 
+{ SYMBOL; return jp_EXCLAMATIONEQUALS; }
 
   YY_BREAK
 
 case 79:
 
 YY_RULE_SETUP
 
 #line 171 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GREATER; }
 
+{ SYMBOL; return jp_GREATER; }
 
   YY_BREAK
 
 case 80:
 
 YY_RULE_SETUP
 
 #line 172 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GTEQUALS; }
 
+{ SYMBOL; return jp_GTEQUALS; }
 
   YY_BREAK
 
 case 81:
 
 YY_RULE_SETUP
 
 #line 173 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GTGT; }
 
+{ SYMBOL; return jp_GTGT; }
 
   YY_BREAK
 
 case 82:
 
 YY_RULE_SETUP
 
 #line 174 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GTGTEQUALS; }
 
+{ SYMBOL; return jp_GTGTEQUALS; }
 
   YY_BREAK
 
 case 83:
 
 YY_RULE_SETUP
 
 #line 175 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GTGTGT; }
 
+{ SYMBOL; return jp_GTGTGT; }
 
   YY_BREAK
 
 case 84:
 
 YY_RULE_SETUP
 
 #line 176 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return GTGTGTEQUALS; }
 
+{ SYMBOL; return jp_GTGTGTEQUALS; }
 
   YY_BREAK
 
 case 85:
 
 YY_RULE_SETUP
 
 #line 177 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return LESLESEQUALS; }
 
+{ SYMBOL; return jp_LESLESEQUALS; }
 
   YY_BREAK
 
 case 86:
 
 YY_RULE_SETUP
 
 #line 178 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return LESSTHAN; }
 
+{ SYMBOL; return jp_LESSTHAN; }
 
   YY_BREAK
 
 case 87:
 
 YY_RULE_SETUP
 
 #line 179 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return LTEQUALS; }
 
+{ SYMBOL; return jp_LTEQUALS; }
 
   YY_BREAK
 
 case 88:
 
 YY_RULE_SETUP
 
 #line 180 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return LTLT; }
 
+{ SYMBOL; return jp_LTLT; }
 
   YY_BREAK
 
 case 89:
 
 YY_RULE_SETUP
 
 #line 181 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return MINUS; }
 
+{ SYMBOL; return jp_MINUS; }
 
   YY_BREAK
 
 case 90:
 
 YY_RULE_SETUP
 
 #line 182 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return MINUSEQUALS; }
 
+{ SYMBOL; return jp_MINUSEQUALS; }
 
   YY_BREAK
 
 case 91:
 
 YY_RULE_SETUP
 
 #line 183 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return MINUSMINUS; }
 
+{ SYMBOL; return jp_MINUSMINUS; }
 
   YY_BREAK
 
 case 92:
 
 YY_RULE_SETUP
 
 #line 184 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PAREEND; }
 
+{ SYMBOL; return jp_PAREEND; }
 
   YY_BREAK
 
 case 93:
 
 YY_RULE_SETUP
 
 #line 185 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PARESTART; }
 
+{ SYMBOL; return jp_PARESTART; }
 
   YY_BREAK
 
 case 94:
 
 YY_RULE_SETUP
 
 #line 186 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PERCENT; }
 
+{ SYMBOL; return jp_PERCENT; }
 
   YY_BREAK
 
 case 95:
 
 YY_RULE_SETUP
 
 #line 187 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PERCENTEQUALS; }
 
+{ SYMBOL; return jp_PERCENTEQUALS; }
 
   YY_BREAK
 
 case 96:
 
 YY_RULE_SETUP
 
 #line 188 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PIPE; }
 
+{ SYMBOL; return jp_PIPE; }
 
   YY_BREAK
 
 case 97:
 
 YY_RULE_SETUP
 
 #line 189 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PIPEEQUALS; }
 
+{ SYMBOL; return jp_PIPEEQUALS; }
 
   YY_BREAK
 
 case 98:
 
 YY_RULE_SETUP
 
 #line 190 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PIPEPIPE; }
 
+{ SYMBOL; return jp_PIPEPIPE; }
 
   YY_BREAK
 
 case 99:
 
 YY_RULE_SETUP
 
 #line 191 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PLUS; }
 
+{ SYMBOL; return jp_PLUS; }
 
   YY_BREAK
 
 case 100:
 
 YY_RULE_SETUP
 
 #line 192 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PLUSEQUALS; }
 
+{ SYMBOL; return jp_PLUSEQUALS; }
 
   YY_BREAK
 
 case 101:
 
 YY_RULE_SETUP
 
 #line 193 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return PLUSPLUS; }
 
+{ SYMBOL; return jp_PLUSPLUS; }
 
   YY_BREAK
 
 case 102:
 
 YY_RULE_SETUP
 
 #line 194 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return QUESTION; }
 
+{ SYMBOL; return jp_QUESTION; }
 
   YY_BREAK
 
 case 103:
 
 YY_RULE_SETUP
 
 #line 195 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return SEMICOL; }
 
+{ SYMBOL; return jp_SEMICOL; }
 
   YY_BREAK
 
 case 104:
 
 YY_RULE_SETUP
 
 #line 196 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return TILDE; }
 
+{ SYMBOL; return jp_TILDE; }
 
   YY_BREAK
 
 case 105:
 
 YY_RULE_SETUP
 
 #line 197 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return TIMES; }
 
+{ SYMBOL; return jp_TIMES; }
 
   YY_BREAK
 
 case 106:
 
 YY_RULE_SETUP
 
 #line 198 "cmDependsJavaLexer.in.l"
 
-{ SYMBOL; return TIMESEQUALS; }
 
+{ SYMBOL; return jp_TIMESEQUALS; }
 
   YY_BREAK
 
 case 107:
 
 YY_RULE_SETUP
 
 #line 200 "cmDependsJavaLexer.in.l"
 
 { 
   yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  return NAME; 
+  return jp_NAME; 
 }
 
   YY_BREAK
 
 case 108:
 
@@ -1574,7 +1574,7 @@ YY_RULE_SETUP
 
   std::cerr << "Unknown character: " << yytext[0] 
     << " (" << (int)yytext[0] << ")" << std::endl; 
   yyextra->Error("Unknown character"); 
-  return ERROR; 
+  return jp_ERROR; 
 }
 
   YY_BREAK
 
 case 111:

+ 105 - 105
Source/cmDependsJavaLexer.in.l
View File 

@@ -91,115 +91,115 @@ Modify cmDependsJavaLexer.h:
 
 <comment>.|\n {}
 
 
 \" { BEGIN(string); }
 
-<string>\" { BEGIN(INITIAL); return STRINGLITERAL; }
 
+<string>\" { BEGIN(INITIAL); return jp_STRINGLITERAL; }
 
 <string>. {}
 
 
-abstract { KEYWORD; return ABSTRACT; }
 
-assert { KEYWORD; return ASSERT; }
 
-boolean { KEYWORD; return BOOLEAN_TYPE; }
 
-break { KEYWORD; return BREAK; }
 
-byte { KEYWORD; return BYTE_TYPE; }
 
-case { KEYWORD; return CASE; }
 
-catch { KEYWORD; return CATCH; }
 
-char { KEYWORD; return CHAR_TYPE; }
 
-class { KEYWORD; return CLASS; }
 
-continue { KEYWORD; return CONTINUE; }
 
-default { KEYWORD; return DEFAULT; }
 
-do { KEYWORD; return DO; }
 
-double { KEYWORD; return DOUBLE_TYPE; }
 
-else { KEYWORD; return ELSE; }
 
-extends { KEYWORD; return EXTENDS; }
 
-final { KEYWORD; return FINAL; }
 
-finally { KEYWORD; return FINALLY; }
 
-float { KEYWORD; return FLOAT_TYPE; }
 
-for { KEYWORD; return FOR; }
 
-if { KEYWORD; return IF; }
 
-implements { KEYWORD; return IMPLEMENTS; }
 
-import { KEYWORD; return IMPORT; }
 
-instanceof { KEYWORD; return INSTANCEOF; }
 
-int { KEYWORD; return INT_TYPE; }
 
-interface { KEYWORD; return INTERFACE; }
 
-long { KEYWORD; return LONG_TYPE; }
 
-native { KEYWORD; return NATIVE; }
 
-new { KEYWORD; return NEW; }
 
-package { KEYWORD; return PACKAGE; }
 
-private { KEYWORD; return PRIVATE; }
 
-protected { KEYWORD; return PROTECTED; }
 
-public { KEYWORD; return PUBLIC; }
 
-return { KEYWORD; return RETURN; }
 
-short { KEYWORD; return SHORT_TYPE; }
 
-static { KEYWORD; return STATIC; }
 
-strictfp { KEYWORD; return STRICTFP; }
 
-super { KEYWORD; return SUPER; }
 
-switch { KEYWORD; return SWITCH; }
 
-synchronized { KEYWORD; return SYNCHRONIZED; }
 
-this { KEYWORD; return THIS; }
 
-throw { KEYWORD; return THROW; }
 
-throws { KEYWORD; return THROWS; }
 
-transient { KEYWORD; return TRANSIENT; }
 
-try { KEYWORD; return TRY; }
 
-void { KEYWORD; return VOID; }
 
-volatile { KEYWORD; return VOLATILE; }
 
-while { KEYWORD; return WHILE; }
 
-
 
-(true|false) { PRIMITIVE; return BOOLEANLITERAL; }
 
-\'([^\\]|\\.|\\u[0-9a-fA-F]*|\\[0-7]*)\' { PRIMITIVE; return CHARACTERLITERAL; }
 
-(0|[0-9]+)[lL]? { PRIMITIVE; return DECIMALINTEGERLITERAL; }
 
-([0-9]+\.[0-9]*|\.[0-9]+|[0-9]+)([eE][+\-]?[0-9]+)?[fFdD]? { PRIMITIVE; return FLOATINGPOINTLITERAL; }
 
-0[xX][0-9a-fA-F]+[lL]? { PRIMITIVE; return HEXINTEGERLITERAL; }
 
-null { PRIMITIVE; return NULLLITERAL; }
 
-
 
-"&" { SYMBOL; return AND; }
 
-"&&" { SYMBOL; return ANDAND; }
 
-"&=" { SYMBOL; return ANDEQUALS; }
 
-"\]" { SYMBOL; return BRACKETEND; }
 
-"\[" { SYMBOL; return BRACKETSTART; }
 
-"\^" { SYMBOL; return CARROT; }
 
-"\^=" { SYMBOL; return CARROTEQUALS; }
 
-":" { SYMBOL; return COLON; }
 
-"," { SYMBOL; return COMMA; }
 
-"}" { SYMBOL; return CURLYEND; }
 
-"{" { SYMBOL; return CURLYSTART; }
 
-"/" { SYMBOL; return DIVIDE; }
 
-"/=" { SYMBOL; return DIVIDEEQUALS; }
 
-"\$" { SYMBOL; return DOLLAR; }
 
-"\." { SYMBOL; return DOT; }
 
-"=" { SYMBOL; return EQUALS; }
 
-"==" { SYMBOL; return EQUALSEQUALS; }
 
-"\!" { SYMBOL; return EXCLAMATION; }
 
-"\!=" { SYMBOL; return EXCLAMATIONEQUALS; }
 
-">" { SYMBOL; return GREATER; }
 
-">=" { SYMBOL; return GTEQUALS; }
 
-">>" { SYMBOL; return GTGT; }
 
-">>=" { SYMBOL; return GTGTEQUALS; }
 
-">>>" { SYMBOL; return GTGTGT; }
 
-">>>=" { SYMBOL; return GTGTGTEQUALS; }
 
-"<<=" { SYMBOL; return LESLESEQUALS; }
 
-"<" { SYMBOL; return LESSTHAN; }
 
-"<=" { SYMBOL; return LTEQUALS; }
 
-"<<" { SYMBOL; return LTLT; }
 
-"-" { SYMBOL; return MINUS; }
 
-"-=" { SYMBOL; return MINUSEQUALS; }
 
-"--" { SYMBOL; return MINUSMINUS; }
 
-"\)" { SYMBOL; return PAREEND; }
 
-"\(" { SYMBOL; return PARESTART; }
 
-"%" { SYMBOL; return PERCENT; }
 
-"%=" { SYMBOL; return PERCENTEQUALS; }
 
-"\|" { SYMBOL; return PIPE; }
 
-"\|=" { SYMBOL; return PIPEEQUALS; }
 
-"\|\|" { SYMBOL; return PIPEPIPE; }
 
-"\+" { SYMBOL; return PLUS; }
 
-"\+=" { SYMBOL; return PLUSEQUALS; }
 
-"\+\+" { SYMBOL; return PLUSPLUS; }
 
-"\?" { SYMBOL; return QUESTION; }
 
-";" { SYMBOL; return SEMICOL; }
 
-"\~" { SYMBOL; return TILDE; }
 
-"\*" { SYMBOL; return TIMES; }
 
-"\*=" { SYMBOL; return TIMESEQUALS; }
 
+abstract { KEYWORD; return jp_ABSTRACT; }
 
+assert { KEYWORD; return jp_ASSERT; }
 
+boolean { KEYWORD; return jp_BOOLEAN_TYPE; }
 
+break { KEYWORD; return jp_BREAK; }
 
+byte { KEYWORD; return jp_BYTE_TYPE; }
 
+case { KEYWORD; return jp_CASE; }
 
+catch { KEYWORD; return jp_CATCH; }
 
+char { KEYWORD; return jp_CHAR_TYPE; }
 
+class { KEYWORD; return jp_CLASS; }
 
+continue { KEYWORD; return jp_CONTINUE; }
 
+default { KEYWORD; return jp_DEFAULT; }
 
+do { KEYWORD; return jp_DO; }
 
+double { KEYWORD; return jp_DOUBLE_TYPE; }
 
+else { KEYWORD; return jp_ELSE; }
 
+extends { KEYWORD; return jp_EXTENDS; }
 
+final { KEYWORD; return jp_FINAL; }
 
+finally { KEYWORD; return jp_FINALLY; }
 
+float { KEYWORD; return jp_FLOAT_TYPE; }
 
+for { KEYWORD; return jp_FOR; }
 
+if { KEYWORD; return jp_IF; }
 
+implements { KEYWORD; return jp_IMPLEMENTS; }
 
+import { KEYWORD; return jp_IMPORT; }
 
+instanceof { KEYWORD; return jp_INSTANCEOF; }
 
+int { KEYWORD; return jp_INT_TYPE; }
 
+interface { KEYWORD; return jp_INTERFACE; }
 
+long { KEYWORD; return jp_LONG_TYPE; }
 
+native { KEYWORD; return jp_NATIVE; }
 
+new { KEYWORD; return jp_NEW; }
 
+package { KEYWORD; return jp_PACKAGE; }
 
+private { KEYWORD; return jp_PRIVATE; }
 
+protected { KEYWORD; return jp_PROTECTED; }
 
+public { KEYWORD; return jp_PUBLIC; }
 
+return { KEYWORD; return jp_RETURN; }
 
+short { KEYWORD; return jp_SHORT_TYPE; }
 
+static { KEYWORD; return jp_STATIC; }
 
+strictfp { KEYWORD; return jp_STRICTFP; }
 
+super { KEYWORD; return jp_SUPER; }
 
+switch { KEYWORD; return jp_SWITCH; }
 
+synchronized { KEYWORD; return jp_SYNCHRONIZED; }
 
+this { KEYWORD; return jp_THIS; }
 
+throw { KEYWORD; return jp_THROW; }
 
+throws { KEYWORD; return jp_THROWS; }
 
+transient { KEYWORD; return jp_TRANSIENT; }
 
+try { KEYWORD; return jp_TRY; }
 
+void { KEYWORD; return jp_VOID; }
 
+volatile { KEYWORD; return jp_VOLATILE; }
 
+while { KEYWORD; return jp_WHILE; }
 
+
 
+(true|false) { PRIMITIVE; return jp_BOOLEANLITERAL; }
 
+\'([^\\]|\\.|\\u[0-9a-fA-F]*|\\[0-7]*)\' { PRIMITIVE; return jp_CHARACTERLITERAL; }
 
+(0|[0-9]+)[lL]? { PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
 
+([0-9]+\.[0-9]*|\.[0-9]+|[0-9]+)([eE][+\-]?[0-9]+)?[fFdD]? { PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
 
+0[xX][0-9a-fA-F]+[lL]? { PRIMITIVE; return jp_HEXINTEGERLITERAL; }
 
+null { PRIMITIVE; return jp_NULLLITERAL; }
 
+
 
+"&" { SYMBOL; return jp_AND; }
 
+"&&" { SYMBOL; return jp_ANDAND; }
 
+"&=" { SYMBOL; return jp_ANDEQUALS; }
 
+"\]" { SYMBOL; return jp_BRACKETEND; }
 
+"\[" { SYMBOL; return jp_BRACKETSTART; }
 
+"\^" { SYMBOL; return jp_CARROT; }
 
+"\^=" { SYMBOL; return jp_CARROTEQUALS; }
 
+":" { SYMBOL; return jp_COLON; }
 
+"," { SYMBOL; return jp_COMMA; }
 
+"}" { SYMBOL; return jp_CURLYEND; }
 
+"{" { SYMBOL; return jp_CURLYSTART; }
 
+"/" { SYMBOL; return jp_DIVIDE; }
 
+"/=" { SYMBOL; return jp_DIVIDEEQUALS; }
 
+"\$" { SYMBOL; return jp_DOLLAR; }
 
+"\." { SYMBOL; return jp_DOT; }
 
+"=" { SYMBOL; return jp_EQUALS; }
 
+"==" { SYMBOL; return jp_EQUALSEQUALS; }
 
+"\!" { SYMBOL; return jp_EXCLAMATION; }
 
+"\!=" { SYMBOL; return jp_EXCLAMATIONEQUALS; }
 
+">" { SYMBOL; return jp_GREATER; }
 
+">=" { SYMBOL; return jp_GTEQUALS; }
 
+">>" { SYMBOL; return jp_GTGT; }
 
+">>=" { SYMBOL; return jp_GTGTEQUALS; }
 
+">>>" { SYMBOL; return jp_GTGTGT; }
 
+">>>=" { SYMBOL; return jp_GTGTGTEQUALS; }
 
+"<<=" { SYMBOL; return jp_LESLESEQUALS; }
 
+"<" { SYMBOL; return jp_LESSTHAN; }
 
+"<=" { SYMBOL; return jp_LTEQUALS; }
 
+"<<" { SYMBOL; return jp_LTLT; }
 
+"-" { SYMBOL; return jp_MINUS; }
 
+"-=" { SYMBOL; return jp_MINUSEQUALS; }
 
+"--" { SYMBOL; return jp_MINUSMINUS; }
 
+"\)" { SYMBOL; return jp_PAREEND; }
 
+"\(" { SYMBOL; return jp_PARESTART; }
 
+"%" { SYMBOL; return jp_PERCENT; }
 
+"%=" { SYMBOL; return jp_PERCENTEQUALS; }
 
+"\|" { SYMBOL; return jp_PIPE; }
 
+"\|=" { SYMBOL; return jp_PIPEEQUALS; }
 
+"\|\|" { SYMBOL; return jp_PIPEPIPE; }
 
+"\+" { SYMBOL; return jp_PLUS; }
 
+"\+=" { SYMBOL; return jp_PLUSEQUALS; }
 
+"\+\+" { SYMBOL; return jp_PLUSPLUS; }
 
+"\?" { SYMBOL; return jp_QUESTION; }
 
+";" { SYMBOL; return jp_SEMICOL; }
 
+"\~" { SYMBOL; return jp_TILDE; }
 
+"\*" { SYMBOL; return jp_TIMES; }
 
+"\*=" { SYMBOL; return jp_TIMESEQUALS; }
 
 
 [a-z_A-Z][a-z_0-9A-Z]* { 
   yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  return NAME; 
+  return jp_NAME; 
 }
 
 
 \/\/.*\n { }
 
@@ -208,7 +208,7 @@ null { PRIMITIVE; return NULLLITERAL; }
 
   std::cerr << "Unknown character: " << yytext[0] 
     << " (" << (int)yytext[0] << ")" << std::endl; 
   yyextra->Error("Unknown character"); 
-  return ERROR; 
+  return jp_ERROR; 
 }
 
 
 %%

File diff suppressed because it is too large
+ 323 - 317
Source/cmDependsJavaParser.cxx


File diff suppressed because it is too large
+ 284 - 284
Source/cmDependsJavaParser.y


+ 206 - 206
Source/cmDependsJavaParserTokens.h
View File 

@@ -29,214 +29,214 @@
 
    /* Put the tokens into the symbol table, so that GDB and other debuggers
 
       know about them.  */
 
    enum yytokentype {
 
-     ABSTRACT = 258,
 
-     ASSERT = 259,
 
-     BOOLEAN_TYPE = 260,
 
-     BREAK = 261,
 
-     BYTE_TYPE = 262,
 
-     CASE = 263,
 
-     CATCH = 264,
 
-     CHAR_TYPE = 265,
 
-     CLASS = 266,
 
-     CONTINUE = 267,
 
-     DEFAULT = 268,
 
-     DO = 269,
 
-     DOUBLE_TYPE = 270,
 
-     ELSE = 271,
 
-     EXTENDS = 272,
 
-     FINAL = 273,
 
-     FINALLY = 274,
 
-     FLOAT_TYPE = 275,
 
-     FOR = 276,
 
-     IF = 277,
 
-     IMPLEMENTS = 278,
 
-     IMPORT = 279,
 
-     INSTANCEOF = 280,
 
-     INT_TYPE = 281,
 
-     INTERFACE = 282,
 
-     LONG_TYPE = 283,
 
-     NATIVE = 284,
 
-     NEW = 285,
 
-     PACKAGE = 286,
 
-     PRIVATE = 287,
 
-     PROTECTED = 288,
 
-     PUBLIC = 289,
 
-     RETURN = 290,
 
-     SHORT_TYPE = 291,
 
-     STATIC = 292,
 
-     STRICTFP = 293,
 
-     SUPER = 294,
 
-     SWITCH = 295,
 
-     SYNCHRONIZED = 296,
 
-     THIS = 297,
 
-     THROW = 298,
 
-     THROWS = 299,
 
-     TRANSIENT = 300,
 
-     TRY = 301,
 
-     VOID = 302,
 
-     VOLATILE = 303,
 
-     WHILE = 304,
 
-     BOOLEANLITERAL = 305,
 
-     CHARACTERLITERAL = 306,
 
-     DECIMALINTEGERLITERAL = 307,
 
-     FLOATINGPOINTLITERAL = 308,
 
-     HEXINTEGERLITERAL = 309,
 
-     NULLLITERAL = 310,
 
-     STRINGLITERAL = 311,
 
-     NAME = 312,
 
-     AND = 313,
 
-     ANDAND = 314,
 
-     ANDEQUALS = 315,
 
-     BRACKETEND = 316,
 
-     BRACKETSTART = 317,
 
-     CARROT = 318,
 
-     CARROTEQUALS = 319,
 
-     COLON = 320,
 
-     COMMA = 321,
 
-     CURLYEND = 322,
 
-     CURLYSTART = 323,
 
-     DIVIDE = 324,
 
-     DIVIDEEQUALS = 325,
 
-     DOLLAR = 326,
 
-     DOT = 327,
 
-     EQUALS = 328,
 
-     EQUALSEQUALS = 329,
 
-     EXCLAMATION = 330,
 
-     EXCLAMATIONEQUALS = 331,
 
-     GREATER = 332,
 
-     GTEQUALS = 333,
 
-     GTGT = 334,
 
-     GTGTEQUALS = 335,
 
-     GTGTGT = 336,
 
-     GTGTGTEQUALS = 337,
 
-     LESLESEQUALS = 338,
 
-     LESSTHAN = 339,
 
-     LTEQUALS = 340,
 
-     LTLT = 341,
 
-     MINUS = 342,
 
-     MINUSEQUALS = 343,
 
-     MINUSMINUS = 344,
 
-     PAREEND = 345,
 
-     PARESTART = 346,
 
-     PERCENT = 347,
 
-     PERCENTEQUALS = 348,
 
-     PIPE = 349,
 
-     PIPEEQUALS = 350,
 
-     PIPEPIPE = 351,
 
-     PLUS = 352,
 
-     PLUSEQUALS = 353,
 
-     PLUSPLUS = 354,
 
-     QUESTION = 355,
 
-     SEMICOL = 356,
 
-     TILDE = 357,
 
-     TIMES = 358,
 
-     TIMESEQUALS = 359,
 
-     ERROR = 360
 
+     jp_ABSTRACT = 258,
 
+     jp_ASSERT = 259,
 
+     jp_BOOLEAN_TYPE = 260,
 
+     jp_BREAK = 261,
 
+     jp_BYTE_TYPE = 262,
 
+     jp_CASE = 263,
 
+     jp_CATCH = 264,
 
+     jp_CHAR_TYPE = 265,
 
+     jp_CLASS = 266,
 
+     jp_CONTINUE = 267,
 
+     jp_DEFAULT = 268,
 
+     jp_DO = 269,
 
+     jp_DOUBLE_TYPE = 270,
 
+     jp_ELSE = 271,
 
+     jp_EXTENDS = 272,
 
+     jp_FINAL = 273,
 
+     jp_FINALLY = 274,
 
+     jp_FLOAT_TYPE = 275,
 
+     jp_FOR = 276,
 
+     jp_IF = 277,
 
+     jp_IMPLEMENTS = 278,
 
+     jp_IMPORT = 279,
 
+     jp_INSTANCEOF = 280,
 
+     jp_INT_TYPE = 281,
 
+     jp_INTERFACE = 282,
 
+     jp_LONG_TYPE = 283,
 
+     jp_NATIVE = 284,
 
+     jp_NEW = 285,
 
+     jp_PACKAGE = 286,
 
+     jp_PRIVATE = 287,
 
+     jp_PROTECTED = 288,
 
+     jp_PUBLIC = 289,
 
+     jp_RETURN = 290,
 
+     jp_SHORT_TYPE = 291,
 
+     jp_STATIC = 292,
 
+     jp_STRICTFP = 293,
 
+     jp_SUPER = 294,
 
+     jp_SWITCH = 295,
 
+     jp_SYNCHRONIZED = 296,
 
+     jp_THIS = 297,
 
+     jp_THROW = 298,
 
+     jp_THROWS = 299,
 
+     jp_TRANSIENT = 300,
 
+     jp_TRY = 301,
 
+     jp_VOID = 302,
 
+     jp_VOLATILE = 303,
 
+     jp_WHILE = 304,
 
+     jp_BOOLEANLITERAL = 305,
 
+     jp_CHARACTERLITERAL = 306,
 
+     jp_DECIMALINTEGERLITERAL = 307,
 
+     jp_FLOATINGPOINTLITERAL = 308,
 
+     jp_HEXINTEGERLITERAL = 309,
 
+     jp_NULLLITERAL = 310,
 
+     jp_STRINGLITERAL = 311,
 
+     jp_NAME = 312,
 
+     jp_AND = 313,
 
+     jp_ANDAND = 314,
 
+     jp_ANDEQUALS = 315,
 
+     jp_BRACKETEND = 316,
 
+     jp_BRACKETSTART = 317,
 
+     jp_CARROT = 318,
 
+     jp_CARROTEQUALS = 319,
 
+     jp_COLON = 320,
 
+     jp_COMMA = 321,
 
+     jp_CURLYEND = 322,
 
+     jp_CURLYSTART = 323,
 
+     jp_DIVIDE = 324,
 
+     jp_DIVIDEEQUALS = 325,
 
+     jp_DOLLAR = 326,
 
+     jp_DOT = 327,
 
+     jp_EQUALS = 328,
 
+     jp_EQUALSEQUALS = 329,
 
+     jp_EXCLAMATION = 330,
 
+     jp_EXCLAMATIONEQUALS = 331,
 
+     jp_GREATER = 332,
 
+     jp_GTEQUALS = 333,
 
+     jp_GTGT = 334,
 
+     jp_GTGTEQUALS = 335,
 
+     jp_GTGTGT = 336,
 
+     jp_GTGTGTEQUALS = 337,
 
+     jp_LESLESEQUALS = 338,
 
+     jp_LESSTHAN = 339,
 
+     jp_LTEQUALS = 340,
 
+     jp_LTLT = 341,
 
+     jp_MINUS = 342,
 
+     jp_MINUSEQUALS = 343,
 
+     jp_MINUSMINUS = 344,
 
+     jp_PAREEND = 345,
 
+     jp_PARESTART = 346,
 
+     jp_PERCENT = 347,
 
+     jp_PERCENTEQUALS = 348,
 
+     jp_PIPE = 349,
 
+     jp_PIPEEQUALS = 350,
 
+     jp_PIPEPIPE = 351,
 
+     jp_PLUS = 352,
 
+     jp_PLUSEQUALS = 353,
 
+     jp_PLUSPLUS = 354,
 
+     jp_QUESTION = 355,
 
+     jp_SEMICOL = 356,
 
+     jp_TILDE = 357,
 
+     jp_TIMES = 358,
 
+     jp_TIMESEQUALS = 359,
 
+     jp_ERROR = 360
 
    };
 
 #endif
 
-#define ABSTRACT 258
 
-#define ASSERT 259
 
-#define BOOLEAN_TYPE 260
 
-#define BREAK 261
 
-#define BYTE_TYPE 262
 
-#define CASE 263
 
-#define CATCH 264
 
-#define CHAR_TYPE 265
 
-#define CLASS 266
 
-#define CONTINUE 267
 
-#define DEFAULT 268
 
-#define DO 269
 
-#define DOUBLE_TYPE 270
 
-#define ELSE 271
 
-#define EXTENDS 272
 
-#define FINAL 273
 
-#define FINALLY 274
 
-#define FLOAT_TYPE 275
 
-#define FOR 276
 
-#define IF 277
 
-#define IMPLEMENTS 278
 
-#define IMPORT 279
 
-#define INSTANCEOF 280
 
-#define INT_TYPE 281
 
-#define INTERFACE 282
 
-#define LONG_TYPE 283
 
-#define NATIVE 284
 
-#define NEW 285
 
-#define PACKAGE 286
 
-#define PRIVATE 287
 
-#define PROTECTED 288
 
-#define PUBLIC 289
 
-#define RETURN 290
 
-#define SHORT_TYPE 291
 
-#define STATIC 292
 
-#define STRICTFP 293
 
-#define SUPER 294
 
-#define SWITCH 295
 
-#define SYNCHRONIZED 296
 
-#define THIS 297
 
-#define THROW 298
 
-#define THROWS 299
 
-#define TRANSIENT 300
 
-#define TRY 301
 
-#define VOID 302
 
-#define VOLATILE 303
 
-#define WHILE 304
 
-#define BOOLEANLITERAL 305
 
-#define CHARACTERLITERAL 306
 
-#define DECIMALINTEGERLITERAL 307
 
-#define FLOATINGPOINTLITERAL 308
 
-#define HEXINTEGERLITERAL 309
 
-#define NULLLITERAL 310
 
-#define STRINGLITERAL 311
 
-#define NAME 312
 
-#define AND 313
 
-#define ANDAND 314
 
-#define ANDEQUALS 315
 
-#define BRACKETEND 316
 
-#define BRACKETSTART 317
 
-#define CARROT 318
 
-#define CARROTEQUALS 319
 
-#define COLON 320
 
-#define COMMA 321
 
-#define CURLYEND 322
 
-#define CURLYSTART 323
 
-#define DIVIDE 324
 
-#define DIVIDEEQUALS 325
 
-#define DOLLAR 326
 
-#define DOT 327
 
-#define EQUALS 328
 
-#define EQUALSEQUALS 329
 
-#define EXCLAMATION 330
 
-#define EXCLAMATIONEQUALS 331
 
-#define GREATER 332
 
-#define GTEQUALS 333
 
-#define GTGT 334
 
-#define GTGTEQUALS 335
 
-#define GTGTGT 336
 
-#define GTGTGTEQUALS 337
 
-#define LESLESEQUALS 338
 
-#define LESSTHAN 339
 
-#define LTEQUALS 340
 
-#define LTLT 341
 
-#define MINUS 342
 
-#define MINUSEQUALS 343
 
-#define MINUSMINUS 344
 
-#define PAREEND 345
 
-#define PARESTART 346
 
-#define PERCENT 347
 
-#define PERCENTEQUALS 348
 
-#define PIPE 349
 
-#define PIPEEQUALS 350
 
-#define PIPEPIPE 351
 
-#define PLUS 352
 
-#define PLUSEQUALS 353
 
-#define PLUSPLUS 354
 
-#define QUESTION 355
 
-#define SEMICOL 356
 
-#define TILDE 357
 
-#define TIMES 358
 
-#define TIMESEQUALS 359
 
-#define ERROR 360
 
+#define jp_ABSTRACT 258
 
+#define jp_ASSERT 259
 
+#define jp_BOOLEAN_TYPE 260
 
+#define jp_BREAK 261
 
+#define jp_BYTE_TYPE 262
 
+#define jp_CASE 263
 
+#define jp_CATCH 264
 
+#define jp_CHAR_TYPE 265
 
+#define jp_CLASS 266
 
+#define jp_CONTINUE 267
 
+#define jp_DEFAULT 268
 
+#define jp_DO 269
 
+#define jp_DOUBLE_TYPE 270
 
+#define jp_ELSE 271
 
+#define jp_EXTENDS 272
 
+#define jp_FINAL 273
 
+#define jp_FINALLY 274
 
+#define jp_FLOAT_TYPE 275
 
+#define jp_FOR 276
 
+#define jp_IF 277
 
+#define jp_IMPLEMENTS 278
 
+#define jp_IMPORT 279
 
+#define jp_INSTANCEOF 280
 
+#define jp_INT_TYPE 281
 
+#define jp_INTERFACE 282
 
+#define jp_LONG_TYPE 283
 
+#define jp_NATIVE 284
 
+#define jp_NEW 285
 
+#define jp_PACKAGE 286
 
+#define jp_PRIVATE 287
 
+#define jp_PROTECTED 288
 
+#define jp_PUBLIC 289
 
+#define jp_RETURN 290
 
+#define jp_SHORT_TYPE 291
 
+#define jp_STATIC 292
 
+#define jp_STRICTFP 293
 
+#define jp_SUPER 294
 
+#define jp_SWITCH 295
 
+#define jp_SYNCHRONIZED 296
 
+#define jp_THIS 297
 
+#define jp_THROW 298
 
+#define jp_THROWS 299
 
+#define jp_TRANSIENT 300
 
+#define jp_TRY 301
 
+#define jp_VOID 302
 
+#define jp_VOLATILE 303
 
+#define jp_WHILE 304
 
+#define jp_BOOLEANLITERAL 305
 
+#define jp_CHARACTERLITERAL 306
 
+#define jp_DECIMALINTEGERLITERAL 307
 
+#define jp_FLOATINGPOINTLITERAL 308
 
+#define jp_HEXINTEGERLITERAL 309
 
+#define jp_NULLLITERAL 310
 
+#define jp_STRINGLITERAL 311
 
+#define jp_NAME 312
 
+#define jp_AND 313
 
+#define jp_ANDAND 314
 
+#define jp_ANDEQUALS 315
 
+#define jp_BRACKETEND 316
 
+#define jp_BRACKETSTART 317
 
+#define jp_CARROT 318
 
+#define jp_CARROTEQUALS 319
 
+#define jp_COLON 320
 
+#define jp_COMMA 321
 
+#define jp_CURLYEND 322
 
+#define jp_CURLYSTART 323
 
+#define jp_DIVIDE 324
 
+#define jp_DIVIDEEQUALS 325
 
+#define jp_DOLLAR 326
 
+#define jp_DOT 327
 
+#define jp_EQUALS 328
 
+#define jp_EQUALSEQUALS 329
 
+#define jp_EXCLAMATION 330
 
+#define jp_EXCLAMATIONEQUALS 331
 
+#define jp_GREATER 332
 
+#define jp_GTEQUALS 333
 
+#define jp_GTGT 334
 
+#define jp_GTGTEQUALS 335
 
+#define jp_GTGTGT 336
 
+#define jp_GTGTGTEQUALS 337
 
+#define jp_LESLESEQUALS 338
 
+#define jp_LESSTHAN 339
 
+#define jp_LTEQUALS 340
 
+#define jp_LTLT 341
 
+#define jp_MINUS 342
 
+#define jp_MINUSEQUALS 343
 
+#define jp_MINUSMINUS 344
 
+#define jp_PAREEND 345
 
+#define jp_PARESTART 346
 
+#define jp_PERCENT 347
 
+#define jp_PERCENTEQUALS 348
 
+#define jp_PIPE 349
 
+#define jp_PIPEEQUALS 350
 
+#define jp_PIPEPIPE 351
 
+#define jp_PLUS 352
 
+#define jp_PLUSEQUALS 353
 
+#define jp_PLUSPLUS 354
 
+#define jp_QUESTION 355
 
+#define jp_SEMICOL 356
 
+#define jp_TILDE 357
 
+#define jp_TIMES 358
 
+#define jp_TIMESEQUALS 359
 
+#define jp_ERROR 360

Some files were not shown because too many files changed in this diff