COMP: Remove more warnings/errors

5 files changed, 2166 insertions, 2160 deletions

diff --git a/Source/cmDependsJavaLexer.cxx b/Source/cmDependsJavaLexer.cxx
index cfabec4d61..503fb2808a 100644
--- a/Source/cmDependsJavaLexer.cxx
+++ b/Source/cmDependsJavaLexer.cxx
@@ -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:
diff --git a/Source/cmDependsJavaLexer.in.l b/Source/cmDependsJavaLexer.in.l
index 89541794ec..f77f7fd8b9 100644
--- a/Source/cmDependsJavaLexer.in.l
+++ b/Source/cmDependsJavaLexer.in.l
@@ -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; 
 }
 
 %%
diff --git a/Source/cmDependsJavaParser.cxx b/Source/cmDependsJavaParser.cxx
index d724f8d4d3..ac97989037 100644
--- a/Source/cmDependsJavaParser.cxx
+++ b/Source/cmDependsJavaParser.cxx
@@ -62,214 +62,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
 
 
 
@@ -329,9 +329,9 @@ static void cmDependsJavaError(yyscan_t yyscanner, const char* message);
 #define YYMAXDEPTH 1000000
 
 
-#define CHECKEMPTY(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
-#define ELEMENTSTART(cnt) yyGetParser->PrepareElement(&yyval)
-#define STORECLASS(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
+#define jpCheckEmpty(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
+#define jpElementStart(cnt) yyGetParser->PrepareElement(&yyval)
+#define jpStoreClass(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
 /* Disable some warnings in the generated code.  */
 #ifdef __BORLANDC__
 # pragma warn -8004 /* Variable assigned a value that is not used.  */
@@ -732,30 +732,36 @@ static const unsigned short int yyrline[] =
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "ABSTRACT", "ASSERT", "BOOLEAN_TYPE",
-  "BREAK", "BYTE_TYPE", "CASE", "CATCH", "CHAR_TYPE", "CLASS", "CONTINUE",
-  "DEFAULT", "DO", "DOUBLE_TYPE", "ELSE", "EXTENDS", "FINAL", "FINALLY",
-  "FLOAT_TYPE", "FOR", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF",
-  "INT_TYPE", "INTERFACE", "LONG_TYPE", "NATIVE", "NEW", "PACKAGE",
-  "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT_TYPE", "STATIC",
-  "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS",
-  "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "BOOLEANLITERAL",
-  "CHARACTERLITERAL", "DECIMALINTEGERLITERAL", "FLOATINGPOINTLITERAL",
-  "HEXINTEGERLITERAL", "NULLLITERAL", "STRINGLITERAL", "NAME", "AND",
-  "ANDAND", "ANDEQUALS", "BRACKETEND", "BRACKETSTART", "CARROT",
-  "CARROTEQUALS", "COLON", "COMMA", "CURLYEND", "CURLYSTART", "DIVIDE",
-  "DIVIDEEQUALS", "DOLLAR", "DOT", "EQUALS", "EQUALSEQUALS", "EXCLAMATION",
-  "EXCLAMATIONEQUALS", "GREATER", "GTEQUALS", "GTGT", "GTGTEQUALS",
-  "GTGTGT", "GTGTGTEQUALS", "LESLESEQUALS", "LESSTHAN", "LTEQUALS", "LTLT",
-  "MINUS", "MINUSEQUALS", "MINUSMINUS", "PAREEND", "PARESTART", "PERCENT",
-  "PERCENTEQUALS", "PIPE", "PIPEEQUALS", "PIPEPIPE", "PLUS", "PLUSEQUALS",
-  "PLUSPLUS", "QUESTION", "SEMICOL", "TILDE", "TIMES", "TIMESEQUALS",
-  "ERROR", "$accept", "Goal", "Literal", "IntegerLiteral", "Type",
-  "PrimitiveType", "ReferenceType", "ClassOrInterfaceType", "ClassType",
-  "InterfaceType", "ArrayType", "Name", "SimpleName", "Identifier",
-  "QualifiedName", "SimpleType", "CompilationUnit",
-  "PackageDeclarationopt", "ImportDeclarations", "TypeDeclarations",
-  "PackageDeclaration", "ImportDeclaration", "SingleTypeImportDeclaration",
+  "$end", "error", "$undefined", "jp_ABSTRACT", "jp_ASSERT",
+  "jp_BOOLEAN_TYPE", "jp_BREAK", "jp_BYTE_TYPE", "jp_CASE", "jp_CATCH",
+  "jp_CHAR_TYPE", "jp_CLASS", "jp_CONTINUE", "jp_DEFAULT", "jp_DO",
+  "jp_DOUBLE_TYPE", "jp_ELSE", "jp_EXTENDS", "jp_FINAL", "jp_FINALLY",
+  "jp_FLOAT_TYPE", "jp_FOR", "jp_IF", "jp_IMPLEMENTS", "jp_IMPORT",
+  "jp_INSTANCEOF", "jp_INT_TYPE", "jp_INTERFACE", "jp_LONG_TYPE",
+  "jp_NATIVE", "jp_NEW", "jp_PACKAGE", "jp_PRIVATE", "jp_PROTECTED",
+  "jp_PUBLIC", "jp_RETURN", "jp_SHORT_TYPE", "jp_STATIC", "jp_STRICTFP",
+  "jp_SUPER", "jp_SWITCH", "jp_SYNCHRONIZED", "jp_THIS", "jp_THROW",
+  "jp_THROWS", "jp_TRANSIENT", "jp_TRY", "jp_VOID", "jp_VOLATILE",
+  "jp_WHILE", "jp_BOOLEANLITERAL", "jp_CHARACTERLITERAL",
+  "jp_DECIMALINTEGERLITERAL", "jp_FLOATINGPOINTLITERAL",
+  "jp_HEXINTEGERLITERAL", "jp_NULLLITERAL", "jp_STRINGLITERAL", "jp_NAME",
+  "jp_AND", "jp_ANDAND", "jp_ANDEQUALS", "jp_BRACKETEND",
+  "jp_BRACKETSTART", "jp_CARROT", "jp_CARROTEQUALS", "jp_COLON",
+  "jp_COMMA", "jp_CURLYEND", "jp_CURLYSTART", "jp_DIVIDE",
+  "jp_DIVIDEEQUALS", "jp_DOLLAR", "jp_DOT", "jp_EQUALS", "jp_EQUALSEQUALS",
+  "jp_EXCLAMATION", "jp_EXCLAMATIONEQUALS", "jp_GREATER", "jp_GTEQUALS",
+  "jp_GTGT", "jp_GTGTEQUALS", "jp_GTGTGT", "jp_GTGTGTEQUALS",
+  "jp_LESLESEQUALS", "jp_LESSTHAN", "jp_LTEQUALS", "jp_LTLT", "jp_MINUS",
+  "jp_MINUSEQUALS", "jp_MINUSMINUS", "jp_PAREEND", "jp_PARESTART",
+  "jp_PERCENT", "jp_PERCENTEQUALS", "jp_PIPE", "jp_PIPEEQUALS",
+  "jp_PIPEPIPE", "jp_PLUS", "jp_PLUSEQUALS", "jp_PLUSPLUS", "jp_QUESTION",
+  "jp_SEMICOL", "jp_TILDE", "jp_TIMES", "jp_TIMESEQUALS", "jp_ERROR",
+  "$accept", "Goal", "Literal", "IntegerLiteral", "Type", "PrimitiveType",
+  "ReferenceType", "ClassOrInterfaceType", "ClassType", "InterfaceType",
+  "ArrayType", "Name", "SimpleName", "Identifier", "QualifiedName",
+  "SimpleType", "CompilationUnit", "PackageDeclarationopt",
+  "ImportDeclarations", "TypeDeclarations", "PackageDeclaration",
+  "ImportDeclaration", "SingleTypeImportDeclaration",
   "TypeImportOnDemandDeclaration", "TypeDeclaration", "Modifiers",
   "Modifier", "ClassHeader", "ClassDeclaration", "Modifiersopt", "Super",
   "Interfaces", "InterfaceTypeList", "ClassBody", "ClassBodyDeclarations",
@@ -2209,8 +2215,8 @@ yyreduce:
         case 2:
 #line 192 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2219,8 +2225,8 @@ yyreduce:
   case 3:
 #line 201 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2229,8 +2235,8 @@ yyreduce:
   case 4:
 #line 209 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2239,8 +2245,8 @@ yyreduce:
   case 5:
 #line 217 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2249,8 +2255,8 @@ yyreduce:
   case 6:
 #line 225 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2259,8 +2265,8 @@ yyreduce:
   case 7:
 #line 233 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2269,8 +2275,8 @@ yyreduce:
   case 8:
 #line 241 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2279,8 +2285,8 @@ yyreduce:
   case 9:
 #line 250 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2289,8 +2295,8 @@ yyreduce:
   case 10:
 #line 258 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2299,8 +2305,8 @@ yyreduce:
   case 11:
 #line 267 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2309,8 +2315,8 @@ yyreduce:
   case 12:
 #line 275 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2319,64 +2325,64 @@ yyreduce:
   case 13:
 #line 284 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 14:
 #line 289 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 15:
 #line 294 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 16:
 #line 299 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 17:
 #line 304 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 18:
 #line 309 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 19:
 #line 314 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 20:
 #line 319 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
     break;
 
   case 21:
 #line 325 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2385,8 +2391,8 @@ yyreduce:
   case 22:
 #line 333 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2395,9 +2401,9 @@ yyreduce:
   case 23:
 #line 342 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  STORECLASS(yyvsp[0].str);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpStoreClass(yyvsp[0].str);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2406,8 +2412,8 @@ yyreduce:
   case 24:
 #line 352 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2416,8 +2422,8 @@ yyreduce:
   case 25:
 #line 361 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2426,8 +2432,8 @@ yyreduce:
   case 26:
 #line 370 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2436,9 +2442,9 @@ yyreduce:
   case 27:
 #line 378 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  STORECLASS(yyvsp[-1].str);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpStoreClass(yyvsp[-1].str);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2447,7 +2453,7 @@ yyreduce:
   case 28:
 #line 388 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = yyvsp[0].str;
 }
     break;
@@ -2455,7 +2461,7 @@ yyreduce:
   case 29:
 #line 394 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = yyvsp[0].str;
 }
     break;
@@ -2463,7 +2469,7 @@ yyreduce:
   case 30:
 #line 401 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = yyvsp[0].str;
 }
     break;
@@ -2471,7 +2477,7 @@ yyreduce:
   case 31:
 #line 408 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = yyvsp[0].str;
 }
     break;
@@ -2479,7 +2485,7 @@ yyreduce:
   case 32:
 #line 414 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   yyval.str = yyvsp[0].str;
 }
     break;
@@ -2487,7 +2493,7 @@ yyreduce:
   case 33:
 #line 421 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->AddClassFound(yyvsp[-2].str);
   yyGetParser->UpdateCombine(yyvsp[-2].str, yyvsp[0].str);
   yyGetParser->DeallocateParserType(&(yyvsp[-2].str));
@@ -2498,9 +2504,9 @@ yyreduce:
   case 34:
 #line 430 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  STORECLASS(yyvsp[-2].str);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpStoreClass(yyvsp[-2].str);
+  jpCheckEmpty(3);
   yyGetParser->SetCurrentCombine("");
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
@@ -2510,10 +2516,10 @@ yyreduce:
   case 35:
 #line 440 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  STORECLASS(yyvsp[-2].str);
+  jpElementStart(3);
+  jpStoreClass(yyvsp[-2].str);
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2522,8 +2528,8 @@ yyreduce:
   case 36:
 #line 450 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2532,8 +2538,8 @@ yyreduce:
   case 37:
 #line 459 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2542,8 +2548,8 @@ yyreduce:
   case 38:
 #line 467 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2552,8 +2558,8 @@ yyreduce:
   case 39:
 #line 476 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2562,7 +2568,7 @@ yyreduce:
   case 40:
 #line 484 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2571,8 +2577,8 @@ yyreduce:
   case 41:
 #line 491 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2581,7 +2587,7 @@ yyreduce:
   case 42:
 #line 499 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2590,8 +2596,8 @@ yyreduce:
   case 43:
 #line 506 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2600,7 +2606,7 @@ yyreduce:
   case 44:
 #line 514 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2609,8 +2615,8 @@ yyreduce:
   case 45:
 #line 521 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2619,11 +2625,11 @@ yyreduce:
   case 46:
 #line 530 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->SetCurrentPackage(yyvsp[-1].str);
   yyGetParser->DeallocateParserType(&(yyvsp[-1].str));
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2632,8 +2638,8 @@ yyreduce:
   case 47:
 #line 542 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2642,8 +2648,8 @@ yyreduce:
   case 48:
 #line 550 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2652,11 +2658,11 @@ yyreduce:
   case 49:
 #line 559 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->AddPackagesImport(yyvsp[-1].str);
   yyGetParser->DeallocateParserType(&(yyvsp[-1].str));
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2665,7 +2671,7 @@ yyreduce:
   case 50:
 #line 571 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
   std::string str = yyvsp[-3].str;
   str += ".*";
   yyGetParser->AddPackagesImport(str.c_str());
@@ -2679,8 +2685,8 @@ yyreduce:
   case 51:
 #line 584 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2689,8 +2695,8 @@ yyreduce:
   case 52:
 #line 592 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2699,8 +2705,8 @@ yyreduce:
   case 53:
 #line 600 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2709,8 +2715,8 @@ yyreduce:
   case 54:
 #line 609 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2719,8 +2725,8 @@ yyreduce:
   case 55:
 #line 617 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2730,17 +2736,17 @@ yyreduce:
 #line 632 "cmDependsJavaParser.y"
     {
   yyGetParser->StartClass(yyvsp[0].str);
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
 }
     break;
 
   case 68:
 #line 642 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -2750,8 +2756,8 @@ yyreduce:
   case 69:
 #line 651 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(2);
+  jpElementStart(3);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -2761,8 +2767,8 @@ yyreduce:
   case 70:
 #line 660 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -2772,8 +2778,8 @@ yyreduce:
   case 71:
 #line 669 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -2783,7 +2789,7 @@ yyreduce:
   case 72:
 #line 678 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2792,8 +2798,8 @@ yyreduce:
   case 73:
 #line 685 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2802,8 +2808,8 @@ yyreduce:
   case 74:
 #line 694 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2812,8 +2818,8 @@ yyreduce:
   case 75:
 #line 703 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2822,8 +2828,8 @@ yyreduce:
   case 76:
 #line 712 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2832,8 +2838,8 @@ yyreduce:
   case 77:
 #line 720 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2842,8 +2848,8 @@ yyreduce:
   case 78:
 #line 729 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2852,7 +2858,7 @@ yyreduce:
   case 79:
 #line 737 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2861,8 +2867,8 @@ yyreduce:
   case 80:
 #line 744 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2871,8 +2877,8 @@ yyreduce:
   case 81:
 #line 753 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2881,8 +2887,8 @@ yyreduce:
   case 82:
 #line 761 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2891,8 +2897,8 @@ yyreduce:
   case 83:
 #line 769 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2901,8 +2907,8 @@ yyreduce:
   case 84:
 #line 777 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2911,8 +2917,8 @@ yyreduce:
   case 85:
 #line 786 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2921,8 +2927,8 @@ yyreduce:
   case 86:
 #line 794 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2931,15 +2937,15 @@ yyreduce:
   case 87:
 #line 803 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
 }
     break;
 
   case 88:
 #line 809 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2948,8 +2954,8 @@ yyreduce:
   case 89:
 #line 817 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2958,8 +2964,8 @@ yyreduce:
   case 90:
 #line 826 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2968,8 +2974,8 @@ yyreduce:
   case 91:
 #line 834 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2978,9 +2984,9 @@ yyreduce:
   case 92:
 #line 843 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2989,8 +2995,8 @@ yyreduce:
   case 93:
 #line 852 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -2999,8 +3005,8 @@ yyreduce:
   case 94:
 #line 861 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3009,8 +3015,8 @@ yyreduce:
   case 95:
 #line 869 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3019,8 +3025,8 @@ yyreduce:
   case 96:
 #line 878 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3029,8 +3035,8 @@ yyreduce:
   case 97:
 #line 886 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3039,8 +3045,8 @@ yyreduce:
   case 98:
 #line 894 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3049,8 +3055,8 @@ yyreduce:
   case 99:
 #line 903 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3060,8 +3066,8 @@ yyreduce:
   case 100:
 #line 912 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3071,7 +3077,7 @@ yyreduce:
   case 101:
 #line 921 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3081,8 +3087,8 @@ yyreduce:
   case 102:
 #line 929 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3092,9 +3098,9 @@ yyreduce:
   case 103:
 #line 939 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3104,7 +3110,7 @@ yyreduce:
   case 104:
 #line 949 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
 
 }
     break;
@@ -3112,7 +3118,7 @@ yyreduce:
   case 105:
 #line 955 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3122,7 +3128,7 @@ yyreduce:
   case 107:
 #line 966 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
     break;
@@ -3130,8 +3136,8 @@ yyreduce:
   case 108:
 #line 972 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3141,8 +3147,8 @@ yyreduce:
   case 109:
 #line 982 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3152,8 +3158,8 @@ yyreduce:
   case 110:
 #line 992 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3163,7 +3169,7 @@ yyreduce:
   case 111:
 #line 1002 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
     break;
@@ -3171,8 +3177,8 @@ yyreduce:
   case 112:
 #line 1008 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3182,8 +3188,8 @@ yyreduce:
   case 113:
 #line 1018 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3193,8 +3199,8 @@ yyreduce:
   case 114:
 #line 1028 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3204,8 +3210,8 @@ yyreduce:
   case 115:
 #line 1038 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3215,8 +3221,8 @@ yyreduce:
   case 116:
 #line 1047 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3226,9 +3232,9 @@ yyreduce:
   case 117:
 #line 1057 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3238,8 +3244,8 @@ yyreduce:
   case 118:
 #line 1068 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3249,7 +3255,7 @@ yyreduce:
   case 119:
 #line 1077 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3259,8 +3265,8 @@ yyreduce:
   case 120:
 #line 1085 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3270,8 +3276,8 @@ yyreduce:
   case 121:
 #line 1095 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3281,8 +3287,8 @@ yyreduce:
   case 122:
 #line 1104 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3293,17 +3299,17 @@ yyreduce:
 #line 1114 "cmDependsJavaParser.y"
     {
   yyGetParser->StartClass(yyvsp[0].str);
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
 }
     break;
 
   case 124:
 #line 1123 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -3313,7 +3319,7 @@ yyreduce:
   case 125:
 #line 1132 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -3322,8 +3328,8 @@ yyreduce:
   case 126:
 #line 1139 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3333,8 +3339,8 @@ yyreduce:
   case 127:
 #line 1149 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3344,8 +3350,8 @@ yyreduce:
   case 128:
 #line 1158 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3355,8 +3361,8 @@ yyreduce:
   case 129:
 #line 1168 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3366,7 +3372,7 @@ yyreduce:
   case 130:
 #line 1177 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3376,7 +3382,7 @@ yyreduce:
   case 131:
 #line 1185 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3386,8 +3392,8 @@ yyreduce:
   case 132:
 #line 1194 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3397,8 +3403,8 @@ yyreduce:
   case 133:
 #line 1203 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3408,8 +3414,8 @@ yyreduce:
   case 134:
 #line 1212 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3419,7 +3425,7 @@ yyreduce:
   case 135:
 #line 1221 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3429,8 +3435,8 @@ yyreduce:
   case 136:
 #line 1229 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3440,7 +3446,7 @@ yyreduce:
   case 137:
 #line 1238 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3450,8 +3456,8 @@ yyreduce:
   case 138:
 #line 1247 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3461,8 +3467,8 @@ yyreduce:
   case 139:
 #line 1257 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3472,8 +3478,8 @@ yyreduce:
   case 140:
 #line 1267 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3483,8 +3489,8 @@ yyreduce:
   case 141:
 #line 1276 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3494,8 +3500,8 @@ yyreduce:
   case 142:
 #line 1286 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3505,7 +3511,7 @@ yyreduce:
   case 143:
 #line 1295 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3515,8 +3521,8 @@ yyreduce:
   case 144:
 #line 1303 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3526,8 +3532,8 @@ yyreduce:
   case 145:
 #line 1312 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3537,8 +3543,8 @@ yyreduce:
   case 146:
 #line 1322 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3548,8 +3554,8 @@ yyreduce:
   case 147:
 #line 1331 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3559,7 +3565,7 @@ yyreduce:
   case 148:
 #line 1341 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3569,7 +3575,7 @@ yyreduce:
   case 149:
 #line 1349 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3579,8 +3585,8 @@ yyreduce:
   case 150:
 #line 1357 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3590,8 +3596,8 @@ yyreduce:
   case 151:
 #line 1367 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3601,8 +3607,8 @@ yyreduce:
   case 152:
 #line 1376 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3612,8 +3618,8 @@ yyreduce:
   case 153:
 #line 1386 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3623,8 +3629,8 @@ yyreduce:
   case 154:
 #line 1395 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3634,8 +3640,8 @@ yyreduce:
   case 155:
 #line 1404 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3645,8 +3651,8 @@ yyreduce:
   case 156:
 #line 1414 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3656,8 +3662,8 @@ yyreduce:
   case 157:
 #line 1424 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(3);
+  jpElementStart(1);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3667,8 +3673,8 @@ yyreduce:
   case 158:
 #line 1433 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3678,8 +3684,8 @@ yyreduce:
   case 159:
 #line 1443 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3689,8 +3695,8 @@ yyreduce:
   case 160:
 #line 1452 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3700,8 +3706,8 @@ yyreduce:
   case 161:
 #line 1461 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3711,8 +3717,8 @@ yyreduce:
   case 162:
 #line 1470 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3722,8 +3728,8 @@ yyreduce:
   case 163:
 #line 1479 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3733,8 +3739,8 @@ yyreduce:
   case 164:
 #line 1488 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3744,8 +3750,8 @@ yyreduce:
   case 165:
 #line 1498 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3755,8 +3761,8 @@ yyreduce:
   case 166:
 #line 1507 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3766,8 +3772,8 @@ yyreduce:
   case 167:
 #line 1516 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3777,8 +3783,8 @@ yyreduce:
   case 168:
 #line 1525 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3788,8 +3794,8 @@ yyreduce:
   case 169:
 #line 1534 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3799,8 +3805,8 @@ yyreduce:
   case 170:
 #line 1544 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3810,8 +3816,8 @@ yyreduce:
   case 171:
 #line 1553 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3821,8 +3827,8 @@ yyreduce:
   case 172:
 #line 1562 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3832,8 +3838,8 @@ yyreduce:
   case 173:
 #line 1571 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3843,8 +3849,8 @@ yyreduce:
   case 174:
 #line 1580 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3854,8 +3860,8 @@ yyreduce:
   case 175:
 #line 1589 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3865,8 +3871,8 @@ yyreduce:
   case 176:
 #line 1598 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3876,8 +3882,8 @@ yyreduce:
   case 177:
 #line 1607 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3887,8 +3893,8 @@ yyreduce:
   case 178:
 #line 1616 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3898,8 +3904,8 @@ yyreduce:
   case 179:
 #line 1625 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3909,8 +3915,8 @@ yyreduce:
   case 180:
 #line 1634 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3920,8 +3926,8 @@ yyreduce:
   case 181:
 #line 1643 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3931,8 +3937,8 @@ yyreduce:
   case 182:
 #line 1653 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3942,9 +3948,9 @@ yyreduce:
   case 183:
 #line 1663 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[-2].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3954,8 +3960,8 @@ yyreduce:
   case 184:
 #line 1674 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3965,8 +3971,8 @@ yyreduce:
   case 185:
 #line 1684 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3976,8 +3982,8 @@ yyreduce:
   case 186:
 #line 1694 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3987,8 +3993,8 @@ yyreduce:
   case 187:
 #line 1703 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3998,8 +4004,8 @@ yyreduce:
   case 188:
 #line 1712 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4009,8 +4015,8 @@ yyreduce:
   case 189:
 #line 1721 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4020,8 +4026,8 @@ yyreduce:
   case 190:
 #line 1730 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4031,8 +4037,8 @@ yyreduce:
   case 191:
 #line 1739 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4042,8 +4048,8 @@ yyreduce:
   case 192:
 #line 1748 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4053,8 +4059,8 @@ yyreduce:
   case 193:
 #line 1758 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4064,8 +4070,8 @@ yyreduce:
   case 194:
 #line 1768 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(7);
-  CHECKEMPTY(7);
+  jpElementStart(7);
+  jpCheckEmpty(7);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4075,8 +4081,8 @@ yyreduce:
   case 195:
 #line 1778 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(7);
-  CHECKEMPTY(7);
+  jpElementStart(7);
+  jpCheckEmpty(7);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4086,7 +4092,7 @@ yyreduce:
   case 196:
 #line 1788 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
     break;
@@ -4094,7 +4100,7 @@ yyreduce:
   case 197:
 #line 1795 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
 
 }
     break;
@@ -4102,7 +4108,7 @@ yyreduce:
   case 198:
 #line 1801 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4112,8 +4118,8 @@ yyreduce:
   case 199:
 #line 1809 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4123,7 +4129,7 @@ yyreduce:
   case 200:
 #line 1818 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4133,8 +4139,8 @@ yyreduce:
   case 201:
 #line 1826 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4144,8 +4150,8 @@ yyreduce:
   case 202:
 #line 1836 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4155,8 +4161,8 @@ yyreduce:
   case 203:
 #line 1846 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4166,8 +4172,8 @@ yyreduce:
   case 204:
 #line 1855 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4177,8 +4183,8 @@ yyreduce:
   case 205:
 #line 1865 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4188,8 +4194,8 @@ yyreduce:
   case 206:
 #line 1874 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4199,7 +4205,7 @@ yyreduce:
   case 207:
 #line 1884 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
     break;
@@ -4207,7 +4213,7 @@ yyreduce:
   case 208:
 #line 1891 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
     break;
@@ -4215,7 +4221,7 @@ yyreduce:
   case 209:
 #line 1898 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(7);
+  jpElementStart(7);
 
 }
     break;
@@ -4223,7 +4229,7 @@ yyreduce:
   case 210:
 #line 1906 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(9);
+  jpElementStart(9);
 
 }
     break;
@@ -4231,7 +4237,7 @@ yyreduce:
   case 211:
 #line 1912 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4241,8 +4247,8 @@ yyreduce:
   case 212:
 #line 1920 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4252,7 +4258,7 @@ yyreduce:
   case 213:
 #line 1929 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4262,8 +4268,8 @@ yyreduce:
   case 214:
 #line 1937 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4273,7 +4279,7 @@ yyreduce:
   case 215:
 #line 1948 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(9);
+  jpElementStart(9);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4283,7 +4289,7 @@ yyreduce:
   case 216:
 #line 1956 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4293,8 +4299,8 @@ yyreduce:
   case 217:
 #line 1964 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4304,8 +4310,8 @@ yyreduce:
   case 218:
 #line 1974 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4315,8 +4321,8 @@ yyreduce:
   case 219:
 #line 1983 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4326,8 +4332,8 @@ yyreduce:
   case 220:
 #line 1993 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4337,8 +4343,8 @@ yyreduce:
   case 221:
 #line 2003 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4348,8 +4354,8 @@ yyreduce:
   case 222:
 #line 2012 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4359,8 +4365,8 @@ yyreduce:
   case 223:
 #line 2022 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4370,8 +4376,8 @@ yyreduce:
   case 224:
 #line 2031 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4381,9 +4387,9 @@ yyreduce:
   case 225:
 #line 2041 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[-1].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4393,7 +4399,7 @@ yyreduce:
   case 226:
 #line 2051 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4403,7 +4409,7 @@ yyreduce:
   case 227:
 #line 2059 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
     break;
@@ -4411,9 +4417,9 @@ yyreduce:
   case 228:
 #line 2066 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[-1].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4423,8 +4429,8 @@ yyreduce:
   case 229:
 #line 2077 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4434,8 +4440,8 @@ yyreduce:
   case 230:
 #line 2087 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4445,8 +4451,8 @@ yyreduce:
   case 231:
 #line 2097 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4456,8 +4462,8 @@ yyreduce:
   case 232:
 #line 2107 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4467,8 +4473,8 @@ yyreduce:
   case 233:
 #line 2116 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4478,7 +4484,7 @@ yyreduce:
   case 234:
 #line 2125 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4488,8 +4494,8 @@ yyreduce:
   case 235:
 #line 2133 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4499,8 +4505,8 @@ yyreduce:
   case 236:
 #line 2143 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4510,8 +4516,8 @@ yyreduce:
   case 237:
 #line 2152 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4521,7 +4527,7 @@ yyreduce:
   case 238:
 #line 2162 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
     break;
@@ -4529,8 +4535,8 @@ yyreduce:
   case 239:
 #line 2169 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4540,8 +4546,8 @@ yyreduce:
   case 240:
 #line 2179 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4551,8 +4557,8 @@ yyreduce:
   case 241:
 #line 2188 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4562,8 +4568,8 @@ yyreduce:
   case 242:
 #line 2198 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4573,7 +4579,7 @@ yyreduce:
   case 243:
 #line 2207 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
     break;
@@ -4581,8 +4587,8 @@ yyreduce:
   case 244:
 #line 2213 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4592,8 +4598,8 @@ yyreduce:
   case 245:
 #line 2222 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4603,8 +4609,8 @@ yyreduce:
   case 246:
 #line 2231 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4614,8 +4620,8 @@ yyreduce:
   case 247:
 #line 2240 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4625,8 +4631,8 @@ yyreduce:
   case 248:
 #line 2249 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4636,8 +4642,8 @@ yyreduce:
   case 249:
 #line 2259 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(6);
-  CHECKEMPTY(6);
+  jpElementStart(6);
+  jpCheckEmpty(6);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4647,7 +4653,7 @@ yyreduce:
   case 250:
 #line 2268 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4657,8 +4663,8 @@ yyreduce:
   case 251:
 #line 2276 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4668,7 +4674,7 @@ yyreduce:
   case 252:
 #line 2285 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4678,8 +4684,8 @@ yyreduce:
   case 253:
 #line 2293 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4689,8 +4695,8 @@ yyreduce:
   case 254:
 #line 2303 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4700,8 +4706,8 @@ yyreduce:
   case 255:
 #line 2312 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4711,8 +4717,8 @@ yyreduce:
   case 256:
 #line 2322 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4722,8 +4728,8 @@ yyreduce:
   case 257:
 #line 2331 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4733,8 +4739,8 @@ yyreduce:
   case 258:
 #line 2340 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4744,8 +4750,8 @@ yyreduce:
   case 259:
 #line 2349 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4755,7 +4761,7 @@ yyreduce:
   case 260:
 #line 2358 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4765,8 +4771,8 @@ yyreduce:
   case 261:
 #line 2366 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4776,8 +4782,8 @@ yyreduce:
   case 262:
 #line 2376 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4787,8 +4793,8 @@ yyreduce:
   case 263:
 #line 2385 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4798,8 +4804,8 @@ yyreduce:
   case 264:
 #line 2395 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4809,7 +4815,7 @@ yyreduce:
   case 265:
 #line 2405 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
+  jpElementStart(2);
 
 }
     break;
@@ -4817,7 +4823,7 @@ yyreduce:
   case 266:
 #line 2411 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
 
 }
     break;
@@ -4825,9 +4831,9 @@ yyreduce:
   case 267:
 #line 2418 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4837,9 +4843,9 @@ yyreduce:
   case 268:
 #line 2428 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4849,9 +4855,9 @@ yyreduce:
   case 269:
 #line 2438 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4861,9 +4867,9 @@ yyreduce:
   case 270:
 #line 2448 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4873,9 +4879,9 @@ yyreduce:
   case 271:
 #line 2459 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4885,10 +4891,10 @@ yyreduce:
   case 272:
 #line 2469 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&(yyvsp[-5].str));
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4898,9 +4904,9 @@ yyreduce:
   case 273:
 #line 2480 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4910,9 +4916,9 @@ yyreduce:
   case 274:
 #line 2490 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4922,9 +4928,9 @@ yyreduce:
   case 275:
 #line 2501 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&(yyvsp[-3].str));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4934,8 +4940,8 @@ yyreduce:
   case 276:
 #line 2511 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4945,8 +4951,8 @@ yyreduce:
   case 277:
 #line 2521 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4956,7 +4962,7 @@ yyreduce:
   case 278:
 #line 2530 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
@@ -4967,8 +4973,8 @@ yyreduce:
   case 279:
 #line 2539 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4978,8 +4984,8 @@ yyreduce:
   case 280:
 #line 2548 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -4989,8 +4995,8 @@ yyreduce:
   case 281:
 #line 2557 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5000,8 +5006,8 @@ yyreduce:
   case 282:
 #line 2567 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5011,8 +5017,8 @@ yyreduce:
   case 283:
 #line 2577 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5022,8 +5028,8 @@ yyreduce:
   case 284:
 #line 2587 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5033,8 +5039,8 @@ yyreduce:
   case 285:
 #line 2596 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5044,8 +5050,8 @@ yyreduce:
   case 286:
 #line 2605 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5055,8 +5061,8 @@ yyreduce:
   case 287:
 #line 2614 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5066,8 +5072,8 @@ yyreduce:
   case 288:
 #line 2623 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5077,8 +5083,8 @@ yyreduce:
   case 289:
 #line 2633 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5088,8 +5094,8 @@ yyreduce:
   case 290:
 #line 2643 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5099,8 +5105,8 @@ yyreduce:
   case 291:
 #line 2653 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5110,8 +5116,8 @@ yyreduce:
   case 292:
 #line 2662 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5121,8 +5127,8 @@ yyreduce:
   case 293:
 #line 2671 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5132,8 +5138,8 @@ yyreduce:
   case 294:
 #line 2680 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5143,8 +5149,8 @@ yyreduce:
   case 295:
 #line 2690 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5154,8 +5160,8 @@ yyreduce:
   case 296:
 #line 2699 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5165,7 +5171,7 @@ yyreduce:
   case 297:
 #line 2708 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
     break;
@@ -5173,8 +5179,8 @@ yyreduce:
   case 298:
 #line 2715 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5184,8 +5190,8 @@ yyreduce:
   case 299:
 #line 2724 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5195,8 +5201,8 @@ yyreduce:
   case 300:
 #line 2733 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5206,8 +5212,8 @@ yyreduce:
   case 301:
 #line 2742 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5217,8 +5223,8 @@ yyreduce:
   case 302:
 #line 2752 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5228,8 +5234,8 @@ yyreduce:
   case 303:
 #line 2761 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5239,8 +5245,8 @@ yyreduce:
   case 304:
 #line 2770 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5250,8 +5256,8 @@ yyreduce:
   case 305:
 #line 2780 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5261,8 +5267,8 @@ yyreduce:
   case 306:
 #line 2789 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5272,8 +5278,8 @@ yyreduce:
   case 307:
 #line 2798 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5283,8 +5289,8 @@ yyreduce:
   case 308:
 #line 2807 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5294,8 +5300,8 @@ yyreduce:
   case 309:
 #line 2817 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5305,8 +5311,8 @@ yyreduce:
   case 310:
 #line 2826 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5316,8 +5322,8 @@ yyreduce:
   case 311:
 #line 2835 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5327,8 +5333,8 @@ yyreduce:
   case 312:
 #line 2844 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5338,8 +5344,8 @@ yyreduce:
   case 313:
 #line 2853 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5349,8 +5355,8 @@ yyreduce:
   case 314:
 #line 2862 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5360,8 +5366,8 @@ yyreduce:
   case 315:
 #line 2872 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5371,8 +5377,8 @@ yyreduce:
   case 316:
 #line 2881 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5382,8 +5388,8 @@ yyreduce:
   case 317:
 #line 2890 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5393,8 +5399,8 @@ yyreduce:
   case 318:
 #line 2900 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5404,8 +5410,8 @@ yyreduce:
   case 319:
 #line 2909 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5415,8 +5421,8 @@ yyreduce:
   case 320:
 #line 2919 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5426,8 +5432,8 @@ yyreduce:
   case 321:
 #line 2928 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5437,8 +5443,8 @@ yyreduce:
   case 322:
 #line 2938 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5448,8 +5454,8 @@ yyreduce:
   case 323:
 #line 2947 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5459,8 +5465,8 @@ yyreduce:
   case 324:
 #line 2957 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5470,8 +5476,8 @@ yyreduce:
   case 325:
 #line 2966 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5481,8 +5487,8 @@ yyreduce:
   case 326:
 #line 2976 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5492,8 +5498,8 @@ yyreduce:
   case 327:
 #line 2985 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5503,8 +5509,8 @@ yyreduce:
   case 328:
 #line 2995 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5514,8 +5520,8 @@ yyreduce:
   case 329:
 #line 3004 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5525,8 +5531,8 @@ yyreduce:
   case 330:
 #line 3014 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5536,8 +5542,8 @@ yyreduce:
   case 331:
 #line 3023 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5547,8 +5553,8 @@ yyreduce:
   case 332:
 #line 3033 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5558,9 +5564,9 @@ yyreduce:
   case 333:
 #line 3043 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&(yyvsp[0].str));
-  CHECKEMPTY(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5570,8 +5576,8 @@ yyreduce:
   case 334:
 #line 3053 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5581,8 +5587,8 @@ yyreduce:
   case 335:
 #line 3062 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5592,8 +5598,8 @@ yyreduce:
   case 336:
 #line 3072 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5603,8 +5609,8 @@ yyreduce:
   case 337:
 #line 3081 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5614,8 +5620,8 @@ yyreduce:
   case 338:
 #line 3090 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5625,8 +5631,8 @@ yyreduce:
   case 339:
 #line 3099 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5636,8 +5642,8 @@ yyreduce:
   case 340:
 #line 3108 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5647,8 +5653,8 @@ yyreduce:
   case 341:
 #line 3117 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5658,8 +5664,8 @@ yyreduce:
   case 342:
 #line 3126 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5669,8 +5675,8 @@ yyreduce:
   case 343:
 #line 3135 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5680,8 +5686,8 @@ yyreduce:
   case 344:
 #line 3144 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5691,8 +5697,8 @@ yyreduce:
   case 345:
 #line 3153 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5702,8 +5708,8 @@ yyreduce:
   case 346:
 #line 3162 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5713,8 +5719,8 @@ yyreduce:
   case 347:
 #line 3171 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5724,8 +5730,8 @@ yyreduce:
   case 348:
 #line 3181 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5735,8 +5741,8 @@ yyreduce:
   case 349:
 #line 3191 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5746,8 +5752,8 @@ yyreduce:
   case 350:
 #line 3201 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5757,9 +5763,9 @@ yyreduce:
   case 351:
 #line 3210 "cmDependsJavaParser.y"
     {
-  ELEMENTSTART(3);
-  STORECLASS(yyvsp[-2].str);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpStoreClass(yyvsp[-2].str);
+  jpCheckEmpty(3);
   yyval.str = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -5770,7 +5776,7 @@ yyreduce:
     }
 
 /* Line 1010 of yacc.c.  */
-#line 5774 "cmDependsJavaParser.cxx"
+#line 5780 "cmDependsJavaParser.cxx"
 
   yyvsp -= yylen;
   yyssp -= yylen;
diff --git a/Source/cmDependsJavaParser.y b/Source/cmDependsJavaParser.y
index 9206ebc72c..5d37d0afa6 100644
--- a/Source/cmDependsJavaParser.y
+++ b/Source/cmDependsJavaParser.y
@@ -51,9 +51,9 @@ static void cmDependsJavaError(yyscan_t yyscanner, const char* message);
 #define YYMAXDEPTH 1000000
 
 
-#define CHECKEMPTY(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
-#define ELEMENTSTART(cnt) yyGetParser->PrepareElement(&yyval)
-#define STORECLASS(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
+#define jpCheckEmpty(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
+#define jpElementStart(cnt) yyGetParser->PrepareElement(&yyval)
+#define jpStoreClass(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
 /* Disable some warnings in the generated code.  */
 #ifdef __BORLANDC__
 # pragma warn -8004 /* Variable assigned a value that is not used.  */
@@ -75,113 +75,113 @@ static void cmDependsJavaError(yyscan_t yyscanner, const char* message);
 
 /*-------------------------------------------------------------------------*/
 /* Tokens */
-%token ABSTRACT
-%token ASSERT
-%token BOOLEAN_TYPE
-%token BREAK
-%token BYTE_TYPE
-%token CASE
-%token CATCH
-%token CHAR_TYPE
-%token CLASS
-%token CONTINUE
-%token DEFAULT
-%token DO
-%token DOUBLE_TYPE
-%token ELSE
-%token EXTENDS
-%token FINAL
-%token FINALLY
-%token FLOAT_TYPE
-%token FOR
-%token IF
-%token IMPLEMENTS
-%token IMPORT
-%token INSTANCEOF
-%token INT_TYPE
-%token INTERFACE
-%token LONG_TYPE
-%token NATIVE
-%token NEW
-%token PACKAGE
-%token PRIVATE
-%token PROTECTED
-%token PUBLIC
-%token RETURN
-%token SHORT_TYPE
-%token STATIC
-%token STRICTFP
-%token SUPER
-%token SWITCH
-%token SYNCHRONIZED
-%token THIS
-%token THROW
-%token THROWS
-%token TRANSIENT
-%token TRY
-%token VOID
-%token VOLATILE
-%token WHILE
-
-%token BOOLEANLITERAL
-%token CHARACTERLITERAL
-%token DECIMALINTEGERLITERAL
-%token FLOATINGPOINTLITERAL
-%token HEXINTEGERLITERAL
-%token NULLLITERAL
-%token STRINGLITERAL
-
-%token NAME
-
-%token AND
-%token ANDAND
-%token ANDEQUALS
-%token BRACKETEND
-%token BRACKETSTART
-%token CARROT
-%token CARROTEQUALS
-%token COLON
-%token COMMA
-%token CURLYEND
-%token CURLYSTART
-%token DIVIDE
-%token DIVIDEEQUALS
-%token DOLLAR
-%token DOT
-%token EQUALS
-%token EQUALSEQUALS
-%token EXCLAMATION
-%token EXCLAMATIONEQUALS
-%token GREATER
-%token GTEQUALS
-%token GTGT
-%token GTGTEQUALS
-%token GTGTGT
-%token GTGTGTEQUALS
-%token LESLESEQUALS
-%token LESSTHAN
-%token LTEQUALS
-%token LTLT
-%token MINUS
-%token MINUSEQUALS
-%token MINUSMINUS
-%token PAREEND
-%token PARESTART
-%token PERCENT
-%token PERCENTEQUALS
-%token PIPE
-%token PIPEEQUALS
-%token PIPEPIPE
-%token PLUS
-%token PLUSEQUALS
-%token PLUSPLUS
-%token QUESTION
-%token SEMICOL
-%token TILDE
-%token TIMES
-%token TIMESEQUALS
-
-%token ERROR
+%token jp_ABSTRACT
+%token jp_ASSERT
+%token jp_BOOLEAN_TYPE
+%token jp_BREAK
+%token jp_BYTE_TYPE
+%token jp_CASE
+%token jp_CATCH
+%token jp_CHAR_TYPE
+%token jp_CLASS
+%token jp_CONTINUE
+%token jp_DEFAULT
+%token jp_DO
+%token jp_DOUBLE_TYPE
+%token jp_ELSE
+%token jp_EXTENDS
+%token jp_FINAL
+%token jp_FINALLY
+%token jp_FLOAT_TYPE
+%token jp_FOR
+%token jp_IF
+%token jp_IMPLEMENTS
+%token jp_IMPORT
+%token jp_INSTANCEOF
+%token jp_INT_TYPE
+%token jp_INTERFACE
+%token jp_LONG_TYPE
+%token jp_NATIVE
+%token jp_NEW
+%token jp_PACKAGE
+%token jp_PRIVATE
+%token jp_PROTECTED
+%token jp_PUBLIC
+%token jp_RETURN
+%token jp_SHORT_TYPE
+%token jp_STATIC
+%token jp_STRICTFP
+%token jp_SUPER
+%token jp_SWITCH
+%token jp_SYNCHRONIZED
+%token jp_THIS
+%token jp_THROW
+%token jp_THROWS
+%token jp_TRANSIENT
+%token jp_TRY
+%token jp_VOID
+%token jp_VOLATILE
+%token jp_WHILE
+
+%token jp_BOOLEANLITERAL
+%token jp_CHARACTERLITERAL
+%token jp_DECIMALINTEGERLITERAL
+%token jp_FLOATINGPOINTLITERAL
+%token jp_HEXINTEGERLITERAL
+%token jp_NULLLITERAL
+%token jp_STRINGLITERAL
+
+%token jp_NAME
+
+%token jp_AND
+%token jp_ANDAND
+%token jp_ANDEQUALS
+%token jp_BRACKETEND
+%token jp_BRACKETSTART
+%token jp_CARROT
+%token jp_CARROTEQUALS
+%token jp_COLON
+%token jp_COMMA
+%token jp_CURLYEND
+%token jp_CURLYSTART
+%token jp_DIVIDE
+%token jp_DIVIDEEQUALS
+%token jp_DOLLAR
+%token jp_DOT
+%token jp_EQUALS
+%token jp_EQUALSEQUALS
+%token jp_EXCLAMATION
+%token jp_EXCLAMATIONEQUALS
+%token jp_GREATER
+%token jp_GTEQUALS
+%token jp_GTGT
+%token jp_GTGTEQUALS
+%token jp_GTGTGT
+%token jp_GTGTGTEQUALS
+%token jp_LESLESEQUALS
+%token jp_LESSTHAN
+%token jp_LTEQUALS
+%token jp_LTLT
+%token jp_MINUS
+%token jp_MINUSEQUALS
+%token jp_MINUSMINUS
+%token jp_PAREEND
+%token jp_PARESTART
+%token jp_PERCENT
+%token jp_PERCENTEQUALS
+%token jp_PIPE
+%token jp_PIPEEQUALS
+%token jp_PIPEPIPE
+%token jp_PLUS
+%token jp_PLUSEQUALS
+%token jp_PLUSPLUS
+%token jp_QUESTION
+%token jp_SEMICOL
+%token jp_TILDE
+%token jp_TIMES
+%token jp_TIMESEQUALS
+
+%token jp_ERROR
 
 /*-------------------------------------------------------------------------*/
 /* grammar */
@@ -190,8 +190,8 @@ static void cmDependsJavaError(yyscan_t yyscanner, const char* message);
 Goal:
 CompilationUnit
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -199,65 +199,65 @@ CompilationUnit
 Literal:
 IntegerLiteral
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-FLOATINGPOINTLITERAL
+jp_FLOATINGPOINTLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-BOOLEANLITERAL
+jp_BOOLEANLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-CHARACTERLITERAL
+jp_CHARACTERLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-STRINGLITERAL
+jp_STRINGLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-NULLLITERAL
+jp_NULLLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 IntegerLiteral:
-DECIMALINTEGERLITERAL
+jp_DECIMALINTEGERLITERAL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-HEXINTEGERLITERAL	
+jp_HEXINTEGERLITERAL	
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -265,74 +265,74 @@ HEXINTEGERLITERAL
 Type:
 PrimitiveType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ReferenceType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 PrimitiveType:
-BYTE_TYPE
+jp_BYTE_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-SHORT_TYPE
+jp_SHORT_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-INT_TYPE
+jp_INT_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-LONG_TYPE
+jp_LONG_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-CHAR_TYPE
+jp_CHAR_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-FLOAT_TYPE
+jp_FLOAT_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-DOUBLE_TYPE
+jp_DOUBLE_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 |
-BOOLEAN_TYPE
+jp_BOOLEAN_TYPE
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
 }
 
 ReferenceType:
 ClassOrInterfaceType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ArrayType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -340,9 +340,9 @@ ArrayType
 ClassOrInterfaceType:
 Name
 {
-  ELEMENTSTART(1);
-  STORECLASS($<str>1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -350,8 +350,8 @@ Name
 ClassType:
 ClassOrInterfaceType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -359,8 +359,8 @@ ClassOrInterfaceType
 InterfaceType:
 ClassOrInterfaceType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -368,17 +368,17 @@ ClassOrInterfaceType
 ArrayType:
 PrimitiveType Dims
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 Name Dims
 {
-  ELEMENTSTART(2);
-  STORECLASS($<str>1);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -386,70 +386,70 @@ Name Dims
 Name:
 SimpleName
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = $<str>1;
 }
 |
 QualifiedName
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = $<str>1;
 }
 
 SimpleName:
 Identifier
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = $<str>1;
 }
 
 Identifier:
-NAME
+jp_NAME
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = $<str>1;
 }
 |
-DOLLAR NAME
+jp_DOLLAR jp_NAME
 {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   $<str>$ = $<str>2;
 }
 
 QualifiedName:
-Name DOT Identifier
+Name jp_DOT Identifier
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->AddClassFound($<str>1);
   yyGetParser->UpdateCombine($<str>1, $<str>3);
   yyGetParser->DeallocateParserType(&($<str>1));
   $<str>$ = const_cast<char*>(yyGetParser->GetCurrentCombine());
 }
 |
-Name DOT CLASS
+Name jp_DOT jp_CLASS
 {
-  ELEMENTSTART(3);
-  STORECLASS($<str>1);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(3);
   yyGetParser->SetCurrentCombine("");
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-Name DOT THIS
+Name jp_DOT jp_THIS
 {
-  ELEMENTSTART(3);
-  STORECLASS($<str>1);
+  jpElementStart(3);
+  jpStoreClass($<str>1);
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-SimpleType DOT CLASS
+SimpleType jp_DOT jp_CLASS
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -457,16 +457,16 @@ SimpleType DOT CLASS
 SimpleType:
 PrimitiveType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-VOID
+jp_VOID
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -474,65 +474,65 @@ VOID
 CompilationUnit:
 PackageDeclarationopt ImportDeclarations TypeDeclarations
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 PackageDeclarationopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 PackageDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 ImportDeclarations:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ImportDeclarations ImportDeclaration
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 TypeDeclarations:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 TypeDeclarations TypeDeclaration
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 PackageDeclaration:
-PACKAGE Name SEMICOL
+jp_PACKAGE Name jp_SEMICOL
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->SetCurrentPackage($<str>2);
   yyGetParser->DeallocateParserType(&($<str>2));
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -540,36 +540,36 @@ PACKAGE Name SEMICOL
 ImportDeclaration:
 SingleTypeImportDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 TypeImportOnDemandDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 SingleTypeImportDeclaration:
-IMPORT Name SEMICOL
+jp_IMPORT Name jp_SEMICOL
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->AddPackagesImport($<str>2);
   yyGetParser->DeallocateParserType(&($<str>2));
   yyGetParser->SetCurrentCombine("");
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 TypeImportOnDemandDeclaration:
-IMPORT Name DOT TIMES SEMICOL
+jp_IMPORT Name jp_DOT jp_TIMES jp_SEMICOL
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
   std::string str = $<str>2;
   str += ".*";
   yyGetParser->AddPackagesImport(str.c_str());
@@ -582,24 +582,24 @@ IMPORT Name DOT TIMES SEMICOL
 TypeDeclaration:
 ClassDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 InterfaceDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-SEMICOL
+jp_SEMICOL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -607,41 +607,41 @@ SEMICOL
 Modifiers:
 Modifier
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 Modifiers Modifier
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 Modifier:
-PUBLIC | PROTECTED | PRIVATE |
-STATIC |
-ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE |
-STRICTFP
+jp_PUBLIC | jp_PROTECTED | jp_PRIVATE |
+jp_STATIC |
+jp_ABSTRACT | jp_FINAL | jp_NATIVE | jp_SYNCHRONIZED | jp_TRANSIENT | jp_VOLATILE |
+jp_STRICTFP
 
 ClassHeader:
-Modifiersopt CLASS Identifier
+Modifiersopt jp_CLASS Identifier
 {
   yyGetParser->StartClass($<str>3);
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
 }
 
 
 ClassDeclaration:
 ClassHeader ClassBody
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -649,8 +649,8 @@ ClassHeader ClassBody
 |
 ClassHeader Interfaces ClassBody
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(2);
+  jpElementStart(3);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -658,8 +658,8 @@ ClassHeader Interfaces ClassBody
 |
 ClassHeader Super ClassBody
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -667,8 +667,8 @@ ClassHeader Super ClassBody
 |
 ClassHeader Super Interfaces ClassBody
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -676,33 +676,33 @@ ClassHeader Super Interfaces ClassBody
 
 Modifiersopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 Modifiers
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 Super:
-EXTENDS ClassType
+jp_EXTENDS ClassType
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 Interfaces:
-IMPLEMENTS InterfaceTypeList
+jp_IMPLEMENTS InterfaceTypeList
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -710,40 +710,40 @@ IMPLEMENTS InterfaceTypeList
 InterfaceTypeList:
 InterfaceType
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-InterfaceTypeList COMMA InterfaceType
+InterfaceTypeList jp_COMMA InterfaceType
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 ClassBody:
-CURLYSTART ClassBodyDeclarations CURLYEND
+jp_CURLYSTART ClassBodyDeclarations jp_CURLYEND
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 ClassBodyDeclarations:
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ClassBodyDeclarations ClassBodyDeclaration
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -751,32 +751,32 @@ ClassBodyDeclarations ClassBodyDeclaration
 ClassBodyDeclaration:
 ClassMemberDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 StaticInitializer
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ConstructorDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 TypeDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -784,39 +784,39 @@ TypeDeclaration
 ClassMemberDeclaration:
 FieldDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 MethodDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 FieldDeclaration:
-Modifiersopt Type VariableDeclarators SEMICOL
+Modifiersopt Type VariableDeclarators jp_SEMICOL
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
 }
 
 VariableDeclarators:
 VariableDeclarator
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-VariableDeclarators COMMA VariableDeclarator
+VariableDeclarators jp_COMMA VariableDeclarator
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -824,16 +824,16 @@ VariableDeclarators COMMA VariableDeclarator
 VariableDeclarator:
 VariableDeclaratorId
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-VariableDeclaratorId EQUALS VariableInitializer
+VariableDeclaratorId jp_EQUALS VariableInitializer
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -841,17 +841,17 @@ VariableDeclaratorId EQUALS VariableInitializer
 VariableDeclaratorId:
 Identifier
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-VariableDeclaratorId BRACKETSTART BRACKETEND
+VariableDeclaratorId jp_BRACKETSTART jp_BRACKETEND
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -859,41 +859,41 @@ VariableDeclaratorId BRACKETSTART BRACKETEND
 VariableInitializer:
 Expression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ArrayInitializer
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 
 MethodDeclaration:
-MethodHeader SEMICOL
+MethodHeader jp_SEMICOL
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 MethodHeader MethodBody
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
-MethodHeader MethodBody SEMICOL
+MethodHeader MethodBody jp_SEMICOL
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
@@ -901,17 +901,17 @@ MethodHeader MethodBody SEMICOL
 MethodHeader:
 Modifiersopt Type MethodDeclarator Throwsopt
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Modifiersopt VOID MethodDeclarator Throwsopt
+Modifiersopt jp_VOID MethodDeclarator Throwsopt
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -919,7 +919,7 @@ Modifiersopt VOID MethodDeclarator Throwsopt
 
 Throwsopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -927,33 +927,33 @@ Throwsopt:
 |
 Throws
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 MethodDeclarator:
-Identifier PARESTART FormalParameterListopt PAREEND
+Identifier jp_PARESTART FormalParameterListopt jp_PAREEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MethodDeclarator BRACKETSTART BRACKETEND
+MethodDeclarator jp_BRACKETSTART jp_BRACKETEND
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
 
 }
 
 FormalParameterListopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -964,14 +964,14 @@ FormalParameterList
 FormalParameterList:
 FormalParameter
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
 |
-FormalParameterList COMMA FormalParameter
+FormalParameterList jp_COMMA FormalParameter
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -980,18 +980,18 @@ FormalParameterList COMMA FormalParameter
 FormalParameter:
 Modifiersopt Type VariableDeclaratorId
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 Throws:
-THROWS ClassTypeList
+jp_THROWS ClassTypeList
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1000,14 +1000,14 @@ THROWS ClassTypeList
 ClassTypeList:
 ClassType
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
 |
-ClassTypeList COMMA ClassType
+ClassTypeList jp_COMMA ClassType
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1016,18 +1016,18 @@ ClassTypeList COMMA ClassType
 MethodBody:
 Block
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 StaticInitializer:
-STATIC Block
+jp_STATIC Block
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1036,38 +1036,38 @@ STATIC Block
 ConstructorDeclaration:
 Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody SEMICOL
+Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody jp_SEMICOL
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ConstructorDeclarator:
-SimpleName PARESTART FormalParameterListopt PAREEND
+SimpleName jp_PARESTART FormalParameterListopt jp_PAREEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ConstructorBody:
-CURLYSTART ExplicitConstructorInvocationopt BlockStatementsopt CURLYEND
+jp_CURLYSTART ExplicitConstructorInvocationopt BlockStatementsopt jp_CURLYEND
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1075,7 +1075,7 @@ CURLYSTART ExplicitConstructorInvocationopt BlockStatementsopt CURLYEND
 
 ExplicitConstructorInvocationopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1083,46 +1083,46 @@ ExplicitConstructorInvocationopt:
 |
 ExplicitConstructorInvocationopt ExplicitConstructorInvocation
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ExplicitConstructorInvocation:
-THIS PARESTART ArgumentListopt PAREEND SEMICOL
+jp_THIS jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-SUPER PARESTART ArgumentListopt PAREEND SEMICOL
+jp_SUPER jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 InterfaceHeader:
-Modifiersopt INTERFACE Identifier
+Modifiersopt jp_INTERFACE Identifier
 {
   yyGetParser->StartClass($<str>3);
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
 }
 
 InterfaceDeclaration:
 InterfaceHeader ExtendsInterfacesopt InterfaceBody
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
   yyGetParser->EndClass();
@@ -1130,44 +1130,44 @@ InterfaceHeader ExtendsInterfacesopt InterfaceBody
 
 ExtendsInterfacesopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 }
 |
 ExtendsInterfaces
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ExtendsInterfaces:
-EXTENDS InterfaceType
+jp_EXTENDS InterfaceType
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ExtendsInterfaces COMMA InterfaceType
+ExtendsInterfaces jp_COMMA InterfaceType
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 InterfaceBody:
-CURLYSTART InterfaceMemberDeclarations CURLYEND
+jp_CURLYSTART InterfaceMemberDeclarations jp_CURLYEND
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1175,7 +1175,7 @@ CURLYSTART InterfaceMemberDeclarations CURLYEND
 
 InterfaceMemberDeclarations:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1183,7 +1183,7 @@ InterfaceMemberDeclarations:
 |
 InterfaceMemberDeclarations InterfaceMemberDeclaration
 {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1192,8 +1192,8 @@ InterfaceMemberDeclarations InterfaceMemberDeclaration
 InterfaceMemberDeclaration:
 ConstantDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1201,8 +1201,8 @@ ConstantDeclaration
 |
 AbstractMethodDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1210,16 +1210,16 @@ AbstractMethodDeclaration
 |
 ClassDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ClassDeclaration SEMICOL
+ClassDeclaration jp_SEMICOL
 {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1227,16 +1227,16 @@ ClassDeclaration SEMICOL
 |
 InterfaceDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-InterfaceDeclaration SEMICOL
+InterfaceDeclaration jp_SEMICOL
 {
-  ELEMENTSTART(2);
+  jpElementStart(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1245,8 +1245,8 @@ InterfaceDeclaration SEMICOL
 ConstantDeclaration:
 FieldDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1255,37 +1255,37 @@ FieldDeclaration
 AbstractMethodDeclaration:
 MethodHeader Semicols
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 Semicols:
-SEMICOL
+jp_SEMICOL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Semicols SEMICOL
+Semicols jp_SEMICOL
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ArrayInitializer:
-CURLYSTART VariableInitializersOptional CURLYEND
+jp_CURLYSTART VariableInitializersOptional jp_CURLYEND
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1293,7 +1293,7 @@ CURLYSTART VariableInitializersOptional CURLYEND
 
 VariableInitializersOptional:
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1301,17 +1301,17 @@ VariableInitializersOptional:
 |
 VariableInitializers
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-VariableInitializers COMMA
+VariableInitializers jp_COMMA
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1320,26 +1320,26 @@ VariableInitializers COMMA
 VariableInitializers:
 VariableInitializer
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-VariableInitializers COMMA VariableInitializer
+VariableInitializers jp_COMMA VariableInitializer
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 Block:
-CURLYSTART BlockStatementsopt CURLYEND
+jp_CURLYSTART BlockStatementsopt jp_CURLYEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1347,7 +1347,7 @@ CURLYSTART BlockStatementsopt CURLYEND
 
 BlockStatementsopt:
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1355,8 +1355,8 @@ BlockStatementsopt:
 |
 BlockStatements
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1365,8 +1365,8 @@ BlockStatements
 BlockStatements:
 BlockStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1374,8 +1374,8 @@ BlockStatement
 |
 BlockStatements BlockStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1384,8 +1384,8 @@ BlockStatements BlockStatement
 BlockStatement:
 LocalVariableDeclarationStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1393,8 +1393,8 @@ LocalVariableDeclarationStatement
 |
 Statement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1402,18 +1402,18 @@ Statement
 |
 ClassDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 LocalVariableDeclarationStatement:
-LocalVariableDeclaration SEMICOL
+LocalVariableDeclaration jp_SEMICOL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1422,8 +1422,8 @@ LocalVariableDeclaration SEMICOL
 LocalVariableDeclaration:
 Modifiers Type VariableDeclarators
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(3);
+  jpElementStart(1);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1431,8 +1431,8 @@ Modifiers Type VariableDeclarators
 |
 Type VariableDeclarators
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(2);
+  jpElementStart(1);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1441,8 +1441,8 @@ Type VariableDeclarators
 Statement:
 StatementWithoutTrailingSubstatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1450,8 +1450,8 @@ StatementWithoutTrailingSubstatement
 |
 LabeledStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1459,8 +1459,8 @@ LabeledStatement
 |
 IfThenStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1468,8 +1468,8 @@ IfThenStatement
 |
 IfThenElseStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1477,8 +1477,8 @@ IfThenElseStatement
 |
 WhileStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1486,8 +1486,8 @@ WhileStatement
 |
 ForStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1496,8 +1496,8 @@ ForStatement
 StatementNoShortIf:
 StatementWithoutTrailingSubstatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1505,8 +1505,8 @@ StatementWithoutTrailingSubstatement
 |
 LabeledStatementNoShortIf
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1514,8 +1514,8 @@ LabeledStatementNoShortIf
 |
 IfThenElseStatementNoShortIf
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1523,8 +1523,8 @@ IfThenElseStatementNoShortIf
 |
 WhileStatementNoShortIf
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1532,8 +1532,8 @@ WhileStatementNoShortIf
 |
 ForStatementNoShortIf
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1542,8 +1542,8 @@ ForStatementNoShortIf
 StatementWithoutTrailingSubstatement:
 Block
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1551,8 +1551,8 @@ Block
 |
 EmptyStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1560,8 +1560,8 @@ EmptyStatement
 |
 ExpressionStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1569,8 +1569,8 @@ ExpressionStatement
 |
 SwitchStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1578,8 +1578,8 @@ SwitchStatement
 |
 DoStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1587,8 +1587,8 @@ DoStatement
 |
 BreakStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1596,8 +1596,8 @@ BreakStatement
 |
 ContinueStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1605,8 +1605,8 @@ ContinueStatement
 |
 ReturnStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1614,8 +1614,8 @@ ReturnStatement
 |
 SynchronizedStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1623,8 +1623,8 @@ SynchronizedStatement
 |
 ThrowStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1632,8 +1632,8 @@ ThrowStatement
 |
 TryStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1641,49 +1641,49 @@ TryStatement
 |
 AssertStatement
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 EmptyStatement:
-SEMICOL
+jp_SEMICOL
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 LabeledStatement:
-Identifier COLON Statement
+Identifier jp_COLON Statement
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 LabeledStatementNoShortIf:
-Identifier COLON StatementNoShortIf
+Identifier jp_COLON StatementNoShortIf
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ExpressionStatement:
-StatementExpression SEMICOL
+StatementExpression jp_SEMICOL
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1692,8 +1692,8 @@ StatementExpression SEMICOL
 StatementExpression:
 Assignment
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1701,8 +1701,8 @@ Assignment
 |
 PreIncrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1710,8 +1710,8 @@ PreIncrementExpression
 |
 PreDecrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1719,8 +1719,8 @@ PreDecrementExpression
 |
 PostIncrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1728,8 +1728,8 @@ PostIncrementExpression
 |
 PostDecrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1737,8 +1737,8 @@ PostDecrementExpression
 |
 MethodInvocation
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1746,60 +1746,60 @@ MethodInvocation
 |
 ClassInstanceCreationExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 IfThenStatement:
-IF PARESTART Expression PAREEND Statement
+jp_IF jp_PARESTART Expression jp_PAREEND Statement
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 IfThenElseStatement:
-IF PARESTART Expression PAREEND StatementNoShortIf ELSE Statement
+jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE Statement
 {
-  ELEMENTSTART(7);
-  CHECKEMPTY(7);
+  jpElementStart(7);
+  jpCheckEmpty(7);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 IfThenElseStatementNoShortIf:
-IF PARESTART Expression PAREEND StatementNoShortIf ELSE StatementNoShortIf
+jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE StatementNoShortIf
 {
-  ELEMENTSTART(7);
-  CHECKEMPTY(7);
+  jpElementStart(7);
+  jpCheckEmpty(7);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 SwitchStatement:
-SWITCH PARESTART Expression PAREEND SwitchBlock
+jp_SWITCH jp_PARESTART Expression jp_PAREEND SwitchBlock
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
 
 SwitchBlock:
-CURLYSTART SwitchBlockStatementGroups SwitchLabelsopt CURLYEND
+jp_CURLYSTART SwitchBlockStatementGroups SwitchLabelsopt jp_CURLYEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
 
 }
 
 SwitchLabelsopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1807,8 +1807,8 @@ SwitchLabelsopt:
 |
 SwitchLabels
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1816,7 +1816,7 @@ SwitchLabels
 
 SwitchBlockStatementGroups:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1824,8 +1824,8 @@ SwitchBlockStatementGroups:
 |
 SwitchBlockStatementGroups SwitchBlockStatementGroup
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1834,8 +1834,8 @@ SwitchBlockStatementGroups SwitchBlockStatementGroup
 SwitchBlockStatementGroup:
 SwitchLabels BlockStatements
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1844,8 +1844,8 @@ SwitchLabels BlockStatements
 SwitchLabels:
 SwitchLabel
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1853,64 +1853,64 @@ SwitchLabel
 |
 SwitchLabels SwitchLabel
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 SwitchLabel:
-CASE ConstantExpression COLON
+jp_CASE ConstantExpression jp_COLON
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-DEFAULT COLON
+jp_DEFAULT jp_COLON
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 WhileStatement:
-WHILE PARESTART Expression PAREEND Statement
+jp_WHILE jp_PARESTART Expression jp_PAREEND Statement
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
 
 WhileStatementNoShortIf:
-WHILE PARESTART Expression PAREEND StatementNoShortIf
+jp_WHILE jp_PARESTART Expression jp_PAREEND StatementNoShortIf
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
 
 DoStatement:
-DO Statement WHILE PARESTART Expression PAREEND SEMICOL
+jp_DO Statement jp_WHILE jp_PARESTART Expression jp_PAREEND jp_SEMICOL
 {
-  ELEMENTSTART(7);
+  jpElementStart(7);
 
 }
 
 ForStatement:
-FOR PARESTART ForInitopt SEMICOL Expressionopt SEMICOL ForUpdateopt PAREEND
+jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
 Statement
 {
-  ELEMENTSTART(9);
+  jpElementStart(9);
 
 }
 
 ForUpdateopt:
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1918,8 +1918,8 @@ ForUpdateopt:
 |
 ForUpdate
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1927,7 +1927,7 @@ ForUpdate
 
 ForInitopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1935,18 +1935,18 @@ ForInitopt:
 |
 ForInit
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ForStatementNoShortIf:
-FOR PARESTART ForInitopt SEMICOL Expressionopt SEMICOL ForUpdateopt PAREEND
+jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
 StatementNoShortIf
 {
-  ELEMENTSTART(9);
+  jpElementStart(9);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1954,7 +1954,7 @@ StatementNoShortIf
 
 Expressionopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1962,8 +1962,8 @@ Expressionopt:
 |
 Expression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1972,8 +1972,8 @@ Expression
 ForInit:
 StatementExpressionList
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1981,8 +1981,8 @@ StatementExpressionList
 |
 LocalVariableDeclaration
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -1991,8 +1991,8 @@ LocalVariableDeclaration
 ForUpdate:
 StatementExpressionList
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2001,47 +2001,47 @@ StatementExpressionList
 StatementExpressionList:
 StatementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-StatementExpressionList COMMA StatementExpression
+StatementExpressionList jp_COMMA StatementExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 AssertStatement:
-ASSERT Expression SEMICOL
+jp_ASSERT Expression jp_SEMICOL
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ASSERT Expression COLON Expression SEMICOL
+jp_ASSERT Expression jp_COLON Expression jp_SEMICOL
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 BreakStatement:
-BREAK Identifieropt SEMICOL
+jp_BREAK Identifieropt jp_SEMICOL
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>2));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2049,7 +2049,7 @@ BREAK Identifieropt SEMICOL
 
 Identifieropt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2057,65 +2057,65 @@ Identifieropt:
 |
 Identifier
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
 
 ContinueStatement:
-CONTINUE Identifieropt SEMICOL
+jp_CONTINUE Identifieropt jp_SEMICOL
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>2));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ReturnStatement:
-RETURN Expressionopt SEMICOL
+jp_RETURN Expressionopt jp_SEMICOL
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ThrowStatement:
-THROW Expression SEMICOL
+jp_THROW Expression jp_SEMICOL
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 SynchronizedStatement:
-SYNCHRONIZED PARESTART Expression PAREEND Block
+jp_SYNCHRONIZED jp_PARESTART Expression jp_PAREEND Block
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 TryStatement:
-TRY Block Catches
+jp_TRY Block Catches
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-TRY Block Catchesopt Finally
+jp_TRY Block Catchesopt Finally
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2123,7 +2123,7 @@ TRY Block Catchesopt Finally
 
 Catchesopt:
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2131,8 +2131,8 @@ Catchesopt:
 |
 Catches
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2141,8 +2141,8 @@ Catches
 Catches:
 CatchClause
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2150,25 +2150,25 @@ CatchClause
 |
 Catches CatchClause
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 CatchClause:
-CATCH PARESTART FormalParameter PAREEND Block
+jp_CATCH jp_PARESTART FormalParameter jp_PAREEND Block
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
 
 Finally:
-FINALLY Block
+jp_FINALLY Block
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2177,8 +2177,8 @@ FINALLY Block
 Primary:
 PrimaryNoNewArray
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2186,8 +2186,8 @@ PrimaryNoNewArray
 |
 ArrayCreationExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2196,23 +2196,23 @@ ArrayCreationExpression
 PrimaryNoNewArray:
 Literal
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-THIS
+jp_THIS
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
 
 }
 |
-PARESTART Expression PAREEND
+jp_PARESTART Expression jp_PAREEND
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2220,8 +2220,8 @@ PARESTART Expression PAREEND
 |
 ClassInstanceCreationExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2229,8 +2229,8 @@ ClassInstanceCreationExpression
 |
 FieldAccess
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2238,8 +2238,8 @@ FieldAccess
 |
 MethodInvocation
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2247,18 +2247,18 @@ MethodInvocation
 |
 ArrayAccess
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ClassInstanceCreationExpression:
-New ClassType PARESTART ArgumentListopt PAREEND ClassBodyOpt
+New ClassType jp_PARESTART ArgumentListopt jp_PAREEND ClassBodyOpt
 {
-  ELEMENTSTART(6);
-  CHECKEMPTY(6);
+  jpElementStart(6);
+  jpCheckEmpty(6);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2266,7 +2266,7 @@ New ClassType PARESTART ArgumentListopt PAREEND ClassBodyOpt
 
 ClassBodyOpt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2274,8 +2274,8 @@ ClassBodyOpt:
 |
 ClassBody
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2283,7 +2283,7 @@ ClassBody
 
 ArgumentListopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2291,8 +2291,8 @@ ArgumentListopt:
 |
 ArgumentList
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2301,17 +2301,17 @@ ArgumentList
 ArgumentList:
 Expression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ArgumentList COMMA Expression
+ArgumentList jp_COMMA Expression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2320,8 +2320,8 @@ ArgumentList COMMA Expression
 ArrayCreationExpression:
 New PrimitiveType DimExprs Dimsopt
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2329,8 +2329,8 @@ New PrimitiveType DimExprs Dimsopt
 |
 New ClassOrInterfaceType DimExprs Dimsopt
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2338,8 +2338,8 @@ New ClassOrInterfaceType DimExprs Dimsopt
 |
 New PrimitiveType Dims ArrayInitializer
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2347,8 +2347,8 @@ New PrimitiveType Dims ArrayInitializer
 |
 New ClassOrInterfaceType Dims ArrayInitializer
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2356,7 +2356,7 @@ New ClassOrInterfaceType Dims ArrayInitializer
 
 Dimsopt:
 {
-  ELEMENTSTART(0);
+  jpElementStart(0);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2364,8 +2364,8 @@ Dimsopt:
 |
 Dims
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2374,8 +2374,8 @@ Dims
 DimExprs:
 DimExpr
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2383,134 +2383,134 @@ DimExpr
 |
 DimExprs DimExpr
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 DimExpr:
-BRACKETSTART Expression BRACKETEND
+jp_BRACKETSTART Expression jp_BRACKETEND
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 Dims:
-BRACKETSTART BRACKETEND
+jp_BRACKETSTART jp_BRACKETEND
 {
-  ELEMENTSTART(2);
+  jpElementStart(2);
 
 }
 |
-Dims BRACKETSTART BRACKETEND
+Dims jp_BRACKETSTART jp_BRACKETEND
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
 
 }
 
 FieldAccess:
-Primary DOT Identifier
+Primary jp_DOT Identifier
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-SUPER DOT Identifier
+jp_SUPER jp_DOT Identifier
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-THIS DOT Identifier
+jp_THIS jp_DOT Identifier
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Primary DOT THIS
+Primary jp_DOT jp_THIS
 {
-  ELEMENTSTART(3);
+  jpElementStart(3);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 MethodInvocation:
-Name PARESTART ArgumentListopt PAREEND
+Name jp_PARESTART ArgumentListopt jp_PAREEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Primary DOT Identifier PARESTART ArgumentListopt PAREEND
+Primary jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
 {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&($<str>1));
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-SUPER DOT Identifier PARESTART ArgumentListopt PAREEND
+jp_SUPER jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
 {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-THIS DOT Identifier PARESTART ArgumentListopt PAREEND
+jp_THIS jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
 {
-  ELEMENTSTART(6);
+  jpElementStart(6);
   yyGetParser->DeallocateParserType(&($<str>3));
-  CHECKEMPTY(6);
+  jpCheckEmpty(6);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 ArrayAccess:
-Name BRACKETSTART Expression BRACKETEND
+Name jp_BRACKETSTART Expression jp_BRACKETEND
 {
-  ELEMENTSTART(4);
+  jpElementStart(4);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PrimaryNoNewArray BRACKETSTART Expression BRACKETEND
+PrimaryNoNewArray jp_BRACKETSTART Expression jp_BRACKETEND
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2519,8 +2519,8 @@ PrimaryNoNewArray BRACKETSTART Expression BRACKETEND
 PostfixExpression:
 Primary
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2528,17 +2528,17 @@ Primary
 |
 Name
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&($<str>1));
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ArrayType DOT CLASS
+ArrayType jp_DOT jp_CLASS
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2546,8 +2546,8 @@ ArrayType DOT CLASS
 |
 PostIncrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2555,28 +2555,28 @@ PostIncrementExpression
 |
 PostDecrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 PostIncrementExpression:
-PostfixExpression PLUSPLUS
+PostfixExpression jp_PLUSPLUS
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 PostDecrementExpression:
-PostfixExpression MINUSMINUS
+PostfixExpression jp_MINUSMINUS
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2585,8 +2585,8 @@ PostfixExpression MINUSMINUS
 UnaryExpression:
 PreIncrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2594,26 +2594,26 @@ PreIncrementExpression
 |
 PreDecrementExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PLUS UnaryExpression
+jp_PLUS UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MINUS UnaryExpression
+jp_MINUS UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2621,28 +2621,28 @@ MINUS UnaryExpression
 |
 UnaryExpressionNotPlusMinus
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 PreIncrementExpression:
-PLUSPLUS UnaryExpression
+jp_PLUSPLUS UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 PreDecrementExpression:
-MINUSMINUS UnaryExpression
+jp_MINUSMINUS UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2651,26 +2651,26 @@ MINUSMINUS UnaryExpression
 UnaryExpressionNotPlusMinus:
 PostfixExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-TILDE UnaryExpression
+jp_TILDE UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-EXCLAMATION UnaryExpression
+jp_EXCLAMATION UnaryExpression
 {
-  ELEMENTSTART(2);
-  CHECKEMPTY(2);
+  jpElementStart(2);
+  jpCheckEmpty(2);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2678,70 +2678,70 @@ EXCLAMATION UnaryExpression
 |
 CastExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 CastExpression:
-PARESTART PrimitiveType Dimsopt PAREEND UnaryExpression
+jp_PARESTART PrimitiveType Dimsopt jp_PAREEND UnaryExpression
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PARESTART Expression PAREEND UnaryExpressionNotPlusMinus
+jp_PARESTART Expression jp_PAREEND UnaryExpressionNotPlusMinus
 {
-  ELEMENTSTART(4);
-  CHECKEMPTY(4);
+  jpElementStart(4);
+  jpCheckEmpty(4);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PARESTART Name Dims PAREEND UnaryExpressionNotPlusMinus
+jp_PARESTART Name Dims jp_PAREEND UnaryExpressionNotPlusMinus
 {
-  ELEMENTSTART(5);
+  jpElementStart(5);
 
 }
 
 MultiplicativeExpression:
 UnaryExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MultiplicativeExpression TIMES UnaryExpression
+MultiplicativeExpression jp_TIMES UnaryExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MultiplicativeExpression DIVIDE UnaryExpression
+MultiplicativeExpression jp_DIVIDE UnaryExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MultiplicativeExpression PERCENT UnaryExpression
+MultiplicativeExpression jp_PERCENT UnaryExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2750,26 +2750,26 @@ MultiplicativeExpression PERCENT UnaryExpression
 AdditiveExpression:
 MultiplicativeExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-AdditiveExpression PLUS MultiplicativeExpression
+AdditiveExpression jp_PLUS MultiplicativeExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-AdditiveExpression MINUS MultiplicativeExpression
+AdditiveExpression jp_MINUS MultiplicativeExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2778,35 +2778,35 @@ AdditiveExpression MINUS MultiplicativeExpression
 ShiftExpression:
 AdditiveExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ShiftExpression LTLT AdditiveExpression
+ShiftExpression jp_LTLT AdditiveExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ShiftExpression GTGT AdditiveExpression
+ShiftExpression jp_GTGT AdditiveExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ShiftExpression GTGTGT AdditiveExpression
+ShiftExpression jp_GTGTGT AdditiveExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2815,53 +2815,53 @@ ShiftExpression GTGTGT AdditiveExpression
 RelationalExpression:
 ShiftExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-RelationalExpression LESSTHAN ShiftExpression
+RelationalExpression jp_LESSTHAN ShiftExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-RelationalExpression GREATER ShiftExpression
+RelationalExpression jp_GREATER ShiftExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-RelationalExpression LTEQUALS ShiftExpression
+RelationalExpression jp_LTEQUALS ShiftExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-RelationalExpression GTEQUALS ShiftExpression
+RelationalExpression jp_GTEQUALS ShiftExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-RelationalExpression INSTANCEOF ReferenceType
+RelationalExpression jp_INSTANCEOF ReferenceType
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2870,26 +2870,26 @@ RelationalExpression INSTANCEOF ReferenceType
 EqualityExpression:
 RelationalExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-EqualityExpression EQUALSEQUALS RelationalExpression
+EqualityExpression jp_EQUALSEQUALS RelationalExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-EqualityExpression EXCLAMATIONEQUALS RelationalExpression
+EqualityExpression jp_EXCLAMATIONEQUALS RelationalExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2898,17 +2898,17 @@ EqualityExpression EXCLAMATIONEQUALS RelationalExpression
 AndExpression:
 EqualityExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-AndExpression AND EqualityExpression
+AndExpression jp_AND EqualityExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2917,17 +2917,17 @@ AndExpression AND EqualityExpression
 ExclusiveOrExpression:
 AndExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ExclusiveOrExpression CARROT AndExpression
+ExclusiveOrExpression jp_CARROT AndExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2936,17 +2936,17 @@ ExclusiveOrExpression CARROT AndExpression
 InclusiveOrExpression:
 ExclusiveOrExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-InclusiveOrExpression PIPE ExclusiveOrExpression
+InclusiveOrExpression jp_PIPE ExclusiveOrExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2955,17 +2955,17 @@ InclusiveOrExpression PIPE ExclusiveOrExpression
 ConditionalAndExpression:
 InclusiveOrExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ConditionalAndExpression ANDAND InclusiveOrExpression
+ConditionalAndExpression jp_ANDAND InclusiveOrExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2974,17 +2974,17 @@ ConditionalAndExpression ANDAND InclusiveOrExpression
 ConditionalOrExpression:
 ConditionalAndExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ConditionalOrExpression PIPEPIPE ConditionalAndExpression
+ConditionalOrExpression jp_PIPEPIPE ConditionalAndExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -2993,17 +2993,17 @@ ConditionalOrExpression PIPEPIPE ConditionalAndExpression
 ConditionalExpression:
 ConditionalOrExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ConditionalOrExpression QUESTION Expression COLON ConditionalExpression
+ConditionalOrExpression jp_QUESTION Expression jp_COLON ConditionalExpression
 {
-  ELEMENTSTART(5);
-  CHECKEMPTY(5);
+  jpElementStart(5);
+  jpCheckEmpty(5);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3012,8 +3012,8 @@ ConditionalOrExpression QUESTION Expression COLON ConditionalExpression
 AssignmentExpression:
 ConditionalExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3021,8 +3021,8 @@ ConditionalExpression
 |
 Assignment
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3031,8 +3031,8 @@ Assignment
 Assignment:
 LeftHandSide AssignmentOperator AssignmentExpression
 {
-  ELEMENTSTART(3);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3041,9 +3041,9 @@ LeftHandSide AssignmentOperator AssignmentExpression
 LeftHandSide:
 Name
 {
-  ELEMENTSTART(1);
+  jpElementStart(1);
   yyGetParser->DeallocateParserType(&($<str>1));
-  CHECKEMPTY(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3051,8 +3051,8 @@ Name
 |
 FieldAccess
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3060,117 +3060,117 @@ FieldAccess
 |
 ArrayAccess
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 AssignmentOperator:
-EQUALS
+jp_EQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-TIMESEQUALS
+jp_TIMESEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-DIVIDEEQUALS
+jp_DIVIDEEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PERCENTEQUALS
+jp_PERCENTEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PLUSEQUALS
+jp_PLUSEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-MINUSEQUALS
+jp_MINUSEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-LESLESEQUALS
+jp_LESLESEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-GTGTEQUALS
+jp_GTGTEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-GTGTGTEQUALS
+jp_GTGTGTEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-ANDEQUALS
+jp_ANDEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-CARROTEQUALS
+jp_CARROTEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-PIPEEQUALS
+jp_PIPEEQUALS
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3179,8 +3179,8 @@ PIPEEQUALS
 Expression:
 AssignmentExpression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
@@ -3189,28 +3189,28 @@ AssignmentExpression
 ConstantExpression:
 Expression
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 
 New:
-NEW
+jp_NEW
 {
-  ELEMENTSTART(1);
-  CHECKEMPTY(1);
+  jpElementStart(1);
+  jpCheckEmpty(1);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
 }
 |
-Name DOT NEW
+Name jp_DOT jp_NEW
 {
-  ELEMENTSTART(3);
-  STORECLASS($<str>1);
-  CHECKEMPTY(3);
+  jpElementStart(3);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(3);
   $<str>$ = 0;
   yyGetParser->SetCurrentCombine("");
 
diff --git a/Source/cmDependsJavaParserTokens.h b/Source/cmDependsJavaParserTokens.h
index 7899a91d63..5711ac38c4 100644
--- a/Source/cmDependsJavaParserTokens.h
+++ b/Source/cmDependsJavaParserTokens.h
@@ -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