javacc-7.0.1.examples.JavaGrammars.cpp.gen.JavaParserTokenManager.cc Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javacc Show documentation
Show all versions of javacc Show documentation
JavaCC is a parser/scanner generator for Java.
/* JavaParserTokenManager.cc */
#include "JavaParserTokenManager.h"
#include "TokenMgrError.h"
#include "SimpleNode.h"
namespace java {
namespace parser {
static const unsigned long long jjbitVec0[] = {
0xfffffffffffffffeULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
};
static const unsigned long long jjbitVec2[] = {
0x0ULL, 0x0ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
};
static const unsigned long long jjbitVec3[] = {
0xfff0000000200002ULL, 0xffffffffffffdfffULL, 0xfffff00f7fffffffULL, 0x12000000007fffffULL
};
static const unsigned long long jjbitVec4[] = {
0x0ULL, 0x0ULL, 0x420043c00000000ULL, 0xff7fffffff7fffffULL
};
static const unsigned long long jjbitVec5[] = {
0xffffcffffffffULL, 0xffffffffffff0000ULL, 0xf9ff3fffffffffffULL, 0x401f00030003ULL
};
static const unsigned long long jjbitVec6[] = {
0x0ULL, 0x400000000000000ULL, 0xfffffffbffffd740ULL, 0xffffffcff7fffULL
};
static const unsigned long long jjbitVec7[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xfffffffffffff003ULL, 0x33fffffffff199fULL
};
static const unsigned long long jjbitVec8[] = {
0xfffe000000000000ULL, 0xfffffffe027fffffULL, 0xffULL, 0x707ffffff0000ULL
};
static const unsigned long long jjbitVec9[] = {
0x7fffffe00000000ULL, 0xfffe0000000007ffULL, 0xffffffffffffffffULL, 0x1c000060002fffffULL
};
static const unsigned long long jjbitVec10[] = {
0x1ffffffd0000ULL, 0x0ULL, 0x3fffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec11[] = {
0x23ffffffffffffe0ULL, 0x3ff010000ULL, 0x3c5fdfffff99fe0ULL, 0xf0003b0000000ULL
};
static const unsigned long long jjbitVec12[] = {
0x36dfdfffff987e0ULL, 0x1c00005e000000ULL, 0x23edfdfffffbafe0ULL, 0x100010000ULL
};
static const unsigned long long jjbitVec13[] = {
0x23cdfdfffff99fe0ULL, 0x3b0000000ULL, 0x3bfc718d63dc7e0ULL, 0x0ULL
};
static const unsigned long long jjbitVec14[] = {
0x3effdfffffddfe0ULL, 0x300000000ULL, 0x3effdfffffddfe0ULL, 0x340000000ULL
};
static const unsigned long long jjbitVec15[] = {
0x3fffdfffffddfe0ULL, 0x300000000ULL, 0x2ffbfffffc7fffe0ULL, 0x7fULL
};
static const unsigned long long jjbitVec16[] = {
0x800dfffffffffffeULL, 0x7fULL, 0x200decaefef02596ULL, 0x3000005fULL
};
static const unsigned long long jjbitVec17[] = {
0x1ULL, 0x7fffffffeffULL, 0xf00ULL, 0x0ULL
};
static const unsigned long long jjbitVec18[] = {
0x6fbffffffffULL, 0x3f0000ULL, 0xffffffff00000000ULL, 0x7fffffffff003fULL
};
static const unsigned long long jjbitVec19[] = {
0xffffffffffffffffULL, 0xffffffff83ffffffULL, 0xffffff07ffffffffULL, 0x3ffffffffffffffULL
};
static const unsigned long long jjbitVec20[] = {
0xffffffffffffff7fULL, 0xffffffff3d7f3d7fULL, 0x7f3d7fffffff3d7fULL, 0xffff7fffff7f7f3dULL
};
static const unsigned long long jjbitVec21[] = {
0xffffffff7f3d7fffULL, 0x7ffff7fULL, 0xffffffff00000000ULL, 0x1fffffffffffffULL
};
static const unsigned long long jjbitVec22[] = {
0xffffffffffffffffULL, 0x7f9fffffffffffULL, 0xffffffff07fffffeULL, 0x7ffffffffffULL
};
static const unsigned long long jjbitVec23[] = {
0x0ULL, 0x0ULL, 0xfffffffffffffULL, 0x8000000ULL
};
static const unsigned long long jjbitVec24[] = {
0xffffffff00000000ULL, 0xffffffffffffffULL, 0x1ffffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec25[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffff0fffffffULL, 0x3ffffffffffffffULL
};
static const unsigned long long jjbitVec26[] = {
0xffffffff3f3fffffULL, 0x3fffffffaaff3f3fULL, 0x5fdfffffffffffffULL, 0x1fdc1fff0fcf1fdcULL
};
static const unsigned long long jjbitVec27[] = {
0x8000000000000000ULL, 0x8000000000000001ULL, 0xffff00000000ULL, 0x0ULL
};
static const unsigned long long jjbitVec28[] = {
0x3fbbd503e2ffc84ULL, 0xffffffff00000000ULL, 0xfULL, 0x0ULL
};
static const unsigned long long jjbitVec29[] = {
0x73e03fe000000e0ULL, 0xfffffffffffffffeULL, 0xfffffffe601fffffULL, 0x7fffffffffffffffULL
};
static const unsigned long long jjbitVec30[] = {
0xfffe1fffffffffe0ULL, 0xffffffffffffffffULL, 0xffffff00007fffULL, 0x0ULL
};
static const unsigned long long jjbitVec31[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x3fffffffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec32[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x3fffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec33[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x1fffULL, 0x0ULL
};
static const unsigned long long jjbitVec34[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xfffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec35[] = {
0x3fffffffffffULL, 0x0ULL, 0x0ULL, 0x0ULL
};
static const unsigned long long jjbitVec36[] = {
0x5f7ffdffa0f8007fULL, 0xffffffffffffffdbULL, 0x3ffffffffffffULL, 0xfffffffffff80000ULL
};
static const unsigned long long jjbitVec37[] = {
0x3fffffffffffffffULL, 0xffffffffffff0000ULL, 0xfffffffffffcffffULL, 0xfff0000000000ffULL
};
static const unsigned long long jjbitVec38[] = {
0x18000000000000ULL, 0xffd702000000e000ULL, 0xffffffffffffffffULL, 0x1fffffffffffffffULL
};
static const unsigned long long jjbitVec39[] = {
0x87fffffe00000010ULL, 0xffffffe007fffffeULL, 0x7fffffffffffffffULL, 0x631cfcfcfcULL
};
static const unsigned long long jjbitVec40[] = {
0x0ULL, 0x0ULL, 0x420043cffffffffULL, 0xff7fffffff7fffffULL
};
static const unsigned long long jjbitVec41[] = {
0xffffffffffffffffULL, 0x400000700007fffULL, 0xfffffffbffffd740ULL, 0xffffffcff7fffULL
};
static const unsigned long long jjbitVec42[] = {
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xfffffffffffff07bULL, 0x33fffffffff199fULL
};
static const unsigned long long jjbitVec43[] = {
0xfffe000000000000ULL, 0xfffffffe027fffffULL, 0xbbfffffbfffe00ffULL, 0x707ffffff0016ULL
};
static const unsigned long long jjbitVec44[] = {
0x7fffffe00000000ULL, 0xffff03ff003fffffULL, 0xffffffffffffffffULL, 0x1fff3dff9fefffffULL
};
static const unsigned long long jjbitVec45[] = {
0xffff1fffffff8000ULL, 0x7ffULL, 0x1ffffffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec46[] = {
0xf3ffffffffffffeeULL, 0xffcfff1f3fffULL, 0xd3c5fdfffff99feeULL, 0xfffcfb080399fULL
};
static const unsigned long long jjbitVec47[] = {
0xd36dfdfffff987e4ULL, 0x1fffc05e003987ULL, 0xf3edfdfffffbafeeULL, 0xffc100013bbfULL
};
static const unsigned long long jjbitVec48[] = {
0xf3cdfdfffff99feeULL, 0xffc3b0c0398fULL, 0xc3bfc718d63dc7ecULL, 0xff8000803dc7ULL
};
static const unsigned long long jjbitVec49[] = {
0xc3effdfffffddfeeULL, 0xffc300603ddfULL, 0xc3effdfffffddfecULL, 0xffc340603ddfULL
};
static const unsigned long long jjbitVec50[] = {
0xc3fffdfffffddfecULL, 0xffc300803dcfULL, 0x2ffbfffffc7fffecULL, 0xc0000ff5f847fULL
};
static const unsigned long long jjbitVec51[] = {
0x87fffffffffffffeULL, 0x3ff7fffULL, 0x3bffecaefef02596ULL, 0x33ff3f5fULL
};
static const unsigned long long jjbitVec52[] = {
0xc2a003ff03000001ULL, 0xfffe07fffffffeffULL, 0x1ffffffffeff0fdfULL, 0x40ULL
};
static const unsigned long long jjbitVec53[] = {
0x3c7f6fbffffffffULL, 0x3ff03ffULL, 0xffffffff00000000ULL, 0x7fffffffff003fULL
};
static const unsigned long long jjbitVec54[] = {
0xffffffff7f3d7fffULL, 0x3fe0007ffff7fULL, 0xffffffff00000000ULL, 0x1fffffffffffffULL
};
static const unsigned long long jjbitVec55[] = {
0x0ULL, 0x0ULL, 0xffffffffffffffffULL, 0x3ff080fffffULL
};
static const unsigned long long jjbitVec56[] = {
0xffffffff03ff7800ULL, 0xffffffffffffffULL, 0x3ffffffffffULL, 0x0ULL
};
static const unsigned long long jjbitVec57[] = {
0x80007c000000f000ULL, 0x8000fc0000000001ULL, 0xffff00000000ULL, 0x21fff0000ULL
};
static const unsigned long long jjbitVec58[] = {
0x73efffe000000e0ULL, 0xfffffffffffffffeULL, 0xfffffffe661fffffULL, 0x7fffffffffffffffULL
};
static const unsigned long long jjbitVec59[] = {
0x5f7ffdffe0f8007fULL, 0xffffffffffffffdbULL, 0x3ffffffffffffULL, 0xfffffffffff80000ULL
};
static const unsigned long long jjbitVec60[] = {
0x18000f00000000ULL, 0xffd702000000e000ULL, 0xffffffffffffffffULL, 0x9fffffffffffffffULL
};
static const unsigned long long jjbitVec61[] = {
0x87fffffe03ff0010ULL, 0xffffffe007fffffeULL, 0x7fffffffffffffffULL, 0xe0000631cfcfcfcULL
};
static const int jjnextStates[] = {
34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8,
9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18,
20, 25, 27, 29, 38, 39, 42, 43, 46, 47,
};
static JJChar jjstrLiteralChars_0[] = {0};
static JJChar jjstrLiteralChars_1[] = {0};
static JJChar jjstrLiteralChars_2[] = {0};
static JJChar jjstrLiteralChars_3[] = {0};
static JJChar jjstrLiteralChars_4[] = {0};
static JJChar jjstrLiteralChars_5[] = {0};
static JJChar jjstrLiteralChars_6[] = {0};
static JJChar jjstrLiteralChars_7[] = {0};
static JJChar jjstrLiteralChars_8[] = {0};
static JJChar jjstrLiteralChars_9[] = {0};
static JJChar jjstrLiteralChars_10[] = {0};
static JJChar jjstrLiteralChars_11[] = {0};
static JJChar jjstrLiteralChars_12[] = {0};
static JJChar jjstrLiteralChars_13[] = {0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0};
static JJChar jjstrLiteralChars_14[] = {0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0};
static JJChar jjstrLiteralChars_15[] = {0x62, 0x72, 0x65, 0x61, 0x6b, 0};
static JJChar jjstrLiteralChars_16[] = {0x62, 0x79, 0x74, 0x65, 0};
static JJChar jjstrLiteralChars_17[] = {0x63, 0x61, 0x73, 0x65, 0};
static JJChar jjstrLiteralChars_18[] = {0x63, 0x61, 0x74, 0x63, 0x68, 0};
static JJChar jjstrLiteralChars_19[] = {0x63, 0x68, 0x61, 0x72, 0};
static JJChar jjstrLiteralChars_20[] = {0x63, 0x6c, 0x61, 0x73, 0x73, 0};
static JJChar jjstrLiteralChars_21[] = {0x63, 0x6f, 0x6e, 0x73, 0x74, 0};
static JJChar jjstrLiteralChars_22[] = {0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0};
static JJChar jjstrLiteralChars_23[] = {0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0};
static JJChar jjstrLiteralChars_24[] = {0x64, 0x6f, 0};
static JJChar jjstrLiteralChars_25[] = {0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0};
static JJChar jjstrLiteralChars_26[] = {0x65, 0x6c, 0x73, 0x65, 0};
static JJChar jjstrLiteralChars_27[] = {0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x73, 0};
static JJChar jjstrLiteralChars_28[] = {0x66, 0x61, 0x6c, 0x73, 0x65, 0};
static JJChar jjstrLiteralChars_29[] = {0x66, 0x69, 0x6e, 0x61, 0x6c, 0};
static JJChar jjstrLiteralChars_30[] = {0x66, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0};
static JJChar jjstrLiteralChars_31[] = {0x66, 0x6c, 0x6f, 0x61, 0x74, 0};
static JJChar jjstrLiteralChars_32[] = {0x66, 0x6f, 0x72, 0};
static JJChar jjstrLiteralChars_33[] = {0x67, 0x6f, 0x74, 0x6f, 0};
static JJChar jjstrLiteralChars_34[] = {0x69, 0x66, 0};
static JJChar jjstrLiteralChars_35[] = {0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0};
static JJChar jjstrLiteralChars_36[] = {0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0};
static JJChar jjstrLiteralChars_37[] = {0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f, 0x66, 0};
static JJChar jjstrLiteralChars_38[] = {0x69, 0x6e, 0x74, 0};
static JJChar jjstrLiteralChars_39[] = {0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0};
static JJChar jjstrLiteralChars_40[] = {0x6c, 0x6f, 0x6e, 0x67, 0};
static JJChar jjstrLiteralChars_41[] = {0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0};
static JJChar jjstrLiteralChars_42[] = {0x6e, 0x65, 0x77, 0};
static JJChar jjstrLiteralChars_43[] = {0x6e, 0x75, 0x6c, 0x6c, 0};
static JJChar jjstrLiteralChars_44[] = {0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0};
static JJChar jjstrLiteralChars_45[] = {0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0};
static JJChar jjstrLiteralChars_46[] = {0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x65, 0x64, 0};
static JJChar jjstrLiteralChars_47[] = {0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0};
static JJChar jjstrLiteralChars_48[] = {0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0};
static JJChar jjstrLiteralChars_49[] = {0x73, 0x68, 0x6f, 0x72, 0x74, 0};
static JJChar jjstrLiteralChars_50[] = {0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0};
static JJChar jjstrLiteralChars_51[] = {0x73, 0x75, 0x70, 0x65, 0x72, 0};
static JJChar jjstrLiteralChars_52[] = {0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0};
static JJChar jjstrLiteralChars_53[] = {0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x7a, 0x65, 0x64, 0};
static JJChar jjstrLiteralChars_54[] = {0x74, 0x68, 0x69, 0x73, 0};
static JJChar jjstrLiteralChars_55[] = {0x74, 0x68, 0x72, 0x6f, 0x77, 0};
static JJChar jjstrLiteralChars_56[] = {0x74, 0x68, 0x72, 0x6f, 0x77, 0x73, 0};
static JJChar jjstrLiteralChars_57[] = {0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x65, 0x6e, 0x74, 0};
static JJChar jjstrLiteralChars_58[] = {0x74, 0x72, 0x75, 0x65, 0};
static JJChar jjstrLiteralChars_59[] = {0x74, 0x72, 0x79, 0};
static JJChar jjstrLiteralChars_60[] = {0x76, 0x6f, 0x69, 0x64, 0};
static JJChar jjstrLiteralChars_61[] = {0x76, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6c, 0x65, 0};
static JJChar jjstrLiteralChars_62[] = {0x77, 0x68, 0x69, 0x6c, 0x65, 0};
static JJChar jjstrLiteralChars_63[] = {0};
static JJChar jjstrLiteralChars_64[] = {0};
static JJChar jjstrLiteralChars_65[] = {0};
static JJChar jjstrLiteralChars_66[] = {0};
static JJChar jjstrLiteralChars_67[] = {0};
static JJChar jjstrLiteralChars_68[] = {0};
static JJChar jjstrLiteralChars_69[] = {0};
static JJChar jjstrLiteralChars_70[] = {0};
static JJChar jjstrLiteralChars_71[] = {0};
static JJChar jjstrLiteralChars_72[] = {0};
static JJChar jjstrLiteralChars_73[] = {0};
static JJChar jjstrLiteralChars_74[] = {0x28, 0};
static JJChar jjstrLiteralChars_75[] = {0x29, 0};
static JJChar jjstrLiteralChars_76[] = {0x7b, 0};
static JJChar jjstrLiteralChars_77[] = {0x7d, 0};
static JJChar jjstrLiteralChars_78[] = {0x5b, 0};
static JJChar jjstrLiteralChars_79[] = {0x5d, 0};
static JJChar jjstrLiteralChars_80[] = {0x3b, 0};
static JJChar jjstrLiteralChars_81[] = {0x2c, 0};
static JJChar jjstrLiteralChars_82[] = {0x2e, 0};
static JJChar jjstrLiteralChars_83[] = {0x3d, 0};
static JJChar jjstrLiteralChars_84[] = {0x3e, 0};
static JJChar jjstrLiteralChars_85[] = {0x3c, 0};
static JJChar jjstrLiteralChars_86[] = {0x21, 0};
static JJChar jjstrLiteralChars_87[] = {0x7e, 0};
static JJChar jjstrLiteralChars_88[] = {0x3f, 0};
static JJChar jjstrLiteralChars_89[] = {0x3a, 0};
static JJChar jjstrLiteralChars_90[] = {0x3d, 0x3d, 0};
static JJChar jjstrLiteralChars_91[] = {0x3c, 0x3d, 0};
static JJChar jjstrLiteralChars_92[] = {0x3e, 0x3d, 0};
static JJChar jjstrLiteralChars_93[] = {0x21, 0x3d, 0};
static JJChar jjstrLiteralChars_94[] = {0x7c, 0x7c, 0};
static JJChar jjstrLiteralChars_95[] = {0x26, 0x26, 0};
static JJChar jjstrLiteralChars_96[] = {0x2b, 0x2b, 0};
static JJChar jjstrLiteralChars_97[] = {0x2d, 0x2d, 0};
static JJChar jjstrLiteralChars_98[] = {0x2b, 0};
static JJChar jjstrLiteralChars_99[] = {0x2d, 0};
static JJChar jjstrLiteralChars_100[] = {0x2a, 0};
static JJChar jjstrLiteralChars_101[] = {0x2f, 0};
static JJChar jjstrLiteralChars_102[] = {0x26, 0};
static JJChar jjstrLiteralChars_103[] = {0x7c, 0};
static JJChar jjstrLiteralChars_104[] = {0x5e, 0};
static JJChar jjstrLiteralChars_105[] = {0x25, 0};
static JJChar jjstrLiteralChars_106[] = {0x3c, 0x3c, 0};
static JJChar jjstrLiteralChars_107[] = {0x3e, 0x3e, 0};
static JJChar jjstrLiteralChars_108[] = {0x3e, 0x3e, 0x3e, 0};
static JJChar jjstrLiteralChars_109[] = {0x2b, 0x3d, 0};
static JJChar jjstrLiteralChars_110[] = {0x2d, 0x3d, 0};
static JJChar jjstrLiteralChars_111[] = {0x2a, 0x3d, 0};
static JJChar jjstrLiteralChars_112[] = {0x2f, 0x3d, 0};
static JJChar jjstrLiteralChars_113[] = {0x26, 0x3d, 0};
static JJChar jjstrLiteralChars_114[] = {0x7c, 0x3d, 0};
static JJChar jjstrLiteralChars_115[] = {0x5e, 0x3d, 0};
static JJChar jjstrLiteralChars_116[] = {0x25, 0x3d, 0};
static JJChar jjstrLiteralChars_117[] = {0x3c, 0x3c, 0x3d, 0};
static JJChar jjstrLiteralChars_118[] = {0x3e, 0x3e, 0x3d, 0};
static JJChar jjstrLiteralChars_119[] = {0x3e, 0x3e, 0x3e, 0x3d, 0};
static JJChar jjstrLiteralChars_120[] = {0};
static const JJString jjstrLiteralImages[] = {
jjstrLiteralChars_0,
jjstrLiteralChars_1,
jjstrLiteralChars_2,
jjstrLiteralChars_3,
jjstrLiteralChars_4,
jjstrLiteralChars_5,
jjstrLiteralChars_6,
jjstrLiteralChars_7,
jjstrLiteralChars_8,
jjstrLiteralChars_9,
jjstrLiteralChars_10,
jjstrLiteralChars_11,
jjstrLiteralChars_12,
jjstrLiteralChars_13,
jjstrLiteralChars_14,
jjstrLiteralChars_15,
jjstrLiteralChars_16,
jjstrLiteralChars_17,
jjstrLiteralChars_18,
jjstrLiteralChars_19,
jjstrLiteralChars_20,
jjstrLiteralChars_21,
jjstrLiteralChars_22,
jjstrLiteralChars_23,
jjstrLiteralChars_24,
jjstrLiteralChars_25,
jjstrLiteralChars_26,
jjstrLiteralChars_27,
jjstrLiteralChars_28,
jjstrLiteralChars_29,
jjstrLiteralChars_30,
jjstrLiteralChars_31,
jjstrLiteralChars_32,
jjstrLiteralChars_33,
jjstrLiteralChars_34,
jjstrLiteralChars_35,
jjstrLiteralChars_36,
jjstrLiteralChars_37,
jjstrLiteralChars_38,
jjstrLiteralChars_39,
jjstrLiteralChars_40,
jjstrLiteralChars_41,
jjstrLiteralChars_42,
jjstrLiteralChars_43,
jjstrLiteralChars_44,
jjstrLiteralChars_45,
jjstrLiteralChars_46,
jjstrLiteralChars_47,
jjstrLiteralChars_48,
jjstrLiteralChars_49,
jjstrLiteralChars_50,
jjstrLiteralChars_51,
jjstrLiteralChars_52,
jjstrLiteralChars_53,
jjstrLiteralChars_54,
jjstrLiteralChars_55,
jjstrLiteralChars_56,
jjstrLiteralChars_57,
jjstrLiteralChars_58,
jjstrLiteralChars_59,
jjstrLiteralChars_60,
jjstrLiteralChars_61,
jjstrLiteralChars_62,
jjstrLiteralChars_63,
jjstrLiteralChars_64,
jjstrLiteralChars_65,
jjstrLiteralChars_66,
jjstrLiteralChars_67,
jjstrLiteralChars_68,
jjstrLiteralChars_69,
jjstrLiteralChars_70,
jjstrLiteralChars_71,
jjstrLiteralChars_72,
jjstrLiteralChars_73,
jjstrLiteralChars_74,
jjstrLiteralChars_75,
jjstrLiteralChars_76,
jjstrLiteralChars_77,
jjstrLiteralChars_78,
jjstrLiteralChars_79,
jjstrLiteralChars_80,
jjstrLiteralChars_81,
jjstrLiteralChars_82,
jjstrLiteralChars_83,
jjstrLiteralChars_84,
jjstrLiteralChars_85,
jjstrLiteralChars_86,
jjstrLiteralChars_87,
jjstrLiteralChars_88,
jjstrLiteralChars_89,
jjstrLiteralChars_90,
jjstrLiteralChars_91,
jjstrLiteralChars_92,
jjstrLiteralChars_93,
jjstrLiteralChars_94,
jjstrLiteralChars_95,
jjstrLiteralChars_96,
jjstrLiteralChars_97,
jjstrLiteralChars_98,
jjstrLiteralChars_99,
jjstrLiteralChars_100,
jjstrLiteralChars_101,
jjstrLiteralChars_102,
jjstrLiteralChars_103,
jjstrLiteralChars_104,
jjstrLiteralChars_105,
jjstrLiteralChars_106,
jjstrLiteralChars_107,
jjstrLiteralChars_108,
jjstrLiteralChars_109,
jjstrLiteralChars_110,
jjstrLiteralChars_111,
jjstrLiteralChars_112,
jjstrLiteralChars_113,
jjstrLiteralChars_114,
jjstrLiteralChars_115,
jjstrLiteralChars_116,
jjstrLiteralChars_117,
jjstrLiteralChars_118,
jjstrLiteralChars_119,
jjstrLiteralChars_120,
};
/** Lexer state names. */
static const JJChar lexStateNames_arr_0[] =
{0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0};
static const JJChar lexStateNames_arr_1[] =
{0x49, 0x4e, 0x5f, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x4e, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x45, 0x4e, 0x54, 0};
static const JJChar lexStateNames_arr_2[] =
{0x49, 0x4e, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x45, 0x4e, 0x54, 0};
static const JJChar lexStateNames_arr_3[] =
{0x49, 0x4e, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x4c, 0x49, 0x4e, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x45, 0x4e, 0x54, 0};
static const JJString lexStateNames[] = {
lexStateNames_arr_0,
lexStateNames_arr_1,
lexStateNames_arr_2,
lexStateNames_arr_3,
};
/** Lex State array. */
static const int jjnewLexState[] = {
-1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
static const unsigned long long jjtoToken[] = {
0xffffffffffffe001ULL, 0x1fffffffffffce8ULL,
};
static const unsigned long long jjtoSkip[] = {
0xe3eULL, 0x0ULL,
};
static const unsigned long long jjtoSpecial[] = {
0xe00ULL, 0x0ULL,
};
void JavaParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; }
int JavaParserTokenManager::jjStopStringLiteralDfa_0(int pos, unsigned long long active0, unsigned long long active1){
switch (pos)
{
case 0:
if ((active0 & 0x140ULL) != 0L || (active1 & 0x1002000000000ULL) != 0L)
return 2;
if ((active1 & 0x40000ULL) != 0L)
return 8;
if ((active0 & 0x7fffffffffffe000ULL) != 0L)
{
jjmatchedKind = 71;
return 32;
}
return -1;
case 1:
if ((active0 & 0x100ULL) != 0L)
return 0;
if ((active0 & 0x7ffffffbfcffe000ULL) != 0L)
{
if (jjmatchedPos != 1)
{
jjmatchedKind = 71;
jjmatchedPos = 1;
}
return 32;
}
if ((active0 & 0x403000000ULL) != 0L)
return 32;
return -1;
case 2:
if ((active0 & 0x77fffb3afeffe000ULL) != 0L)
{
if (jjmatchedPos != 2)
{
jjmatchedKind = 71;
jjmatchedPos = 2;
}
return 32;
}
if ((active0 & 0x80004c100000000ULL) != 0L)
return 32;
return -1;
case 3:
if ((active0 & 0x14400902040b0000ULL) != 0L)
return 32;
if ((active0 & 0x63bff2b8faf4e000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 3;
return 32;
}
return -1;
case 4:
if ((active0 & 0x2235f2b80ac06000ULL) != 0L)
{
if (jjmatchedPos != 4)
{
jjmatchedKind = 71;
jjmatchedPos = 4;
}
return 32;
}
if ((active0 & 0x418a0000f0348000ULL) != 0L)
return 32;
return -1;
case 5:
if ((active0 & 0x222070a848c06000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 5;
return 32;
}
if ((active0 & 0x115821002000000ULL) != 0L)
return 32;
return -1;
case 6:
if ((active0 & 0x222040a800402000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 6;
return 32;
}
if ((active0 & 0x300048804000ULL) != 0L)
return 32;
return -1;
case 7:
if ((active0 & 0x22040a800000000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 7;
return 32;
}
if ((active0 & 0x2000000000402000ULL) != 0L)
return 32;
return -1;
case 8:
if ((active0 & 0x20002800000000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 8;
return 32;
}
if ((active0 & 0x200408000000000ULL) != 0L)
return 32;
return -1;
case 9:
if ((active0 & 0x20000000000000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 9;
return 32;
}
if ((active0 & 0x2800000000ULL) != 0L)
return 32;
return -1;
case 10:
if ((active0 & 0x20000000000000ULL) != 0L)
{
jjmatchedKind = 71;
jjmatchedPos = 10;
return 32;
}
return -1;
default :
return -1;
}
}
int JavaParserTokenManager::jjStartNfa_0(int pos, unsigned long long active0, unsigned long long active1){
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
}
int JavaParserTokenManager::jjStopAtPos(int pos, int kind){
jjmatchedKind = kind;
jjmatchedPos = pos;
return pos + 1;
}
int JavaParserTokenManager::jjMoveStringLiteralDfa0_0(){
switch(curChar)
{
case 33:
jjmatchedKind = 86;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x20000000ULL);
case 37:
jjmatchedKind = 105;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x10000000000000ULL);
case 38:
jjmatchedKind = 102;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x2000080000000ULL);
case 40:
return jjStopAtPos(0, 74);
case 41:
return jjStopAtPos(0, 75);
case 42:
jjmatchedKind = 100;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x800000000000ULL);
case 43:
jjmatchedKind = 98;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x200100000000ULL);
case 44:
return jjStopAtPos(0, 81);
case 45:
jjmatchedKind = 99;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x400200000000ULL);
case 46:
return jjStartNfaWithStates_0(0, 82, 8);
case 47:
jjmatchedKind = 101;
return jjMoveStringLiteralDfa1_0(0x140ULL, 0x1000000000000ULL);
case 58:
return jjStopAtPos(0, 89);
case 59:
return jjStopAtPos(0, 80);
case 60:
jjmatchedKind = 85;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x20040008000000ULL);
case 61:
jjmatchedKind = 83;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x4000000ULL);
case 62:
jjmatchedKind = 84;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0xc0180010000000ULL);
case 63:
return jjStopAtPos(0, 88);
case 91:
return jjStopAtPos(0, 78);
case 93:
return jjStopAtPos(0, 79);
case 94:
jjmatchedKind = 104;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x8000000000000ULL);
case 97:
return jjMoveStringLiteralDfa1_0(0x2000ULL, 0x0ULL);
case 98:
return jjMoveStringLiteralDfa1_0(0x1c000ULL, 0x0ULL);
case 99:
return jjMoveStringLiteralDfa1_0(0x7e0000ULL, 0x0ULL);
case 100:
return jjMoveStringLiteralDfa1_0(0x3800000ULL, 0x0ULL);
case 101:
return jjMoveStringLiteralDfa1_0(0xc000000ULL, 0x0ULL);
case 102:
return jjMoveStringLiteralDfa1_0(0x1f0000000ULL, 0x0ULL);
case 103:
return jjMoveStringLiteralDfa1_0(0x200000000ULL, 0x0ULL);
case 105:
return jjMoveStringLiteralDfa1_0(0xfc00000000ULL, 0x0ULL);
case 108:
return jjMoveStringLiteralDfa1_0(0x10000000000ULL, 0x0ULL);
case 110:
return jjMoveStringLiteralDfa1_0(0xe0000000000ULL, 0x0ULL);
case 112:
return jjMoveStringLiteralDfa1_0(0xf00000000000ULL, 0x0ULL);
case 114:
return jjMoveStringLiteralDfa1_0(0x1000000000000ULL, 0x0ULL);
case 115:
return jjMoveStringLiteralDfa1_0(0x3e000000000000ULL, 0x0ULL);
case 116:
return jjMoveStringLiteralDfa1_0(0xfc0000000000000ULL, 0x0ULL);
case 118:
return jjMoveStringLiteralDfa1_0(0x3000000000000000ULL, 0x0ULL);
case 119:
return jjMoveStringLiteralDfa1_0(0x4000000000000000ULL, 0x0ULL);
case 123:
return jjStopAtPos(0, 76);
case 124:
jjmatchedKind = 103;
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x4000040000000ULL);
case 125:
return jjStopAtPos(0, 77);
case 126:
return jjStopAtPos(0, 87);
default :
return jjMoveNfa_0(3, 0);
}
}
int JavaParserTokenManager::jjMoveStringLiteralDfa1_0(unsigned long long active0, unsigned long long active1){
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(0, active0, active1);
return 1;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 38:
if ((active1 & 0x80000000ULL) != 0L)
return jjStopAtPos(1, 95);
break;
case 42:
if ((active0 & 0x100ULL) != 0L)
return jjStartNfaWithStates_0(1, 8, 0);
break;
case 43:
if ((active1 & 0x100000000ULL) != 0L)
return jjStopAtPos(1, 96);
break;
case 45:
if ((active1 & 0x200000000ULL) != 0L)
return jjStopAtPos(1, 97);
break;
case 47:
if ((active0 & 0x40ULL) != 0L)
return jjStopAtPos(1, 6);
break;
case 60:
if ((active1 & 0x40000000000ULL) != 0L)
{
jjmatchedKind = 106;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000ULL);
case 61:
if ((active1 & 0x4000000ULL) != 0L)
return jjStopAtPos(1, 90);
else if ((active1 & 0x8000000ULL) != 0L)
return jjStopAtPos(1, 91);
else if ((active1 & 0x10000000ULL) != 0L)
return jjStopAtPos(1, 92);
else if ((active1 & 0x20000000ULL) != 0L)
return jjStopAtPos(1, 93);
else if ((active1 & 0x200000000000ULL) != 0L)
return jjStopAtPos(1, 109);
else if ((active1 & 0x400000000000ULL) != 0L)
return jjStopAtPos(1, 110);
else if ((active1 & 0x800000000000ULL) != 0L)
return jjStopAtPos(1, 111);
else if ((active1 & 0x1000000000000ULL) != 0L)
return jjStopAtPos(1, 112);
else if ((active1 & 0x2000000000000ULL) != 0L)
return jjStopAtPos(1, 113);
else if ((active1 & 0x4000000000000ULL) != 0L)
return jjStopAtPos(1, 114);
else if ((active1 & 0x8000000000000ULL) != 0L)
return jjStopAtPos(1, 115);
else if ((active1 & 0x10000000000000ULL) != 0L)
return jjStopAtPos(1, 116);
break;
case 62:
if ((active1 & 0x80000000000ULL) != 0L)
{
jjmatchedKind = 107;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc0100000000000ULL);
case 97:
return jjMoveStringLiteralDfa2_0(active0, 0x120010060000ULL, active1, 0L);
case 98:
return jjMoveStringLiteralDfa2_0(active0, 0x2000ULL, active1, 0L);
case 101:
return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000ULL, active1, 0L);
case 102:
if ((active0 & 0x400000000ULL) != 0L)
return jjStartNfaWithStates_0(1, 34, 32);
break;
case 104:
return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000ULL, active1, 0L);
case 105:
return jjMoveStringLiteralDfa2_0(active0, 0x60000000ULL, active1, 0L);
case 108:
return jjMoveStringLiteralDfa2_0(active0, 0x84100000ULL, active1, 0L);
case 109:
return jjMoveStringLiteralDfa2_0(active0, 0x1800000000ULL, active1, 0L);
case 110:
return jjMoveStringLiteralDfa2_0(active0, 0xe000000000ULL, active1, 0L);
case 111:
if ((active0 & 0x1000000ULL) != 0L)
{
jjmatchedKind = 24;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000ULL, active1, 0L);
case 114:
return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000ULL, active1, 0L);
case 116:
return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000ULL, active1, 0L);
case 117:
return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000ULL, active1, 0L);
case 119:
return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0L);
case 120:
return jjMoveStringLiteralDfa2_0(active0, 0x8000000ULL, active1, 0L);
case 121:
return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000ULL, active1, 0L);
case 124:
if ((active1 & 0x40000000ULL) != 0L)
return jjStopAtPos(1, 94);
break;
default :
break;
}
return jjStartNfa_0(0, active0, active1);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
if (((active0 &= old0) | (active1 &= old1)) == 0L)
return jjStartNfa_0(0, old0, old1);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(1, active0, active1);
return 2;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 61:
if ((active1 & 0x20000000000000ULL) != 0L)
return jjStopAtPos(2, 117);
else if ((active1 & 0x40000000000000ULL) != 0L)
return jjStopAtPos(2, 118);
break;
case 62:
if ((active1 & 0x100000000000ULL) != 0L)
{
jjmatchedKind = 108;
jjmatchedPos = 2;
}
return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000000ULL);
case 97:
return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000ULL, active1, 0L);
case 98:
return jjMoveStringLiteralDfa3_0(active0, 0x800000000000ULL, active1, 0L);
case 99:
return jjMoveStringLiteralDfa3_0(active0, 0x100000000000ULL, active1, 0L);
case 101:
return jjMoveStringLiteralDfa3_0(active0, 0x8000ULL, active1, 0L);
case 102:
return jjMoveStringLiteralDfa3_0(active0, 0x800000ULL, active1, 0L);
case 105:
return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000ULL, active1, 0L);
case 108:
return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000ULL, active1, 0L);
case 110:
return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000ULL, active1, 0L);
case 111:
return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000ULL, active1, 0L);
case 112:
return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000ULL, active1, 0L);
case 114:
if ((active0 & 0x100000000ULL) != 0L)
return jjStartNfaWithStates_0(2, 32, 32);
return jjMoveStringLiteralDfa3_0(active0, 0x180000000000000ULL, active1, 0L);
case 115:
return jjMoveStringLiteralDfa3_0(active0, 0x2004022000ULL, active1, 0L);
case 116:
if ((active0 & 0x4000000000ULL) != 0L)
{
jjmatchedKind = 38;
jjmatchedPos = 2;
}
return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000ULL, active1, 0L);
case 117:
return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000ULL, active1, 0L);
case 119:
if ((active0 & 0x40000000000ULL) != 0L)
return jjStartNfaWithStates_0(2, 42, 32);
break;
case 121:
if ((active0 & 0x800000000000000ULL) != 0L)
return jjStartNfaWithStates_0(2, 59, 32);
break;
default :
break;
}
return jjStartNfa_0(1, active0, active1);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
if (((active0 &= old0) | (active1 &= old1)) == 0L)
return jjStartNfa_0(1, old0, old1);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(2, active0, active1);
return 3;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 61:
if ((active1 & 0x80000000000000ULL) != 0L)
return jjStopAtPos(3, 119);
break;
case 97:
return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000ULL, active1, 0L);
case 98:
return jjMoveStringLiteralDfa4_0(active0, 0x2000000ULL, active1, 0L);
case 99:
return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000ULL, active1, 0L);
case 100:
if ((active0 & 0x1000000000000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 60, 32);
break;
case 101:
if ((active0 & 0x10000ULL) != 0L)
return jjStartNfaWithStates_0(3, 16, 32);
else if ((active0 & 0x20000ULL) != 0L)
return jjStartNfaWithStates_0(3, 17, 32);
else if ((active0 & 0x4000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 26, 32);
else if ((active0 & 0x400000000000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 58, 32);
return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000ULL, active1, 0L);
case 103:
if ((active0 & 0x10000000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 40, 32);
break;
case 105:
return jjMoveStringLiteralDfa4_0(active0, 0x20000000000ULL, active1, 0L);
case 107:
return jjMoveStringLiteralDfa4_0(active0, 0x100000000000ULL, active1, 0L);
case 108:
if ((active0 & 0x80000000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 43, 32);
return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000ULL, active1, 0L);
case 110:
return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000ULL, active1, 0L);
case 111:
if ((active0 & 0x200000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 33, 32);
return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000ULL, active1, 0L);
case 114:
if ((active0 & 0x80000ULL) != 0L)
return jjStartNfaWithStates_0(3, 19, 32);
return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000ULL, active1, 0L);
case 115:
if ((active0 & 0x40000000000000ULL) != 0L)
return jjStartNfaWithStates_0(3, 54, 32);
return jjMoveStringLiteralDfa4_0(active0, 0x10300000ULL, active1, 0L);
case 116:
return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000ULL, active1, 0L);
case 117:
return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000ULL, active1, 0L);
case 118:
return jjMoveStringLiteralDfa4_0(active0, 0x200000000000ULL, active1, 0L);
default :
break;
}
return jjStartNfa_0(2, active0, active1);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa4_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
if (((active0 &= old0) | (active1 &= old1)) == 0L)
return jjStartNfa_0(2, old0, old1);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(3, active0, 0L);
return 4;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 97:
return jjMoveStringLiteralDfa5_0(active0, 0x302000000000ULL);
case 99:
return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000ULL);
case 101:
if ((active0 & 0x10000000ULL) != 0L)
return jjStartNfaWithStates_0(4, 28, 32);
else if ((active0 & 0x4000000000000000ULL) != 0L)
return jjStartNfaWithStates_0(4, 62, 32);
return jjMoveStringLiteralDfa5_0(active0, 0x400800004000ULL);
case 104:
if ((active0 & 0x40000ULL) != 0L)
return jjStartNfaWithStates_0(4, 18, 32);
return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000ULL);
case 105:
return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000ULL);
case 107:
if ((active0 & 0x8000ULL) != 0L)
return jjStartNfaWithStates_0(4, 15, 32);
break;
case 108:
if ((active0 & 0x20000000ULL) != 0L)
{
jjmatchedKind = 29;
jjmatchedPos = 4;
}
return jjMoveStringLiteralDfa5_0(active0, 0x42000000ULL);
case 110:
return jjMoveStringLiteralDfa5_0(active0, 0x8000000ULL);
case 114:
if ((active0 & 0x8000000000000ULL) != 0L)
return jjStartNfaWithStates_0(4, 51, 32);
return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000ULL);
case 115:
if ((active0 & 0x100000ULL) != 0L)
return jjStartNfaWithStates_0(4, 20, 32);
return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000ULL);
case 116:
if ((active0 & 0x200000ULL) != 0L)
return jjStartNfaWithStates_0(4, 21, 32);
else if ((active0 & 0x80000000ULL) != 0L)
return jjStartNfaWithStates_0(4, 31, 32);
else if ((active0 & 0x2000000000000ULL) != 0L)
return jjStartNfaWithStates_0(4, 49, 32);
return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000ULL);
case 117:
return jjMoveStringLiteralDfa5_0(active0, 0x800000ULL);
case 118:
return jjMoveStringLiteralDfa5_0(active0, 0x20000000000ULL);
case 119:
if ((active0 & 0x80000000000000ULL) != 0L)
{
jjmatchedKind = 55;
jjmatchedPos = 4;
}
return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000ULL);
default :
break;
}
return jjStartNfa_0(3, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa5_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(3, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(4, active0, 0L);
return 5;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 97:
return jjMoveStringLiteralDfa6_0(active0, 0x6000ULL);
case 99:
if ((active0 & 0x800000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 47, 32);
else if ((active0 & 0x4000000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 50, 32);
return jjMoveStringLiteralDfa6_0(active0, 0x400000000000ULL);
case 100:
return jjMoveStringLiteralDfa6_0(active0, 0x8000000ULL);
case 101:
if ((active0 & 0x2000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 25, 32);
else if ((active0 & 0x20000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 41, 32);
break;
case 102:
return jjMoveStringLiteralDfa6_0(active0, 0x8000000000ULL);
case 103:
return jjMoveStringLiteralDfa6_0(active0, 0x100000000000ULL);
case 104:
if ((active0 & 0x10000000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 52, 32);
break;
case 105:
return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000ULL);
case 108:
return jjMoveStringLiteralDfa6_0(active0, 0x40800000ULL);
case 109:
return jjMoveStringLiteralDfa6_0(active0, 0x800000000ULL);
case 110:
if ((active0 & 0x1000000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 48, 32);
return jjMoveStringLiteralDfa6_0(active0, 0x2000400000ULL);
case 114:
return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000ULL);
case 115:
if ((active0 & 0x100000000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 56, 32);
break;
case 116:
if ((active0 & 0x1000000000ULL) != 0L)
return jjStartNfaWithStates_0(5, 36, 32);
return jjMoveStringLiteralDfa6_0(active0, 0x200000000000ULL);
default :
break;
}
return jjStartNfa_0(4, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa6_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(4, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(5, active0, 0L);
return 6;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 97:
return jjMoveStringLiteralDfa7_0(active0, 0x8000000000ULL);
case 99:
return jjMoveStringLiteralDfa7_0(active0, 0x2000002000ULL);
case 101:
if ((active0 & 0x100000000000ULL) != 0L)
return jjStartNfaWithStates_0(6, 44, 32);
else if ((active0 & 0x200000000000ULL) != 0L)
return jjStartNfaWithStates_0(6, 45, 32);
return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000ULL);
case 108:
return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000ULL);
case 110:
if ((active0 & 0x4000ULL) != 0L)
return jjStartNfaWithStates_0(6, 14, 32);
break;
case 111:
return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000ULL);
case 115:
if ((active0 & 0x8000000ULL) != 0L)
return jjStartNfaWithStates_0(6, 27, 32);
break;
case 116:
if ((active0 & 0x800000ULL) != 0L)
return jjStartNfaWithStates_0(6, 23, 32);
return jjMoveStringLiteralDfa7_0(active0, 0x400000000000ULL);
case 117:
return jjMoveStringLiteralDfa7_0(active0, 0x400000ULL);
case 121:
if ((active0 & 0x40000000ULL) != 0L)
return jjStartNfaWithStates_0(6, 30, 32);
break;
default :
break;
}
return jjStartNfa_0(5, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa7_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(5, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(6, active0, 0L);
return 7;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 99:
return jjMoveStringLiteralDfa8_0(active0, 0x8000000000ULL);
case 101:
if ((active0 & 0x400000ULL) != 0L)
return jjStartNfaWithStates_0(7, 22, 32);
else if ((active0 & 0x2000000000000000ULL) != 0L)
return jjStartNfaWithStates_0(7, 61, 32);
return jjMoveStringLiteralDfa8_0(active0, 0x402000000000ULL);
case 110:
return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000ULL);
case 116:
if ((active0 & 0x2000ULL) != 0L)
return jjStartNfaWithStates_0(7, 13, 32);
break;
default :
break;
}
return jjStartNfa_0(6, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa8_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(6, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(7, active0, 0L);
return 8;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 100:
if ((active0 & 0x400000000000ULL) != 0L)
return jjStartNfaWithStates_0(8, 46, 32);
break;
case 101:
if ((active0 & 0x8000000000ULL) != 0L)
return jjStartNfaWithStates_0(8, 39, 32);
break;
case 105:
return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000ULL);
case 111:
return jjMoveStringLiteralDfa9_0(active0, 0x2000000000ULL);
case 116:
if ((active0 & 0x200000000000000ULL) != 0L)
return jjStartNfaWithStates_0(8, 57, 32);
return jjMoveStringLiteralDfa9_0(active0, 0x800000000ULL);
default :
break;
}
return jjStartNfa_0(7, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa9_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(7, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(8, active0, 0L);
return 9;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 102:
if ((active0 & 0x2000000000ULL) != 0L)
return jjStartNfaWithStates_0(9, 37, 32);
break;
case 115:
if ((active0 & 0x800000000ULL) != 0L)
return jjStartNfaWithStates_0(9, 35, 32);
break;
case 122:
return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000ULL);
default :
break;
}
return jjStartNfa_0(8, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa10_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(8, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(9, active0, 0L);
return 10;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 101:
return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000ULL);
default :
break;
}
return jjStartNfa_0(9, active0, 0L);
}
int JavaParserTokenManager::jjMoveStringLiteralDfa11_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(9, old0, 0L);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(10, active0, 0L);
return 11;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 100:
if ((active0 & 0x20000000000000ULL) != 0L)
return jjStartNfaWithStates_0(11, 53, 32);
break;
default :
break;
}
return jjStartNfa_0(10, active0, 0L);
}
int JavaParserTokenManager::jjStartNfaWithStates_0(int pos, int kind, int state){
jjmatchedKind = kind;
jjmatchedPos = pos;
if (input_stream->endOfInput()) { return pos + 1; }
curChar = input_stream->readChar();
return jjMoveNfa_0(state, pos + 1);
}
int JavaParserTokenManager::jjMoveNfa_0(int startState, int curPos){
int startsAt = 0;
jjnewStateCnt = 52;
int i = 1;
jjstateSet[0] = startState;
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
unsigned long long l = 1ULL << curChar;
(void)l;
do
{
switch(jjstateSet[--i])
{
case 3:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddStates(0, 6); }
else if (curChar == 36)
{
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
}
else if (curChar == 34)
{ jjCheckNAddStates(7, 9); }
else if (curChar == 39)
{ jjAddStates(10, 11); }
else if (curChar == 46)
{ jjCheckNAdd(8); }
else if (curChar == 47)
jjstateSet[jjnewStateCnt++] = 2;
if ((0x3fe000000000000ULL & l) != 0L)
{
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(5, 6); }
}
else if (curChar == 48)
{
if (kind > 63)
kind = 63;
{ jjCheckNAddStates(12, 14); }
}
break;
case 0:
if (curChar == 42)
jjstateSet[jjnewStateCnt++] = 1;
break;
case 1:
if ((0xffff7fffffffffffULL & l) != 0L && kind > 7)
kind = 7;
break;
case 2:
if (curChar == 42)
jjstateSet[jjnewStateCnt++] = 0;
break;
case 4:
if ((0x3fe000000000000ULL & l) == 0L)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(5, 6); }
break;
case 5:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(5, 6); }
break;
case 7:
if (curChar == 46)
{ jjCheckNAdd(8); }
break;
case 8:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddStates(15, 17); }
break;
case 10:
if ((0x280000000000ULL & l) != 0L)
{ jjCheckNAdd(11); }
break;
case 11:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddTwoStates(11, 12); }
break;
case 13:
if (curChar == 39)
{ jjAddStates(10, 11); }
break;
case 14:
if ((0xffffff7fffffdbffULL & l) != 0L)
{ jjCheckNAdd(15); }
break;
case 15:
if (curChar == 39 && kind > 69)
kind = 69;
break;
case 17:
if ((0x8400000000ULL & l) != 0L)
{ jjCheckNAdd(15); }
break;
case 18:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAddTwoStates(19, 15); }
break;
case 19:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAdd(15); }
break;
case 20:
if ((0xf000000000000ULL & l) != 0L)
jjstateSet[jjnewStateCnt++] = 21;
break;
case 21:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAdd(19); }
break;
case 22:
if (curChar == 34)
{ jjCheckNAddStates(7, 9); }
break;
case 23:
if ((0xfffffffbffffdbffULL & l) != 0L)
{ jjCheckNAddStates(7, 9); }
break;
case 25:
if ((0x8400000000ULL & l) != 0L)
{ jjCheckNAddStates(7, 9); }
break;
case 26:
if (curChar == 34 && kind > 70)
kind = 70;
break;
case 27:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAddStates(18, 21); }
break;
case 28:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAddStates(7, 9); }
break;
case 29:
if ((0xf000000000000ULL & l) != 0L)
jjstateSet[jjnewStateCnt++] = 30;
break;
case 30:
if ((0xff000000000000ULL & l) != 0L)
{ jjCheckNAdd(28); }
break;
case 31:
if (curChar != 36)
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
case 32:
if ((0x3ff00100fffc1ffULL & l) == 0L)
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
case 33:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddStates(0, 6); }
break;
case 34:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddTwoStates(34, 35); }
break;
case 35:
if (curChar != 46)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddStates(22, 24); }
break;
case 36:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddStates(22, 24); }
break;
case 38:
if ((0x280000000000ULL & l) != 0L)
{ jjCheckNAdd(39); }
break;
case 39:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddTwoStates(39, 12); }
break;
case 40:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddTwoStates(40, 41); }
break;
case 42:
if ((0x280000000000ULL & l) != 0L)
{ jjCheckNAdd(43); }
break;
case 43:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 67)
kind = 67;
{ jjCheckNAddTwoStates(43, 12); }
break;
case 44:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddStates(25, 27); }
break;
case 46:
if ((0x280000000000ULL & l) != 0L)
{ jjCheckNAdd(47); }
break;
case 47:
if ((0x3ff000000000000ULL & l) != 0L)
{ jjCheckNAddTwoStates(47, 12); }
break;
case 48:
if (curChar != 48)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddStates(12, 14); }
break;
case 50:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(50, 6); }
break;
case 51:
if ((0xff000000000000ULL & l) == 0L)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(51, 6); }
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
unsigned long long l = 1ULL << (curChar & 077);
(void)l;
do
{
switch(jjstateSet[--i])
{
case 3:
if ((0x7fffffe87fffffeULL & l) == 0L)
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
case 1:
if (kind > 7)
kind = 7;
break;
case 6:
if ((0x100000001000ULL & l) != 0L && kind > 63)
kind = 63;
break;
case 9:
if ((0x2000000020ULL & l) != 0L)
{ jjAddStates(28, 29); }
break;
case 12:
if ((0x5000000050ULL & l) != 0L && kind > 67)
kind = 67;
break;
case 14:
if ((0xffffffffefffffffULL & l) != 0L)
{ jjCheckNAdd(15); }
break;
case 16:
if (curChar == 92)
{ jjAddStates(30, 32); }
break;
case 17:
if ((0x14404410000000ULL & l) != 0L)
{ jjCheckNAdd(15); }
break;
case 23:
if ((0xffffffffefffffffULL & l) != 0L)
{ jjCheckNAddStates(7, 9); }
break;
case 24:
if (curChar == 92)
{ jjAddStates(33, 35); }
break;
case 25:
if ((0x14404410000000ULL & l) != 0L)
{ jjCheckNAddStates(7, 9); }
break;
case 32:
if ((0x87fffffe87fffffeULL & l) == 0L)
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
case 37:
if ((0x2000000020ULL & l) != 0L)
{ jjAddStates(36, 37); }
break;
case 41:
if ((0x2000000020ULL & l) != 0L)
{ jjAddStates(38, 39); }
break;
case 45:
if ((0x2000000020ULL & l) != 0L)
{ jjAddStates(40, 41); }
break;
case 49:
if ((0x100000001000000ULL & l) != 0L)
{ jjCheckNAdd(50); }
break;
case 50:
if ((0x7e0000007eULL & l) == 0L)
break;
if (kind > 63)
kind = 63;
{ jjCheckNAddTwoStates(50, 6); }
break;
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (curChar >> 8);
int i1 = hiByte >> 6;
unsigned long long l1 = 1ULL << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
unsigned long long l2 = 1ULL << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 3:
if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
case 1:
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
kind = 7;
break;
case 14:
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
jjstateSet[jjnewStateCnt++] = 15;
break;
case 23:
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
{ jjAddStates(7, 9); }
break;
case 32:
if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
break;
if (kind > 71)
kind = 71;
{ jjCheckNAdd(32); }
break;
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 52 - startsAt)))
return curPos;
if (input_stream->endOfInput()) { return curPos; }
curChar = input_stream->readChar();
}
}
int JavaParserTokenManager::jjMoveStringLiteralDfa0_3(){
switch(curChar)
{
case 42:
return jjMoveStringLiteralDfa1_3(0x800ULL);
default :
return 1;
}
}
int JavaParserTokenManager::jjMoveStringLiteralDfa1_3(unsigned long long active0){
if (input_stream->endOfInput()) {
return 1;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 47:
if ((active0 & 0x800ULL) != 0L)
return jjStopAtPos(1, 11);
break;
default :
return 2;
}
return 2;
}
int JavaParserTokenManager::jjMoveStringLiteralDfa0_1(){
return jjMoveNfa_1(0, 0);
}
int JavaParserTokenManager::jjMoveNfa_1(int startState, int curPos){
int startsAt = 0;
jjnewStateCnt = 3;
int i = 1;
jjstateSet[0] = startState;
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
unsigned long long l = 1ULL << curChar;
(void)l;
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0x2400ULL & l) != 0L)
{
if (kind > 9)
kind = 9;
}
if (curChar == 13)
jjstateSet[jjnewStateCnt++] = 1;
break;
case 1:
if (curChar == 10 && kind > 9)
kind = 9;
break;
case 2:
if (curChar == 13)
jjstateSet[jjnewStateCnt++] = 1;
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
unsigned long long l = 1ULL << (curChar & 077);
(void)l;
do
{
switch(jjstateSet[--i])
{
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (curChar >> 8);
int i1 = hiByte >> 6;
unsigned long long l1 = 1ULL << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
unsigned long long l2 = 1ULL << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
return curPos;
if (input_stream->endOfInput()) { return curPos; }
curChar = input_stream->readChar();
}
}
int JavaParserTokenManager::jjMoveStringLiteralDfa0_2(){
switch(curChar)
{
case 42:
return jjMoveStringLiteralDfa1_2(0x400ULL);
default :
return 1;
}
}
int JavaParserTokenManager::jjMoveStringLiteralDfa1_2(unsigned long long active0){
if (input_stream->endOfInput()) {
return 1;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 47:
if ((active0 & 0x400ULL) != 0L)
return jjStopAtPos(1, 10);
break;
default :
return 2;
}
return 2;
}
bool JavaParserTokenManager::jjCanMove_0(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){
switch(hiByte)
{
case 0:
return ((jjbitVec2[i2] & l2) != 0L);
default :
if ((jjbitVec0[i1] & l1) != 0L)
return true;
return false;
}
}
bool JavaParserTokenManager::jjCanMove_1(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){
switch(hiByte)
{
case 0:
return ((jjbitVec4[i2] & l2) != 0L);
case 2:
return ((jjbitVec5[i2] & l2) != 0L);
case 3:
return ((jjbitVec6[i2] & l2) != 0L);
case 4:
return ((jjbitVec7[i2] & l2) != 0L);
case 5:
return ((jjbitVec8[i2] & l2) != 0L);
case 6:
return ((jjbitVec9[i2] & l2) != 0L);
case 7:
return ((jjbitVec10[i2] & l2) != 0L);
case 9:
return ((jjbitVec11[i2] & l2) != 0L);
case 10:
return ((jjbitVec12[i2] & l2) != 0L);
case 11:
return ((jjbitVec13[i2] & l2) != 0L);
case 12:
return ((jjbitVec14[i2] & l2) != 0L);
case 13:
return ((jjbitVec15[i2] & l2) != 0L);
case 14:
return ((jjbitVec16[i2] & l2) != 0L);
case 15:
return ((jjbitVec17[i2] & l2) != 0L);
case 16:
return ((jjbitVec18[i2] & l2) != 0L);
case 17:
return ((jjbitVec19[i2] & l2) != 0L);
case 18:
return ((jjbitVec20[i2] & l2) != 0L);
case 19:
return ((jjbitVec21[i2] & l2) != 0L);
case 20:
return ((jjbitVec0[i2] & l2) != 0L);
case 22:
return ((jjbitVec22[i2] & l2) != 0L);
case 23:
return ((jjbitVec23[i2] & l2) != 0L);
case 24:
return ((jjbitVec24[i2] & l2) != 0L);
case 30:
return ((jjbitVec25[i2] & l2) != 0L);
case 31:
return ((jjbitVec26[i2] & l2) != 0L);
case 32:
return ((jjbitVec27[i2] & l2) != 0L);
case 33:
return ((jjbitVec28[i2] & l2) != 0L);
case 48:
return ((jjbitVec29[i2] & l2) != 0L);
case 49:
return ((jjbitVec30[i2] & l2) != 0L);
case 77:
return ((jjbitVec31[i2] & l2) != 0L);
case 159:
return ((jjbitVec32[i2] & l2) != 0L);
case 164:
return ((jjbitVec33[i2] & l2) != 0L);
case 215:
return ((jjbitVec34[i2] & l2) != 0L);
case 250:
return ((jjbitVec35[i2] & l2) != 0L);
case 251:
return ((jjbitVec36[i2] & l2) != 0L);
case 253:
return ((jjbitVec37[i2] & l2) != 0L);
case 254:
return ((jjbitVec38[i2] & l2) != 0L);
case 255:
return ((jjbitVec39[i2] & l2) != 0L);
default :
if ((jjbitVec3[i1] & l1) != 0L)
return true;
return false;
}
}
bool JavaParserTokenManager::jjCanMove_2(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){
switch(hiByte)
{
case 0:
return ((jjbitVec40[i2] & l2) != 0L);
case 2:
return ((jjbitVec5[i2] & l2) != 0L);
case 3:
return ((jjbitVec41[i2] & l2) != 0L);
case 4:
return ((jjbitVec42[i2] & l2) != 0L);
case 5:
return ((jjbitVec43[i2] & l2) != 0L);
case 6:
return ((jjbitVec44[i2] & l2) != 0L);
case 7:
return ((jjbitVec45[i2] & l2) != 0L);
case 9:
return ((jjbitVec46[i2] & l2) != 0L);
case 10:
return ((jjbitVec47[i2] & l2) != 0L);
case 11:
return ((jjbitVec48[i2] & l2) != 0L);
case 12:
return ((jjbitVec49[i2] & l2) != 0L);
case 13:
return ((jjbitVec50[i2] & l2) != 0L);
case 14:
return ((jjbitVec51[i2] & l2) != 0L);
case 15:
return ((jjbitVec52[i2] & l2) != 0L);
case 16:
return ((jjbitVec53[i2] & l2) != 0L);
case 17:
return ((jjbitVec19[i2] & l2) != 0L);
case 18:
return ((jjbitVec20[i2] & l2) != 0L);
case 19:
return ((jjbitVec54[i2] & l2) != 0L);
case 20:
return ((jjbitVec0[i2] & l2) != 0L);
case 22:
return ((jjbitVec22[i2] & l2) != 0L);
case 23:
return ((jjbitVec55[i2] & l2) != 0L);
case 24:
return ((jjbitVec56[i2] & l2) != 0L);
case 30:
return ((jjbitVec25[i2] & l2) != 0L);
case 31:
return ((jjbitVec26[i2] & l2) != 0L);
case 32:
return ((jjbitVec57[i2] & l2) != 0L);
case 33:
return ((jjbitVec28[i2] & l2) != 0L);
case 48:
return ((jjbitVec58[i2] & l2) != 0L);
case 49:
return ((jjbitVec30[i2] & l2) != 0L);
case 77:
return ((jjbitVec31[i2] & l2) != 0L);
case 159:
return ((jjbitVec32[i2] & l2) != 0L);
case 164:
return ((jjbitVec33[i2] & l2) != 0L);
case 215:
return ((jjbitVec34[i2] & l2) != 0L);
case 250:
return ((jjbitVec35[i2] & l2) != 0L);
case 251:
return ((jjbitVec59[i2] & l2) != 0L);
case 253:
return ((jjbitVec37[i2] & l2) != 0L);
case 254:
return ((jjbitVec60[i2] & l2) != 0L);
case 255:
return ((jjbitVec61[i2] & l2) != 0L);
default :
if ((jjbitVec3[i1] & l1) != 0L)
return true;
return false;
}
}
/** Token literal values. */
Token * JavaParserTokenManager::jjFillToken(){
Token *t;
JJString curTokenImage;
int beginLine = -1;
int endLine = -1;
int beginColumn = -1;
int endColumn = -1;
JJString im = jjstrLiteralImages[jjmatchedKind];
curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
if (input_stream->getTrackLineColumn()) {
beginLine = input_stream->getBeginLine();
beginColumn = input_stream->getBeginColumn();
endLine = input_stream->getEndLine();
endColumn = input_stream->getEndColumn();
}
t = Token::newToken(jjmatchedKind);
t->kind = jjmatchedKind;
t->image = curTokenImage;
t->specialToken = nullptr;
t->next = nullptr;
if (input_stream->getTrackLineColumn()) {
t->beginLine = beginLine;
t->endLine = endLine;
t->beginColumn = beginColumn;
t->endColumn = endColumn;
}
return t;
}
const int defaultLexState = 0;
/** Get the next Token. */
Token * JavaParserTokenManager::getNextToken(){
Token *specialToken = nullptr;
Token *matchedToken = nullptr;
int curPos = 0;
for (;;)
{
EOFLoop:
if (input_stream->endOfInput())
{
jjmatchedKind = 0;
jjmatchedPos = -1;
matchedToken = jjFillToken();
matchedToken->specialToken = specialToken;
return matchedToken;
}
curChar = input_stream->BeginToken();
image = jjimage;
image.clear();
jjimageLen = 0;
for (;;)
{
switch(curLexState)
{
case 0:
{ input_stream->backup(0);
while (curChar <= 32 && (0x100003600ULL & (1ULL << curChar)) != 0L)
{
if (input_stream->endOfInput()) { goto EOFLoop; }
curChar = input_stream->BeginToken();
}
}
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_0();
if (jjmatchedPos == 0 && jjmatchedKind > 120)
{
jjmatchedKind = 120;
}
break;
case 1:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_1();
if (jjmatchedPos == 0 && jjmatchedKind > 12)
{
jjmatchedKind = 12;
}
break;
case 2:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_2();
if (jjmatchedPos == 0 && jjmatchedKind > 12)
{
jjmatchedKind = 12;
}
break;
case 3:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_3();
if (jjmatchedPos == 0 && jjmatchedKind > 12)
{
jjmatchedKind = 12;
}
break;
}
if (jjmatchedKind != 0x7fffffff)
{
if (jjmatchedPos + 1 < curPos)
input_stream->backup(curPos - jjmatchedPos - 1);
if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
{
matchedToken = jjFillToken();
matchedToken->specialToken = specialToken;
TokenLexicalActions(matchedToken);
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
return matchedToken;
}
else if ((jjtoSkip[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
{
if ((jjtoSpecial[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
{
matchedToken = jjFillToken();
if (specialToken == nullptr)
specialToken = matchedToken;
else
{
matchedToken->specialToken = specialToken;
specialToken = (specialToken->next = matchedToken);
}
SkipLexicalActions(matchedToken);
}
else
SkipLexicalActions(nullptr);
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
goto EOFLoop;
}
MoreLexicalActions();
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
curPos = 0;
jjmatchedKind = 0x7fffffff;
if (!input_stream->endOfInput()) {
curChar = input_stream->readChar();
continue;
}
}
int error_line = input_stream->getEndLine();
int error_column = input_stream->getEndColumn();
JJString error_after;
bool EOFSeen = false;
if (input_stream->endOfInput()) {
EOFSeen = true;
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
if (curChar == '\n' || curChar == '\r') {
error_line++;
error_column = 0;
}
else
error_column++;
}
if (!EOFSeen) {
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
}
errorHandler->lexicalError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, this);
}
}
}
void JavaParserTokenManager::SkipLexicalActions(Token *matchedToken){
switch(jjmatchedKind)
{
default :
break;
}
}
void JavaParserTokenManager::MoreLexicalActions(){
jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
switch(jjmatchedKind)
{
case 7 : {
image.append(input_stream->GetSuffix(jjimageLen));
jjimageLen = 0;
input_stream->backup(1);
break;
}
default :
break;
}
}
void JavaParserTokenManager::TokenLexicalActions(Token *matchedToken){
switch(jjmatchedKind)
{
case 120 : {
image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
int i; i = 10; fprintf(stderr, "error: %d\n", i);
break;
}
default :
break;
}
}
/** Reinitialise parser. */
void JavaParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState) {
clear();
jjmatchedPos = jjnewStateCnt = 0;
curLexState = lexState;
input_stream = stream;
ReInitRounds();
debugStream = stdout; // init
SwitchTo(lexState);
errorHandler = new TokenManagerErrorHandler();
}
void JavaParserTokenManager::ReInitRounds() {
int i;
jjround = 0x80000001;
for (i = 52; i-- > 0;)
jjrounds[i] = 0x80000000;
}
/** Switch to specified lex state. */
void JavaParserTokenManager::SwitchTo(int lexState) {
if (lexState >= 4 || lexState < 0) {
JJString message;
#ifdef WIDE_CHAR
message += L"Error: Ignoring invalid lexical state : ";
message += lexState; message += L". State unchanged.";
#else
message += "Error: Ignoring invalid lexical state : ";
message += lexState; message += ". State unchanged.";
#endif
throw new TokenMgrError(message, INVALID_LEXICAL_STATE);
} else
curLexState = lexState;
}
/** Constructor. */
JavaParserTokenManager::JavaParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState)
: MyTm()
{
input_stream = nullptr;
ReInit(stream, lexState);
}
// Destructor
JavaParserTokenManager::~JavaParserTokenManager () {
clear();
}
// clear
void JavaParserTokenManager::clear() {
//Since input_stream was generated outside of TokenManager
//TokenManager should not take care of deleting it
//if (input_stream) delete input_stream;
if (errorHandler) delete errorHandler, errorHandler = nullptr;
}
}
}