COMP: Remove more warnings/errors

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:

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

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