| 1 |
/* OWL2FunctionalStyleParserTokenManager.cc */ |
| 2 |
#include "OWL2FunctionalStyleParserTokenManager.h" |
| 3 |
namespace Konclude { |
| 4 |
namespace Parser { |
| 5 |
namespace FunctionalJAVACC { |
| 6 |
static const unsigned long long jjbitVec0[] = { |
| 7 |
0xfffe7000fffffff6ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x5e00000000ffffffULL |
| 8 |
}; |
| 9 |
static const unsigned long long jjbitVec2[] = { |
| 10 |
0x0ULL, 0x0ULL, 0x0ULL, 0xff7fffffff7fffffULL |
| 11 |
}; |
| 12 |
static const unsigned long long jjbitVec3[] = { |
| 13 |
0x0ULL, 0xbfff000000000000ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 14 |
}; |
| 15 |
static const unsigned long long jjbitVec4[] = { |
| 16 |
0x3000ULL, 0xffff000000000000ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 17 |
}; |
| 18 |
static const unsigned long long jjbitVec5[] = { |
| 19 |
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffULL, 0x0ULL |
| 20 |
}; |
| 21 |
static const unsigned long long jjbitVec6[] = { |
| 22 |
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffULL |
| 23 |
}; |
| 24 |
static const unsigned long long jjbitVec7[] = { |
| 25 |
0xfffffffffffffffeULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 26 |
}; |
| 27 |
static const unsigned long long jjbitVec8[] = { |
| 28 |
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffff00000000ffffULL |
| 29 |
}; |
| 30 |
static const unsigned long long jjbitVec9[] = { |
| 31 |
0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x3fffffffffffffffULL |
| 32 |
}; |
| 33 |
static const unsigned long long jjbitVec10[] = { |
| 34 |
0x0ULL, 0x0ULL, 0x80000000000000ULL, 0xff7fffffff7fffffULL |
| 35 |
}; |
| 36 |
static const unsigned long long jjbitVec11[] = { |
| 37 |
0xffffffffffffffffULL, 0xbfffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 38 |
}; |
| 39 |
static const unsigned long long jjbitVec12[] = { |
| 40 |
0x8000000000003000ULL, 0xffff000000000001ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 41 |
}; |
| 42 |
static const unsigned long long jjbitVec13[] = { |
| 43 |
0x0ULL, 0x0ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL |
| 44 |
}; |
| 45 |
static const int jjnextStates[] = { |
| 46 |
6, 7, 8, |
| 47 |
}; |
| 48 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_0[] = {0}; |
| 49 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_1[] = {0}; |
| 50 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_2[] = {0}; |
| 51 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_3[] = {0}; |
| 52 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_4[] = {0}; |
| 53 |
|
| 54 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_5[] = {0x28, 0}; |
| 55 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_6[] = {0x29, 0}; |
| 56 |
|
| 57 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_7[] = {0x3d, 0}; |
| 58 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_8[] = {0x5e, 0x5e, 0}; |
| 59 |
|
| 60 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_9[] = {0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0}; |
| 61 |
|
| 62 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_10[] = {0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0}; |
| 63 |
|
| 64 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_11[] = {0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0}; |
| 65 |
|
| 66 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_12[] = {0x43, 0x6c, 0x61, 0x73, 0x73, 0}; |
| 67 |
|
| 68 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_13[] = {0x44, 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0}; |
| 69 |
|
| 70 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_14[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 71 |
|
| 72 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_15[] = {0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 73 |
|
| 74 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_16[] = {0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 75 |
|
| 76 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_17[] = {0x4e, 0x61, 0x6d, 0x65, 0x64, 0x49, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0}; |
| 77 |
|
| 78 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_18[] = {0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 79 |
|
| 80 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_19[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4f, 0x66, 0}; |
| 81 |
|
| 82 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_20[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0}; |
| 83 |
|
| 84 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_21[] = {0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x66, 0}; |
| 85 |
|
| 86 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_22[] = {0x4f, 0x6e, 0x65, 0x4f, 0x66, 0}; |
| 87 |
|
| 88 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_23[] = {0x44, 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 89 |
|
| 90 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_24[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0}; |
| 91 |
|
| 92 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_25[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0}; |
| 93 |
|
| 94 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_26[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x66, 0}; |
| 95 |
|
| 96 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_27[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x65, 0x4f, 0x66, 0}; |
| 97 |
|
| 98 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_28[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x6f, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0}; |
| 99 |
|
| 100 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_29[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x41, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0}; |
| 101 |
|
| 102 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_30[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0}; |
| 103 |
|
| 104 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_31[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x53, 0x65, 0x6c, 0x66, 0}; |
| 105 |
|
| 106 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_32[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x69, 0x6e, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 107 |
|
| 108 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_33[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x61, 0x78, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 109 |
|
| 110 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_34[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x45, 0x78, 0x61, 0x63, 0x74, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 111 |
|
| 112 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_35[] = {0x44, 0x61, 0x74, 0x61, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0}; |
| 113 |
|
| 114 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_36[] = {0x44, 0x61, 0x74, 0x61, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x4f, 0x66, 0}; |
| 115 |
|
| 116 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_37[] = {0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x66, 0}; |
| 117 |
|
| 118 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_38[] = {0x44, 0x61, 0x74, 0x61, 0x4f, 0x6e, 0x65, 0x4f, 0x66, 0}; |
| 119 |
|
| 120 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_39[] = {0x44, 0x61, 0x74, 0x61, 0x53, 0x6f, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0}; |
| 121 |
|
| 122 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_40[] = {0x44, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0}; |
| 123 |
|
| 124 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_41[] = {0x44, 0x61, 0x74, 0x61, 0x48, 0x61, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0}; |
| 125 |
|
| 126 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_42[] = {0x44, 0x61, 0x74, 0x61, 0x4d, 0x69, 0x6e, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 127 |
|
| 128 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_43[] = {0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x78, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 129 |
|
| 130 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_44[] = {0x44, 0x61, 0x74, 0x61, 0x45, 0x78, 0x61, 0x63, 0x74, 0x43, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0}; |
| 131 |
|
| 132 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_45[] = {0x53, 0x75, 0x62, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x4f, 0x66, 0}; |
| 133 |
|
| 134 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_46[] = {0x45, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0}; |
| 135 |
|
| 136 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_47[] = {0x44, 0x69, 0x73, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0}; |
| 137 |
|
| 138 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_48[] = {0x44, 0x69, 0x73, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0}; |
| 139 |
|
| 140 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_49[] = {0x53, 0x75, 0x62, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4f, 0x66, 0}; |
| 141 |
|
| 142 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_50[] = {0x45, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0}; |
| 143 |
|
| 144 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_51[] = {0x44, 0x69, 0x73, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0}; |
| 145 |
|
| 146 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_52[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0}; |
| 147 |
|
| 148 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_53[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0}; |
| 149 |
|
| 150 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_54[] = {0x49, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0}; |
| 151 |
|
| 152 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_55[] = {0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 153 |
|
| 154 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_56[] = {0x49, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 155 |
|
| 156 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_57[] = {0x52, 0x65, 0x66, 0x6c, 0x65, 0x78, 0x69, 0x76, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 157 |
|
| 158 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_58[] = {0x49, 0x72, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x78, 0x69, 0x76, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 159 |
|
| 160 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_59[] = {0x53, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 161 |
|
| 162 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_60[] = {0x41, 0x73, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 163 |
|
| 164 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_61[] = {0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 165 |
|
| 166 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_62[] = {0x53, 0x75, 0x62, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4f, 0x66, 0}; |
| 167 |
|
| 168 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_63[] = {0x45, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0}; |
| 169 |
|
| 170 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_64[] = {0x44, 0x69, 0x73, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0}; |
| 171 |
|
| 172 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_65[] = {0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0}; |
| 173 |
|
| 174 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_66[] = {0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0}; |
| 175 |
|
| 176 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_67[] = {0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0}; |
| 177 |
|
| 178 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_68[] = {0x44, 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 179 |
|
| 180 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_69[] = {0x48, 0x61, 0x73, 0x4b, 0x65, 0x79, 0}; |
| 181 |
|
| 182 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_70[] = {0x53, 0x61, 0x6d, 0x65, 0x49, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0}; |
| 183 |
|
| 184 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_71[] = {0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x73, 0}; |
| 185 |
|
| 186 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_72[] = {0x43, 0x6c, 0x61, 0x73, 0x73, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 187 |
|
| 188 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_73[] = {0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 189 |
|
| 190 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_74[] = {0x4e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 191 |
|
| 192 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_75[] = {0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 193 |
|
| 194 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_76[] = {0x4e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 195 |
|
| 196 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_77[] = {0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 197 |
|
| 198 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_78[] = {0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0}; |
| 199 |
|
| 200 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_79[] = {0x53, 0x75, 0x62, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4f, 0x66, 0}; |
| 201 |
|
| 202 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_80[] = {0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0}; |
| 203 |
|
| 204 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_81[] = {0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0}; |
| 205 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_82[] = {0}; |
| 206 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_83[] = {0}; |
| 207 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_84[] = {0}; |
| 208 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_85[] = {0}; |
| 209 |
|
| 210 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_86[] = {0x5f, 0x3a, 0}; |
| 211 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_87[] = {0}; |
| 212 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_88[] = {0}; |
| 213 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_89[] = {0}; |
| 214 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_90[] = {0}; |
| 215 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_91[] = {0}; |
| 216 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_92[] = {0}; |
| 217 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_93[] = {0}; |
| 218 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_94[] = {0}; |
| 219 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_95[] = {0}; |
| 220 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_96[] = {0}; |
| 221 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_97[] = {0}; |
| 222 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_98[] = {0}; |
| 223 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_99[] = {0}; |
| 224 |
|
| 225 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_100[] = {0}; |
| 226 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_101[] = {0}; |
| 227 |
static JAVACC_CHAR_TYPE jjstrLiteralChars_102[] = {0}; |
| 228 |
static const JAVACC_STRING_TYPE jjstrLiteralImages[] = { |
| 229 |
jjstrLiteralChars_0, |
| 230 |
jjstrLiteralChars_1, |
| 231 |
jjstrLiteralChars_2, |
| 232 |
jjstrLiteralChars_3, |
| 233 |
jjstrLiteralChars_4, |
| 234 |
jjstrLiteralChars_5, |
| 235 |
jjstrLiteralChars_6, |
| 236 |
jjstrLiteralChars_7, |
| 237 |
jjstrLiteralChars_8, |
| 238 |
jjstrLiteralChars_9, |
| 239 |
jjstrLiteralChars_10, |
| 240 |
jjstrLiteralChars_11, |
| 241 |
jjstrLiteralChars_12, |
| 242 |
jjstrLiteralChars_13, |
| 243 |
jjstrLiteralChars_14, |
| 244 |
jjstrLiteralChars_15, |
| 245 |
jjstrLiteralChars_16, |
| 246 |
jjstrLiteralChars_17, |
| 247 |
jjstrLiteralChars_18, |
| 248 |
jjstrLiteralChars_19, |
| 249 |
jjstrLiteralChars_20, |
| 250 |
jjstrLiteralChars_21, |
| 251 |
jjstrLiteralChars_22, |
| 252 |
jjstrLiteralChars_23, |
| 253 |
jjstrLiteralChars_24, |
| 254 |
jjstrLiteralChars_25, |
| 255 |
jjstrLiteralChars_26, |
| 256 |
jjstrLiteralChars_27, |
| 257 |
jjstrLiteralChars_28, |
| 258 |
jjstrLiteralChars_29, |
| 259 |
jjstrLiteralChars_30, |
| 260 |
jjstrLiteralChars_31, |
| 261 |
jjstrLiteralChars_32, |
| 262 |
jjstrLiteralChars_33, |
| 263 |
jjstrLiteralChars_34, |
| 264 |
jjstrLiteralChars_35, |
| 265 |
jjstrLiteralChars_36, |
| 266 |
jjstrLiteralChars_37, |
| 267 |
jjstrLiteralChars_38, |
| 268 |
jjstrLiteralChars_39, |
| 269 |
jjstrLiteralChars_40, |
| 270 |
jjstrLiteralChars_41, |
| 271 |
jjstrLiteralChars_42, |
| 272 |
jjstrLiteralChars_43, |
| 273 |
jjstrLiteralChars_44, |
| 274 |
jjstrLiteralChars_45, |
| 275 |
jjstrLiteralChars_46, |
| 276 |
jjstrLiteralChars_47, |
| 277 |
jjstrLiteralChars_48, |
| 278 |
jjstrLiteralChars_49, |
| 279 |
jjstrLiteralChars_50, |
| 280 |
jjstrLiteralChars_51, |
| 281 |
jjstrLiteralChars_52, |
| 282 |
jjstrLiteralChars_53, |
| 283 |
jjstrLiteralChars_54, |
| 284 |
jjstrLiteralChars_55, |
| 285 |
jjstrLiteralChars_56, |
| 286 |
jjstrLiteralChars_57, |
| 287 |
jjstrLiteralChars_58, |
| 288 |
jjstrLiteralChars_59, |
| 289 |
jjstrLiteralChars_60, |
| 290 |
jjstrLiteralChars_61, |
| 291 |
jjstrLiteralChars_62, |
| 292 |
jjstrLiteralChars_63, |
| 293 |
jjstrLiteralChars_64, |
| 294 |
jjstrLiteralChars_65, |
| 295 |
jjstrLiteralChars_66, |
| 296 |
jjstrLiteralChars_67, |
| 297 |
jjstrLiteralChars_68, |
| 298 |
jjstrLiteralChars_69, |
| 299 |
jjstrLiteralChars_70, |
| 300 |
jjstrLiteralChars_71, |
| 301 |
jjstrLiteralChars_72, |
| 302 |
jjstrLiteralChars_73, |
| 303 |
jjstrLiteralChars_74, |
| 304 |
jjstrLiteralChars_75, |
| 305 |
jjstrLiteralChars_76, |
| 306 |
jjstrLiteralChars_77, |
| 307 |
jjstrLiteralChars_78, |
| 308 |
jjstrLiteralChars_79, |
| 309 |
jjstrLiteralChars_80, |
| 310 |
jjstrLiteralChars_81, |
| 311 |
jjstrLiteralChars_82, |
| 312 |
jjstrLiteralChars_83, |
| 313 |
jjstrLiteralChars_84, |
| 314 |
jjstrLiteralChars_85, |
| 315 |
jjstrLiteralChars_86, |
| 316 |
jjstrLiteralChars_87, |
| 317 |
jjstrLiteralChars_88, |
| 318 |
jjstrLiteralChars_89, |
| 319 |
jjstrLiteralChars_90, |
| 320 |
jjstrLiteralChars_91, |
| 321 |
jjstrLiteralChars_92, |
| 322 |
jjstrLiteralChars_93, |
| 323 |
jjstrLiteralChars_94, |
| 324 |
jjstrLiteralChars_95, |
| 325 |
jjstrLiteralChars_96, |
| 326 |
jjstrLiteralChars_97, |
| 327 |
jjstrLiteralChars_98, |
| 328 |
jjstrLiteralChars_99, |
| 329 |
jjstrLiteralChars_100, |
| 330 |
jjstrLiteralChars_101, |
| 331 |
jjstrLiteralChars_102, |
| 332 |
}; |
| 333 |
|
| 334 |
/** Lexer state names. */ |
| 335 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_0[] = |
| 336 |
{0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0}; |
| 337 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_1[] = |
| 338 |
{0x46, 0x75, 0x6c, 0x6c, 0x49, 0x72, 0x69, 0}; |
| 339 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_2[] = |
| 340 |
{0x46, 0x75, 0x6c, 0x6c, 0x49, 0x72, 0x69, 0x45, 0x6e, 0x64, 0}; |
| 341 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_3[] = |
| 342 |
{0x41, 0x66, 0x74, 0x65, 0x72, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0}; |
| 343 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_4[] = |
| 344 |
{0x51, 0x75, 0x6f, 0x74, 0x65, 0x64, 0x51, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0}; |
| 345 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_5[] = |
| 346 |
{0x51, 0x75, 0x6f, 0x74, 0x65, 0x64, 0x51, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x64, 0}; |
| 347 |
static const JAVACC_CHAR_TYPE lexStateNames_arr_6[] = |
| 348 |
{0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0}; |
| 349 |
static const JAVACC_STRING_TYPE lexStateNames[] = { |
| 350 |
lexStateNames_arr_0, |
| 351 |
lexStateNames_arr_1, |
| 352 |
lexStateNames_arr_2, |
| 353 |
lexStateNames_arr_3, |
| 354 |
lexStateNames_arr_4, |
| 355 |
lexStateNames_arr_5, |
| 356 |
lexStateNames_arr_6, |
| 357 |
}; |
| 358 |
|
| 359 |
/** Lex State array. */ |
| 360 |
static const int jjnewLexState[] = { |
| 361 |
-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, |
| 362 |
-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, |
| 363 |
-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, |
| 364 |
-1, -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, 3, -1, -1, -1, -1, 1, 4, 6, 2, 0, 0, 0, 5, 0, |
| 365 |
0, 0, -1, |
| 366 |
}; |
| 367 |
static const unsigned long long jjtoToken[] = { |
| 368 |
0xffffffffffffffe1ULL, 0x5405fffffULL, |
| 369 |
}; |
| 370 |
static const unsigned long long jjtoSkip[] = { |
| 371 |
0x1eULL, 0x7ab8000000ULL, |
| 372 |
}; |
| 373 |
|
| 374 |
void OWL2FunctionalStyleParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; } |
| 375 |
|
| 376 |
int OWL2FunctionalStyleParserTokenManager::jjStopStringLiteralDfa_0(int pos, unsigned long long active0, unsigned long long active1){ |
| 377 |
switch (pos) |
| 378 |
{ |
| 379 |
case 0: |
| 380 |
if ((active0 & 0xfffffffffffffe00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 381 |
return 9; |
| 382 |
return -1; |
| 383 |
case 1: |
| 384 |
if ((active0 & 0xfffffffffffffe00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 385 |
return 9; |
| 386 |
return -1; |
| 387 |
case 2: |
| 388 |
if ((active0 & 0xfffffffffffffe00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 389 |
return 9; |
| 390 |
return -1; |
| 391 |
case 3: |
| 392 |
if ((active0 & 0xfffffffffffffe00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 393 |
return 9; |
| 394 |
return -1; |
| 395 |
case 4: |
| 396 |
if ((active0 & 0xfffffffffffffe00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 397 |
return 9; |
| 398 |
return -1; |
| 399 |
case 5: |
| 400 |
if ((active0 & 0xffffffffffbfee00ULL) != 0L || (active1 & 0x3ffffULL) != 0L) |
| 401 |
return 9; |
| 402 |
return -1; |
| 403 |
case 6: |
| 404 |
if ((active0 & 0xffffffffffbfe400ULL) != 0L || (active1 & 0x3ffdfULL) != 0L) |
| 405 |
return 9; |
| 406 |
return -1; |
| 407 |
case 7: |
| 408 |
if ((active0 & 0xffffffffffbfe400ULL) != 0L || (active1 & 0x3ffdfULL) != 0L) |
| 409 |
return 9; |
| 410 |
return -1; |
| 411 |
case 8: |
| 412 |
if ((active0 & 0xffffffffffbfc000ULL) != 0L || (active1 & 0x3ffdfULL) != 0L) |
| 413 |
return 9; |
| 414 |
return -1; |
| 415 |
case 9: |
| 416 |
if ((active0 & 0xffffffbfffbfc000ULL) != 0L || (active1 & 0x3ffdfULL) != 0L) |
| 417 |
return 9; |
| 418 |
return -1; |
| 419 |
case 10: |
| 420 |
if ((active0 & 0xffffdfbfffbfc000ULL) != 0L || (active1 & 0x3dfdfULL) != 0L) |
| 421 |
return 9; |
| 422 |
return -1; |
| 423 |
case 11: |
| 424 |
if ((active0 & 0xffffdfaff7bbc000ULL) != 0L || (active1 & 0x3dfdfULL) != 0L) |
| 425 |
return 9; |
| 426 |
return -1; |
| 427 |
case 12: |
| 428 |
if ((active0 & 0xffffddaff79b4000ULL) != 0L || (active1 & 0x3dfdfULL) != 0L) |
| 429 |
return 9; |
| 430 |
return -1; |
| 431 |
case 13: |
| 432 |
if ((active0 & 0xfffeddaf759b4000ULL) != 0L || (active1 & 0x3dfdfULL) != 0L) |
| 433 |
return 9; |
| 434 |
return -1; |
| 435 |
case 14: |
| 436 |
if ((active0 & 0xfffeddaf359b0000ULL) != 0L || (active1 & 0x3de9fULL) != 0L) |
| 437 |
return 9; |
| 438 |
return -1; |
| 439 |
case 15: |
| 440 |
if ((active0 & 0xfffe5daf35910000ULL) != 0L || (active1 & 0x3de9fULL) != 0L) |
| 441 |
return 9; |
| 442 |
return -1; |
| 443 |
case 16: |
| 444 |
if ((active0 & 0xfffe5d8f35910000ULL) != 0L || (active1 & 0x3de9fULL) != 0L) |
| 445 |
return 9; |
| 446 |
return -1; |
| 447 |
case 17: |
| 448 |
if ((active0 & 0xbffe1c8f35910000ULL) != 0L || (active1 & 0x3de9bULL) != 0L) |
| 449 |
return 9; |
| 450 |
return -1; |
| 451 |
case 18: |
| 452 |
if ((active0 & 0xbffe100731900000ULL) != 0L || (active1 & 0x3de89ULL) != 0L) |
| 453 |
return 9; |
| 454 |
return -1; |
| 455 |
case 19: |
| 456 |
if ((active0 & 0xbfdc100711000000ULL) != 0L || (active1 & 0x39e89ULL) != 0L) |
| 457 |
return 9; |
| 458 |
return -1; |
| 459 |
case 20: |
| 460 |
if ((active0 & 0xbfcc000400000000ULL) != 0L || (active1 & 0x39e09ULL) != 0L) |
| 461 |
return 9; |
| 462 |
return -1; |
| 463 |
case 21: |
| 464 |
if ((active0 & 0xbfcc000400000000ULL) != 0L || (active1 & 0x39609ULL) != 0L) |
| 465 |
return 9; |
| 466 |
return -1; |
| 467 |
case 22: |
| 468 |
if ((active0 & 0xbfcc000000000000ULL) != 0L || (active1 & 0x39600ULL) != 0L) |
| 469 |
return 9; |
| 470 |
return -1; |
| 471 |
case 23: |
| 472 |
if ((active0 & 0xb58c000000000000ULL) != 0L || (active1 & 0x11400ULL) != 0L) |
| 473 |
return 9; |
| 474 |
return -1; |
| 475 |
case 24: |
| 476 |
if ((active0 & 0x504000000000000ULL) != 0L || (active1 & 0x1400ULL) != 0L) |
| 477 |
return 9; |
| 478 |
return -1; |
| 479 |
case 25: |
| 480 |
if ((active0 & 0x104000000000000ULL) != 0L || (active1 & 0x1400ULL) != 0L) |
| 481 |
return 9; |
| 482 |
return -1; |
| 483 |
case 26: |
| 484 |
if ((active0 & 0x100000000000000ULL) != 0L || (active1 & 0x1400ULL) != 0L) |
| 485 |
return 9; |
| 486 |
return -1; |
| 487 |
case 27: |
| 488 |
if ((active0 & 0x100000000000000ULL) != 0L || (active1 & 0x1400ULL) != 0L) |
| 489 |
return 9; |
| 490 |
return -1; |
| 491 |
case 28: |
| 492 |
if ((active0 & 0x100000000000000ULL) != 0L || (active1 & 0x1400ULL) != 0L) |
| 493 |
return 9; |
| 494 |
return -1; |
| 495 |
case 29: |
| 496 |
if ((active0 & 0x100000000000000ULL) != 0L || (active1 & 0x400ULL) != 0L) |
| 497 |
return 9; |
| 498 |
return -1; |
| 499 |
default : |
| 500 |
return -1; |
| 501 |
} |
| 502 |
} |
| 503 |
|
| 504 |
int OWL2FunctionalStyleParserTokenManager::jjStartNfa_0(int pos, unsigned long long active0, unsigned long long active1){ |
| 505 |
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); |
| 506 |
} |
| 507 |
|
| 508 |
int OWL2FunctionalStyleParserTokenManager::jjStopAtPos(int pos, int kind){ |
| 509 |
jjmatchedKind = kind; |
| 510 |
jjmatchedPos = pos; |
| 511 |
return pos + 1; |
| 512 |
} |
| 513 |
|
| 514 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_0(){ |
| 515 |
switch(curChar) |
| 516 |
{ |
| 517 |
case 34: |
| 518 |
return jjStopAtPos(0, 92); |
| 519 |
case 35: |
| 520 |
return jjStopAtPos(0, 93); |
| 521 |
case 40: |
| 522 |
return jjStopAtPos(0, 5); |
| 523 |
case 41: |
| 524 |
return jjStopAtPos(0, 6); |
| 525 |
case 60: |
| 526 |
return jjStopAtPos(0, 91); |
| 527 |
case 61: |
| 528 |
return jjStopAtPos(0, 7); |
| 529 |
case 65: |
| 530 |
return jjMoveStringLiteralDfa1_0(0x1000000000010000ULL, 0x36000ULL); |
| 531 |
case 67: |
| 532 |
return jjMoveStringLiteralDfa1_0(0x201000ULL, 0x100ULL); |
| 533 |
case 68: |
| 534 |
return jjMoveStringLiteralDfa1_0(0x99ff80084a000ULL, 0x897ULL); |
| 535 |
case 69: |
| 536 |
return jjMoveStringLiteralDfa1_0(0x8004400000000000ULL, 0x0ULL); |
| 537 |
case 70: |
| 538 |
return jjMoveStringLiteralDfa1_0(0x80000000000000ULL, 0x8ULL); |
| 539 |
case 72: |
| 540 |
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x20ULL); |
| 541 |
case 73: |
| 542 |
return jjMoveStringLiteralDfa1_0(0x540000000000800ULL, 0x0ULL); |
| 543 |
case 78: |
| 544 |
return jjMoveStringLiteralDfa1_0(0x20000ULL, 0x1400ULL); |
| 545 |
case 79: |
| 546 |
return jjMoveStringLiteralDfa1_0(0x300007ff584400ULL, 0x200ULL); |
| 547 |
case 80: |
| 548 |
return jjMoveStringLiteralDfa1_0(0x200ULL, 0x0ULL); |
| 549 |
case 82: |
| 550 |
return jjMoveStringLiteralDfa1_0(0x200000000000000ULL, 0x0ULL); |
| 551 |
case 83: |
| 552 |
return jjMoveStringLiteralDfa1_0(0x4802200000000000ULL, 0x8040ULL); |
| 553 |
case 84: |
| 554 |
return jjMoveStringLiteralDfa1_0(0x2000000000000000ULL, 0x0ULL); |
| 555 |
case 94: |
| 556 |
return jjMoveStringLiteralDfa1_0(0x100ULL, 0x0ULL); |
| 557 |
case 95: |
| 558 |
return jjMoveStringLiteralDfa1_0(0x0ULL, 0x400000ULL); |
| 559 |
default : |
| 560 |
return jjMoveNfa_0(1, 0); |
| 561 |
} |
| 562 |
} |
| 563 |
|
| 564 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa1_0(unsigned long long active0, unsigned long long active1){ |
| 565 |
if (input_stream->endOfInput()) { |
| 566 |
jjStopStringLiteralDfa_0(0, active0, active1); |
| 567 |
return 1; |
| 568 |
} |
| 569 |
curChar = input_stream->readChar(); |
| 570 |
switch(curChar) |
| 571 |
{ |
| 572 |
case 58: |
| 573 |
if ((active1 & 0x400000ULL) != 0L) |
| 574 |
return jjStopAtPos(1, 86); |
| 575 |
break; |
| 576 |
case 94: |
| 577 |
if ((active0 & 0x100ULL) != 0L) |
| 578 |
return jjStopAtPos(1, 8); |
| 579 |
break; |
| 580 |
case 97: |
| 581 |
return jjMoveStringLiteralDfa2_0(active0, 0x1ff80082a000ULL, active1, 0x876ULL); |
| 582 |
case 98: |
| 583 |
return jjMoveStringLiteralDfa2_0(active0, 0x300007ff184000ULL, active1, 0x200ULL); |
| 584 |
case 101: |
| 585 |
return jjMoveStringLiteralDfa2_0(active0, 0x200000000040000ULL, active1, 0x1400ULL); |
| 586 |
case 105: |
| 587 |
return jjMoveStringLiteralDfa2_0(active0, 0x9800000000000ULL, active1, 0x81ULL); |
| 588 |
case 108: |
| 589 |
return jjMoveStringLiteralDfa2_0(active0, 0x1000ULL, active1, 0x100ULL); |
| 590 |
case 109: |
| 591 |
return jjMoveStringLiteralDfa2_0(active0, 0x800ULL, active1, 0L); |
| 592 |
case 110: |
| 593 |
return jjMoveStringLiteralDfa2_0(active0, 0x140000000410400ULL, active1, 0x36000ULL); |
| 594 |
case 111: |
| 595 |
return jjMoveStringLiteralDfa2_0(active0, 0x200000ULL, active1, 0L); |
| 596 |
case 113: |
| 597 |
return jjMoveStringLiteralDfa2_0(active0, 0x8004400000000000ULL, active1, 0L); |
| 598 |
case 114: |
| 599 |
return jjMoveStringLiteralDfa2_0(active0, 0x2400000000000200ULL, active1, 0L); |
| 600 |
case 115: |
| 601 |
return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000ULL, active1, 0L); |
| 602 |
case 117: |
| 603 |
return jjMoveStringLiteralDfa2_0(active0, 0x4082200000000000ULL, active1, 0x8008ULL); |
| 604 |
case 121: |
| 605 |
return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000ULL, active1, 0L); |
| 606 |
default : |
| 607 |
break; |
| 608 |
} |
| 609 |
return jjStartNfa_0(0, active0, active1); |
| 610 |
} |
| 611 |
|
| 612 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 613 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 614 |
return jjStartNfa_0(0, old0, old1); |
| 615 |
if (input_stream->endOfInput()) { |
| 616 |
jjStopStringLiteralDfa_0(1, active0, active1); |
| 617 |
return 2; |
| 618 |
} |
| 619 |
curChar = input_stream->readChar(); |
| 620 |
switch(curChar) |
| 621 |
{ |
| 622 |
case 97: |
| 623 |
return jjMoveStringLiteralDfa3_0(active0, 0x2000000000001000ULL, active1, 0x100ULL); |
| 624 |
case 98: |
| 625 |
return jjMoveStringLiteralDfa3_0(active0, 0x4002200000000000ULL, active1, 0x8000ULL); |
| 626 |
case 99: |
| 627 |
return jjMoveStringLiteralDfa3_0(active0, 0x40000ULL, active1, 0L); |
| 628 |
case 101: |
| 629 |
return jjMoveStringLiteralDfa3_0(active0, 0x400200ULL, active1, 0L); |
| 630 |
case 102: |
| 631 |
return jjMoveStringLiteralDfa3_0(active0, 0x200000000000000ULL, active1, 0x80ULL); |
| 632 |
case 103: |
| 633 |
return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1400ULL); |
| 634 |
case 106: |
| 635 |
return jjMoveStringLiteralDfa3_0(active0, 0x300007ff184000ULL, active1, 0x200ULL); |
| 636 |
case 109: |
| 637 |
return jjMoveStringLiteralDfa3_0(active0, 0x800000000220000ULL, active1, 0x40ULL); |
| 638 |
case 110: |
| 639 |
return jjMoveStringLiteralDfa3_0(active0, 0x80000000010000ULL, active1, 0x36008ULL); |
| 640 |
case 112: |
| 641 |
return jjMoveStringLiteralDfa3_0(active0, 0x800ULL, active1, 0L); |
| 642 |
case 114: |
| 643 |
return jjMoveStringLiteralDfa3_0(active0, 0x400000000000000ULL, active1, 0L); |
| 644 |
case 115: |
| 645 |
return jjMoveStringLiteralDfa3_0(active0, 0x9800000000000ULL, active1, 0x21ULL); |
| 646 |
case 116: |
| 647 |
return jjMoveStringLiteralDfa3_0(active0, 0x1ff80080a400ULL, active1, 0x816ULL); |
| 648 |
case 117: |
| 649 |
return jjMoveStringLiteralDfa3_0(active0, 0x8004400000000000ULL, active1, 0L); |
| 650 |
case 118: |
| 651 |
return jjMoveStringLiteralDfa3_0(active0, 0x140000000000000ULL, active1, 0L); |
| 652 |
case 121: |
| 653 |
return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000000ULL, active1, 0L); |
| 654 |
default : |
| 655 |
break; |
| 656 |
} |
| 657 |
return jjStartNfa_0(1, active0, active1); |
| 658 |
} |
| 659 |
|
| 660 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 661 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 662 |
return jjStartNfa_0(1, old0, old1); |
| 663 |
if (input_stream->endOfInput()) { |
| 664 |
jjStopStringLiteralDfa_0(2, active0, active1); |
| 665 |
return 3; |
| 666 |
} |
| 667 |
curChar = input_stream->readChar(); |
| 668 |
switch(curChar) |
| 669 |
{ |
| 670 |
case 65: |
| 671 |
return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x8000ULL); |
| 672 |
case 67: |
| 673 |
return jjMoveStringLiteralDfa4_0(active0, 0x200000000000ULL, active1, 0L); |
| 674 |
case 68: |
| 675 |
return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000000ULL, active1, 0L); |
| 676 |
case 75: |
| 677 |
return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20ULL); |
| 678 |
case 79: |
| 679 |
return jjMoveStringLiteralDfa4_0(active0, 0x2000000400000ULL, active1, 0L); |
| 680 |
case 97: |
| 681 |
return jjMoveStringLiteralDfa4_0(active0, 0x1ff80080a000ULL, active1, 0x1c16ULL); |
| 682 |
case 99: |
| 683 |
return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000ULL, active1, 0x8ULL); |
| 684 |
case 101: |
| 685 |
return jjMoveStringLiteralDfa4_0(active0, 0x5700007ff1a4000ULL, active1, 0x240ULL); |
| 686 |
case 102: |
| 687 |
return jjMoveStringLiteralDfa4_0(active0, 0x200ULL, active1, 0x80ULL); |
| 688 |
case 105: |
| 689 |
return jjMoveStringLiteralDfa4_0(active0, 0x8004400000000000ULL, active1, 0L); |
| 690 |
case 106: |
| 691 |
return jjMoveStringLiteralDfa4_0(active0, 0x9800000000000ULL, active1, 0x1ULL); |
| 692 |
case 108: |
| 693 |
return jjMoveStringLiteralDfa4_0(active0, 0x200000000040000ULL, active1, 0L); |
| 694 |
case 109: |
| 695 |
return jjMoveStringLiteralDfa4_0(active0, 0x1800000000000000ULL, active1, 0L); |
| 696 |
case 110: |
| 697 |
return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000000ULL, active1, 0L); |
| 698 |
case 111: |
| 699 |
return jjMoveStringLiteralDfa4_0(active0, 0x10c00ULL, active1, 0x36000ULL); |
| 700 |
case 112: |
| 701 |
return jjMoveStringLiteralDfa4_0(active0, 0x200000ULL, active1, 0L); |
| 702 |
case 115: |
| 703 |
return jjMoveStringLiteralDfa4_0(active0, 0x1000ULL, active1, 0x100ULL); |
| 704 |
default : |
| 705 |
break; |
| 706 |
} |
| 707 |
return jjStartNfa_0(2, active0, active1); |
| 708 |
} |
| 709 |
|
| 710 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa4_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 711 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 712 |
return jjStartNfa_0(2, old0, old1); |
| 713 |
if (input_stream->endOfInput()) { |
| 714 |
jjStopStringLiteralDfa_0(3, active0, active1); |
| 715 |
return 4; |
| 716 |
} |
| 717 |
curChar = input_stream->readChar(); |
| 718 |
switch(curChar) |
| 719 |
{ |
| 720 |
case 65: |
| 721 |
return jjMoveStringLiteralDfa5_0(active0, 0x10000000000ULL, active1, 0L); |
| 722 |
case 67: |
| 723 |
return jjMoveStringLiteralDfa5_0(active0, 0x2000000000ULL, active1, 0L); |
| 724 |
case 69: |
| 725 |
return jjMoveStringLiteralDfa5_0(active0, 0x100000000000ULL, active1, 0L); |
| 726 |
case 72: |
| 727 |
return jjMoveStringLiteralDfa5_0(active0, 0x20000000000ULL, active1, 0L); |
| 728 |
case 73: |
| 729 |
return jjMoveStringLiteralDfa5_0(active0, 0x800000000ULL, active1, 0x40ULL); |
| 730 |
case 77: |
| 731 |
return jjMoveStringLiteralDfa5_0(active0, 0xc0000000000ULL, active1, 0L); |
| 732 |
case 79: |
| 733 |
return jjMoveStringLiteralDfa5_0(active0, 0x4000000000ULL, active1, 0L); |
| 734 |
case 80: |
| 735 |
return jjMoveStringLiteralDfa5_0(active0, 0x8000ULL, active1, 0x806ULL); |
| 736 |
case 83: |
| 737 |
return jjMoveStringLiteralDfa5_0(active0, 0x8000000000ULL, active1, 0L); |
| 738 |
case 85: |
| 739 |
return jjMoveStringLiteralDfa5_0(active0, 0x1000000000ULL, active1, 0L); |
| 740 |
case 97: |
| 741 |
return jjMoveStringLiteralDfa5_0(active0, 0x4000000000040000ULL, active1, 0L); |
| 742 |
case 98: |
| 743 |
return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000ULL, active1, 0L); |
| 744 |
case 99: |
| 745 |
return jjMoveStringLiteralDfa5_0(active0, 0x300007ff184000ULL, active1, 0x200ULL); |
| 746 |
case 100: |
| 747 |
return jjMoveStringLiteralDfa5_0(active0, 0x20000ULL, active1, 0L); |
| 748 |
case 101: |
| 749 |
return jjMoveStringLiteralDfa5_0(active0, 0xa00000000000000ULL, active1, 0xa0ULL); |
| 750 |
case 102: |
| 751 |
if ((active0 & 0x400000ULL) != 0L) |
| 752 |
return jjStartNfaWithStates_0(4, 22, 9); |
| 753 |
return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000ULL, active1, 0L); |
| 754 |
case 105: |
| 755 |
return jjMoveStringLiteralDfa5_0(active0, 0x200ULL, active1, 0L); |
| 756 |
case 108: |
| 757 |
return jjMoveStringLiteralDfa5_0(active0, 0x200000200400ULL, active1, 0L); |
| 758 |
case 109: |
| 759 |
return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000ULL, active1, 0L); |
| 760 |
case 110: |
| 761 |
return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x8000ULL); |
| 762 |
case 111: |
| 763 |
return jjMoveStringLiteralDfa5_0(active0, 0x9800000000000ULL, active1, 0x1ULL); |
| 764 |
case 114: |
| 765 |
return jjMoveStringLiteralDfa5_0(active0, 0x140000000000800ULL, active1, 0L); |
| 766 |
case 115: |
| 767 |
if ((active0 & 0x1000ULL) != 0L) |
| 768 |
{ |
| 769 |
jjmatchedKind = 12; |
| 770 |
jjmatchedPos = 4; |
| 771 |
} |
| 772 |
return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000ULL, active1, 0x100ULL); |
| 773 |
case 116: |
| 774 |
return jjMoveStringLiteralDfa5_0(active0, 0x80000000812000ULL, active1, 0x37418ULL); |
| 775 |
case 118: |
| 776 |
return jjMoveStringLiteralDfa5_0(active0, 0x8004400000000000ULL, active1, 0L); |
| 777 |
default : |
| 778 |
break; |
| 779 |
} |
| 780 |
return jjStartNfa_0(3, active0, active1); |
| 781 |
} |
| 782 |
|
| 783 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa5_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 784 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 785 |
return jjStartNfa_0(3, old0, old1); |
| 786 |
if (input_stream->endOfInput()) { |
| 787 |
jjStopStringLiteralDfa_0(4, active0, active1); |
| 788 |
return 5; |
| 789 |
} |
| 790 |
curChar = input_stream->readChar(); |
| 791 |
switch(curChar) |
| 792 |
{ |
| 793 |
case 65: |
| 794 |
return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x100ULL); |
| 795 |
case 73: |
| 796 |
return jjMoveStringLiteralDfa6_0(active0, 0x20000ULL, active1, 0L); |
| 797 |
case 97: |
| 798 |
return jjMoveStringLiteralDfa6_0(active0, 0x80046a0000010000ULL, active1, 0x36000ULL); |
| 799 |
case 101: |
| 800 |
return jjMoveStringLiteralDfa6_0(active0, 0x1000000000200000ULL, active1, 0L); |
| 801 |
case 105: |
| 802 |
return jjMoveStringLiteralDfa6_0(active0, 0x2089840000000000ULL, active1, 0x1409ULL); |
| 803 |
case 106: |
| 804 |
return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000ULL, active1, 0L); |
| 805 |
case 108: |
| 806 |
return jjMoveStringLiteralDfa6_0(active0, 0x400010000000000ULL, active1, 0L); |
| 807 |
case 110: |
| 808 |
return jjMoveStringLiteralDfa6_0(active0, 0x5800000000ULL, active1, 0x8040ULL); |
| 809 |
case 111: |
| 810 |
return jjMoveStringLiteralDfa6_0(active0, 0xa000000400ULL, active1, 0L); |
| 811 |
case 114: |
| 812 |
return jjMoveStringLiteralDfa6_0(active0, 0x48000ULL, active1, 0x886ULL); |
| 813 |
case 115: |
| 814 |
return jjMoveStringLiteralDfa6_0(active0, 0x140000000000000ULL, active1, 0L); |
| 815 |
case 116: |
| 816 |
if ((active0 & 0x800ULL) != 0L) |
| 817 |
return jjStartNfaWithStates_0(5, 11, 9); |
| 818 |
return jjMoveStringLiteralDfa6_0(active0, 0x48300007ff184000ULL, active1, 0x200ULL); |
| 819 |
case 120: |
| 820 |
if ((active0 & 0x200ULL) != 0L) |
| 821 |
return jjStartNfaWithStates_0(5, 9, 9); |
| 822 |
return jjMoveStringLiteralDfa6_0(active0, 0x200100000000000ULL, active1, 0L); |
| 823 |
case 121: |
| 824 |
if ((active1 & 0x20ULL) != 0L) |
| 825 |
return jjStartNfaWithStates_0(5, 69, 9); |
| 826 |
return jjMoveStringLiteralDfa6_0(active0, 0x802000ULL, active1, 0x10ULL); |
| 827 |
default : |
| 828 |
break; |
| 829 |
} |
| 830 |
return jjStartNfa_0(4, active0, active1); |
| 831 |
} |
| 832 |
|
| 833 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa6_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 834 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 835 |
return jjStartNfa_0(4, old0, old1); |
| 836 |
if (input_stream->endOfInput()) { |
| 837 |
jjStopStringLiteralDfa_0(5, active0, active1); |
| 838 |
return 6; |
| 839 |
} |
| 840 |
curChar = input_stream->readChar(); |
| 841 |
switch(curChar) |
| 842 |
{ |
| 843 |
case 65: |
| 844 |
return jjMoveStringLiteralDfa7_0(active0, 0x20000000ULL, active1, 0L); |
| 845 |
case 67: |
| 846 |
return jjMoveStringLiteralDfa7_0(active0, 0x4000000ULL, active1, 0L); |
| 847 |
case 69: |
| 848 |
return jjMoveStringLiteralDfa7_0(active0, 0x400000000ULL, active1, 0L); |
| 849 |
case 72: |
| 850 |
return jjMoveStringLiteralDfa7_0(active0, 0xc0000000ULL, active1, 0L); |
| 851 |
case 73: |
| 852 |
return jjMoveStringLiteralDfa7_0(active0, 0x1080000ULL, active1, 0L); |
| 853 |
case 77: |
| 854 |
return jjMoveStringLiteralDfa7_0(active0, 0x300000000ULL, active1, 0L); |
| 855 |
case 79: |
| 856 |
return jjMoveStringLiteralDfa7_0(active0, 0x8000000ULL, active1, 0L); |
| 857 |
case 80: |
| 858 |
return jjMoveStringLiteralDfa7_0(active0, 0x30000000104000ULL, active1, 0x200ULL); |
| 859 |
case 83: |
| 860 |
return jjMoveStringLiteralDfa7_0(active0, 0x10000000ULL, active1, 0L); |
| 861 |
case 85: |
| 862 |
return jjMoveStringLiteralDfa7_0(active0, 0x2000000ULL, active1, 0L); |
| 863 |
case 97: |
| 864 |
return jjMoveStringLiteralDfa7_0(active0, 0x4000100000040000ULL, active1, 0L); |
| 865 |
case 100: |
| 866 |
return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x40ULL); |
| 867 |
case 101: |
| 868 |
return jjMoveStringLiteralDfa7_0(active0, 0x542004000000000ULL, active1, 0x80ULL); |
| 869 |
case 103: |
| 870 |
return jjMoveStringLiteralDfa7_0(active0, 0x400ULL, active1, 0L); |
| 871 |
case 105: |
| 872 |
return jjMoveStringLiteralDfa7_0(active0, 0x200001000000000ULL, active1, 0L); |
| 873 |
case 108: |
| 874 |
return jjMoveStringLiteralDfa7_0(active0, 0x8004410000000000ULL, active1, 0L); |
| 875 |
case 109: |
| 876 |
return jjMoveStringLiteralDfa7_0(active0, 0xa000200000ULL, active1, 0L); |
| 877 |
case 110: |
| 878 |
return jjMoveStringLiteralDfa7_0(active0, 0x9840000020000ULL, active1, 0x1ULL); |
| 879 |
case 111: |
| 880 |
return jjMoveStringLiteralDfa7_0(active0, 0x80000000008000ULL, active1, 0x880eULL); |
| 881 |
case 112: |
| 882 |
return jjMoveStringLiteralDfa7_0(active0, 0x802000ULL, active1, 0x10ULL); |
| 883 |
case 114: |
| 884 |
return jjMoveStringLiteralDfa7_0(active0, 0x800000000000000ULL, active1, 0L); |
| 885 |
case 115: |
| 886 |
return jjMoveStringLiteralDfa7_0(active0, 0x220000000000ULL, active1, 0x100ULL); |
| 887 |
case 116: |
| 888 |
return jjMoveStringLiteralDfa7_0(active0, 0x3000000800010000ULL, active1, 0x36000ULL); |
| 889 |
case 118: |
| 890 |
return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1400ULL); |
| 891 |
case 120: |
| 892 |
return jjMoveStringLiteralDfa7_0(active0, 0x80000000000ULL, active1, 0L); |
| 893 |
default : |
| 894 |
break; |
| 895 |
} |
| 896 |
return jjStartNfa_0(5, active0, active1); |
| 897 |
} |
| 898 |
|
| 899 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa7_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 900 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 901 |
return jjStartNfa_0(5, old0, old1); |
| 902 |
if (input_stream->endOfInput()) { |
| 903 |
jjStopStringLiteralDfa_0(6, active0, active1); |
| 904 |
return 7; |
| 905 |
} |
| 906 |
curChar = input_stream->readChar(); |
| 907 |
switch(curChar) |
| 908 |
{ |
| 909 |
case 67: |
| 910 |
return jjMoveStringLiteralDfa8_0(active0, 0xc0000000000ULL, active1, 0L); |
| 911 |
case 70: |
| 912 |
return jjMoveStringLiteralDfa8_0(active0, 0x100000000000000ULL, active1, 0L); |
| 913 |
case 79: |
| 914 |
return jjMoveStringLiteralDfa8_0(active0, 0x40004000000000ULL, active1, 0L); |
| 915 |
case 80: |
| 916 |
return jjMoveStringLiteralDfa8_0(active0, 0x4000000000000000ULL, active1, 0L); |
| 917 |
case 86: |
| 918 |
return jjMoveStringLiteralDfa8_0(active0, 0x30000000000ULL, active1, 0L); |
| 919 |
case 97: |
| 920 |
return jjMoveStringLiteralDfa8_0(active0, 0x2c0000000ULL, active1, 0L); |
| 921 |
case 99: |
| 922 |
return jjMoveStringLiteralDfa8_0(active0, 0x2100000000000ULL, active1, 0L); |
| 923 |
case 100: |
| 924 |
return jjMoveStringLiteralDfa8_0(active0, 0x20000ULL, active1, 0L); |
| 925 |
case 101: |
| 926 |
if ((active0 & 0x2000ULL) != 0L) |
| 927 |
{ |
| 928 |
jjmatchedKind = 13; |
| 929 |
jjmatchedPos = 7; |
| 930 |
} |
| 931 |
return jjMoveStringLiteralDfa8_0(active0, 0x8004408800a00000ULL, active1, 0x1410ULL); |
| 932 |
case 105: |
| 933 |
return jjMoveStringLiteralDfa8_0(active0, 0x2800000100010000ULL, active1, 0x36040ULL); |
| 934 |
case 108: |
| 935 |
return jjMoveStringLiteralDfa8_0(active0, 0x20000000ULL, active1, 0L); |
| 936 |
case 110: |
| 937 |
return jjMoveStringLiteralDfa8_0(active0, 0x8000000b080000ULL, active1, 0x88ULL); |
| 938 |
case 111: |
| 939 |
return jjMoveStringLiteralDfa8_0(active0, 0x1014000000ULL, active1, 0L); |
| 940 |
case 112: |
| 941 |
return jjMoveStringLiteralDfa8_0(active0, 0x2000008000ULL, active1, 0x806ULL); |
| 942 |
case 114: |
| 943 |
return jjMoveStringLiteralDfa8_0(active0, 0x1030000000104000ULL, active1, 0x200ULL); |
| 944 |
case 115: |
| 945 |
return jjMoveStringLiteralDfa8_0(active0, 0x200000000000ULL, active1, 0x100ULL); |
| 946 |
case 116: |
| 947 |
return jjMoveStringLiteralDfa8_0(active0, 0x9800000040000ULL, active1, 0x8001ULL); |
| 948 |
case 118: |
| 949 |
return jjMoveStringLiteralDfa8_0(active0, 0x200000000000000ULL, active1, 0L); |
| 950 |
case 120: |
| 951 |
return jjMoveStringLiteralDfa8_0(active0, 0x400000400000000ULL, active1, 0L); |
| 952 |
case 121: |
| 953 |
if ((active0 & 0x400ULL) != 0L) |
| 954 |
return jjStartNfaWithStates_0(7, 10, 9); |
| 955 |
break; |
| 956 |
default : |
| 957 |
break; |
| 958 |
} |
| 959 |
return jjStartNfa_0(6, active0, active1); |
| 960 |
} |
| 961 |
|
| 962 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa8_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 963 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 964 |
return jjStartNfa_0(6, old0, old1); |
| 965 |
if (input_stream->endOfInput()) { |
| 966 |
jjStopStringLiteralDfa_0(7, active0, active1); |
| 967 |
return 8; |
| 968 |
} |
| 969 |
curChar = input_stream->readChar(); |
| 970 |
switch(curChar) |
| 971 |
{ |
| 972 |
case 67: |
| 973 |
return jjMoveStringLiteralDfa9_0(active0, 0x800000000000ULL, active1, 0L); |
| 974 |
case 68: |
| 975 |
return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1011ULL); |
| 976 |
case 79: |
| 977 |
return jjMoveStringLiteralDfa9_0(active0, 0x8200000000000ULL, active1, 0x400ULL); |
| 978 |
case 82: |
| 979 |
return jjMoveStringLiteralDfa9_0(active0, 0x800000ULL, active1, 0L); |
| 980 |
case 85: |
| 981 |
return jjMoveStringLiteralDfa9_0(active0, 0x1000000000000ULL, active1, 0L); |
| 982 |
case 86: |
| 983 |
return jjMoveStringLiteralDfa9_0(active0, 0x8000000000ULL, active1, 0L); |
| 984 |
case 97: |
| 985 |
return jjMoveStringLiteralDfa9_0(active0, 0x800f0400000000ULL, active1, 0x8008ULL); |
| 986 |
case 98: |
| 987 |
return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000ULL, active1, 0L); |
| 988 |
case 99: |
| 989 |
return jjMoveStringLiteralDfa9_0(active0, 0x800000000000000ULL, active1, 0L); |
| 990 |
case 101: |
| 991 |
return jjMoveStringLiteralDfa9_0(active0, 0x200000008008000ULL, active1, 0x906ULL); |
| 992 |
case 102: |
| 993 |
if ((active0 & 0x4000000000ULL) != 0L) |
| 994 |
return jjStartNfaWithStates_0(8, 38, 9); |
| 995 |
break; |
| 996 |
case 105: |
| 997 |
return jjMoveStringLiteralDfa9_0(active0, 0x1400000002060000ULL, active1, 0L); |
| 998 |
case 108: |
| 999 |
return jjMoveStringLiteralDfa9_0(active0, 0x2020000000ULL, active1, 0L); |
| 1000 |
case 109: |
| 1001 |
return jjMoveStringLiteralDfa9_0(active0, 0x14000000ULL, active1, 0L); |
| 1002 |
case 110: |
| 1003 |
return jjMoveStringLiteralDfa9_0(active0, 0x8004401100200000ULL, active1, 0L); |
| 1004 |
case 111: |
| 1005 |
return jjMoveStringLiteralDfa9_0(active0, 0x30000000114000ULL, active1, 0x36200ULL); |
| 1006 |
case 114: |
| 1007 |
return jjMoveStringLiteralDfa9_0(active0, 0x4000000800000000ULL, active1, 0L); |
| 1008 |
case 115: |
| 1009 |
return jjMoveStringLiteralDfa9_0(active0, 0xc0000000ULL, active1, 0L); |
| 1010 |
case 116: |
| 1011 |
return jjMoveStringLiteralDfa9_0(active0, 0x2100001000000ULL, active1, 0x80ULL); |
| 1012 |
case 117: |
| 1013 |
return jjMoveStringLiteralDfa9_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1014 |
case 118: |
| 1015 |
return jjMoveStringLiteralDfa9_0(active0, 0x2000000000080000ULL, active1, 0x40ULL); |
| 1016 |
case 120: |
| 1017 |
return jjMoveStringLiteralDfa9_0(active0, 0x200000000ULL, active1, 0L); |
| 1018 |
default : |
| 1019 |
break; |
| 1020 |
} |
| 1021 |
return jjStartNfa_0(7, active0, active1); |
| 1022 |
} |
| 1023 |
|
| 1024 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa9_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1025 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1026 |
return jjStartNfa_0(7, old0, old1); |
| 1027 |
if (input_stream->endOfInput()) { |
| 1028 |
jjStopStringLiteralDfa_0(8, active0, active1); |
| 1029 |
return 9; |
| 1030 |
} |
| 1031 |
curChar = input_stream->readChar(); |
| 1032 |
switch(curChar) |
| 1033 |
{ |
| 1034 |
case 67: |
| 1035 |
return jjMoveStringLiteralDfa10_0(active0, 0x100300000000ULL, active1, 0L); |
| 1036 |
case 73: |
| 1037 |
return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x80ULL); |
| 1038 |
case 79: |
| 1039 |
return jjMoveStringLiteralDfa10_0(active0, 0xa00001008000000ULL, active1, 0L); |
| 1040 |
case 80: |
| 1041 |
return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000ULL, active1, 0L); |
| 1042 |
case 83: |
| 1043 |
return jjMoveStringLiteralDfa10_0(active0, 0x80000000ULL, active1, 0L); |
| 1044 |
case 86: |
| 1045 |
return jjMoveStringLiteralDfa10_0(active0, 0x60000000ULL, active1, 0L); |
| 1046 |
case 97: |
| 1047 |
return jjMoveStringLiteralDfa10_0(active0, 0x8000000000ULL, active1, 0x1001ULL); |
| 1048 |
case 98: |
| 1049 |
return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000ULL, active1, 0x400ULL); |
| 1050 |
case 99: |
| 1051 |
return jjMoveStringLiteralDfa10_0(active0, 0x1000000400000000ULL, active1, 0L); |
| 1052 |
case 101: |
| 1053 |
return jjMoveStringLiteralDfa10_0(active0, 0x2000002011880000ULL, active1, 0x10ULL); |
| 1054 |
case 102: |
| 1055 |
if ((active0 & 0x200000000000ULL) != 0L) |
| 1056 |
return jjStartNfaWithStates_0(9, 45, 9); |
| 1057 |
break; |
| 1058 |
case 105: |
| 1059 |
return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x40ULL); |
| 1060 |
case 106: |
| 1061 |
return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000ULL, active1, 0L); |
| 1062 |
case 108: |
| 1063 |
return jjMoveStringLiteralDfa10_0(active0, 0x80830000000000ULL, active1, 0x8ULL); |
| 1064 |
case 110: |
| 1065 |
if ((active1 & 0x2000ULL) != 0L) |
| 1066 |
{ |
| 1067 |
jjmatchedKind = 77; |
| 1068 |
jjmatchedPos = 9; |
| 1069 |
} |
| 1070 |
return jjMoveStringLiteralDfa10_0(active0, 0x101000000010000ULL, active1, 0x34000ULL); |
| 1071 |
case 111: |
| 1072 |
return jjMoveStringLiteralDfa10_0(active0, 0x4000000002040000ULL, active1, 0L); |
| 1073 |
case 112: |
| 1074 |
return jjMoveStringLiteralDfa10_0(active0, 0x30000004104000ULL, active1, 0x200ULL); |
| 1075 |
case 114: |
| 1076 |
return jjMoveStringLiteralDfa10_0(active0, 0xc0000008000ULL, active1, 0x906ULL); |
| 1077 |
case 115: |
| 1078 |
return jjMoveStringLiteralDfa10_0(active0, 0x800000000ULL, active1, 0L); |
| 1079 |
case 116: |
| 1080 |
return jjMoveStringLiteralDfa10_0(active0, 0x8004400000200000ULL, active1, 0x8000ULL); |
| 1081 |
case 118: |
| 1082 |
return jjMoveStringLiteralDfa10_0(active0, 0x400000000020000ULL, active1, 0L); |
| 1083 |
default : |
| 1084 |
break; |
| 1085 |
} |
| 1086 |
return jjStartNfa_0(8, active0, active1); |
| 1087 |
} |
| 1088 |
|
| 1089 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa10_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1090 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1091 |
return jjStartNfa_0(8, old0, old1); |
| 1092 |
if (input_stream->endOfInput()) { |
| 1093 |
jjStopStringLiteralDfa_0(9, active0, active1); |
| 1094 |
return 10; |
| 1095 |
} |
| 1096 |
curChar = input_stream->readChar(); |
| 1097 |
switch(curChar) |
| 1098 |
{ |
| 1099 |
case 65: |
| 1100 |
return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x4000ULL); |
| 1101 |
case 67: |
| 1102 |
return jjMoveStringLiteralDfa11_0(active0, 0x400000000000ULL, active1, 0L); |
| 1103 |
case 68: |
| 1104 |
return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000000ULL, active1, 0x8ULL); |
| 1105 |
case 79: |
| 1106 |
return jjMoveStringLiteralDfa11_0(active0, 0x3084000000200000ULL, active1, 0L); |
| 1107 |
case 80: |
| 1108 |
return jjMoveStringLiteralDfa11_0(active0, 0x10000ULL, active1, 0x30000ULL); |
| 1109 |
case 86: |
| 1110 |
return jjMoveStringLiteralDfa11_0(active0, 0x10000000ULL, active1, 0L); |
| 1111 |
case 97: |
| 1112 |
return jjMoveStringLiteralDfa11_0(active0, 0x900360000000ULL, active1, 0L); |
| 1113 |
case 98: |
| 1114 |
return jjMoveStringLiteralDfa11_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1115 |
case 99: |
| 1116 |
return jjMoveStringLiteralDfa11_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1117 |
case 100: |
| 1118 |
return jjMoveStringLiteralDfa11_0(active0, 0xc0000000000ULL, active1, 0x40ULL); |
| 1119 |
case 101: |
| 1120 |
return jjMoveStringLiteralDfa11_0(active0, 0x470000880104000ULL, active1, 0x200ULL); |
| 1121 |
case 102: |
| 1122 |
if ((active0 & 0x8000000ULL) != 0L) |
| 1123 |
return jjStartNfaWithStates_0(10, 27, 9); |
| 1124 |
else if ((active0 & 0x1000000000ULL) != 0L) |
| 1125 |
return jjStartNfaWithStates_0(10, 36, 9); |
| 1126 |
return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x10ULL); |
| 1127 |
case 105: |
| 1128 |
return jjMoveStringLiteralDfa11_0(active0, 0x1000000020000ULL, active1, 0x8000ULL); |
| 1129 |
case 106: |
| 1130 |
return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000ULL, active1, 0x400ULL); |
| 1131 |
case 108: |
| 1132 |
return jjMoveStringLiteralDfa11_0(active0, 0x8004000000ULL, active1, 0L); |
| 1133 |
case 109: |
| 1134 |
return jjMoveStringLiteralDfa11_0(active0, 0x2000000000ULL, active1, 0L); |
| 1135 |
case 110: |
| 1136 |
if ((active0 & 0x40000ULL) != 0L) |
| 1137 |
return jjStartNfaWithStates_0(10, 18, 9); |
| 1138 |
return jjMoveStringLiteralDfa11_0(active0, 0x2000000ULL, active1, 0x80ULL); |
| 1139 |
case 112: |
| 1140 |
return jjMoveStringLiteralDfa11_0(active0, 0x4000000000000000ULL, active1, 0L); |
| 1141 |
case 114: |
| 1142 |
return jjMoveStringLiteralDfa11_0(active0, 0x2000001080000ULL, active1, 0L); |
| 1143 |
case 115: |
| 1144 |
return jjMoveStringLiteralDfa11_0(active0, 0x800000ULL, active1, 0L); |
| 1145 |
case 116: |
| 1146 |
return jjMoveStringLiteralDfa11_0(active0, 0x400008000ULL, active1, 0x1907ULL); |
| 1147 |
case 117: |
| 1148 |
return jjMoveStringLiteralDfa11_0(active0, 0x30000000000ULL, active1, 0L); |
| 1149 |
default : |
| 1150 |
break; |
| 1151 |
} |
| 1152 |
return jjStartNfa_0(9, active0, active1); |
| 1153 |
} |
| 1154 |
|
| 1155 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa11_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1156 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1157 |
return jjStartNfa_0(9, old0, old1); |
| 1158 |
if (input_stream->endOfInput()) { |
| 1159 |
jjStopStringLiteralDfa_0(10, active0, active1); |
| 1160 |
return 11; |
| 1161 |
} |
| 1162 |
curChar = input_stream->readChar(); |
| 1163 |
switch(curChar) |
| 1164 |
{ |
| 1165 |
case 67: |
| 1166 |
return jjMoveStringLiteralDfa12_0(active0, 0x400000000ULL, active1, 0L); |
| 1167 |
case 79: |
| 1168 |
return jjMoveStringLiteralDfa12_0(active0, 0x400000002000000ULL, active1, 0L); |
| 1169 |
case 97: |
| 1170 |
return jjMoveStringLiteralDfa12_0(active0, 0x8000000010000000ULL, active1, 0x1009ULL); |
| 1171 |
case 98: |
| 1172 |
return jjMoveStringLiteralDfa12_0(active0, 0x3084000000000000ULL, active1, 0L); |
| 1173 |
case 99: |
| 1174 |
return jjMoveStringLiteralDfa12_0(active0, 0x40000800000000ULL, active1, 0L); |
| 1175 |
case 100: |
| 1176 |
return jjMoveStringLiteralDfa12_0(active0, 0x20000ULL, active1, 0x80ULL); |
| 1177 |
case 101: |
| 1178 |
if ((active0 & 0x20000000000ULL) != 0L) |
| 1179 |
return jjStartNfaWithStates_0(11, 41, 9); |
| 1180 |
return jjMoveStringLiteralDfa12_0(active0, 0x4008012004000000ULL, active1, 0x400ULL); |
| 1181 |
case 102: |
| 1182 |
if ((active0 & 0x200000ULL) != 0L) |
| 1183 |
return jjStartNfaWithStates_0(11, 21, 9); |
| 1184 |
break; |
| 1185 |
case 105: |
| 1186 |
return jjMoveStringLiteralDfa12_0(active0, 0xc0000000000ULL, active1, 0x110ULL); |
| 1187 |
case 106: |
| 1188 |
return jjMoveStringLiteralDfa12_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1189 |
case 108: |
| 1190 |
return jjMoveStringLiteralDfa12_0(active0, 0x4000e0000000ULL, active1, 0L); |
| 1191 |
case 111: |
| 1192 |
return jjMoveStringLiteralDfa12_0(active0, 0x3000000000000ULL, active1, 0x8000ULL); |
| 1193 |
case 114: |
| 1194 |
return jjMoveStringLiteralDfa12_0(active0, 0x30100300114000ULL, active1, 0x30200ULL); |
| 1195 |
case 115: |
| 1196 |
return jjMoveStringLiteralDfa12_0(active0, 0x800001080000ULL, active1, 0x4000ULL); |
| 1197 |
case 116: |
| 1198 |
return jjMoveStringLiteralDfa12_0(active0, 0x100000000800000ULL, active1, 0L); |
| 1199 |
case 117: |
| 1200 |
return jjMoveStringLiteralDfa12_0(active0, 0x8000000000ULL, active1, 0x40ULL); |
| 1201 |
case 121: |
| 1202 |
if ((active0 & 0x8000ULL) != 0L) |
| 1203 |
{ |
| 1204 |
jjmatchedKind = 15; |
| 1205 |
jjmatchedPos = 11; |
| 1206 |
} |
| 1207 |
return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x806ULL); |
| 1208 |
default : |
| 1209 |
break; |
| 1210 |
} |
| 1211 |
return jjStartNfa_0(10, active0, active1); |
| 1212 |
} |
| 1213 |
|
| 1214 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa12_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1215 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1216 |
return jjStartNfa_0(10, old0, old1); |
| 1217 |
if (input_stream->endOfInput()) { |
| 1218 |
jjStopStringLiteralDfa_0(11, active0, active1); |
| 1219 |
return 12; |
| 1220 |
} |
| 1221 |
curChar = input_stream->readChar(); |
| 1222 |
switch(curChar) |
| 1223 |
{ |
| 1224 |
case 65: |
| 1225 |
return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x800ULL); |
| 1226 |
case 68: |
| 1227 |
return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x2ULL); |
| 1228 |
case 80: |
| 1229 |
return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x1001ULL); |
| 1230 |
case 82: |
| 1231 |
return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x4ULL); |
| 1232 |
case 97: |
| 1233 |
return jjMoveStringLiteralDfa13_0(active0, 0x400400000000ULL, active1, 0x40ULL); |
| 1234 |
case 98: |
| 1235 |
return jjMoveStringLiteralDfa13_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1236 |
case 99: |
| 1237 |
return jjMoveStringLiteralDfa13_0(active0, 0x8000000000000ULL, active1, 0x400ULL); |
| 1238 |
case 100: |
| 1239 |
return jjMoveStringLiteralDfa13_0(active0, 0x100300000000ULL, active1, 0L); |
| 1240 |
case 101: |
| 1241 |
return jjMoveStringLiteralDfa13_0(active0, 0xa00008001080000ULL, active1, 0L); |
| 1242 |
case 102: |
| 1243 |
if ((active0 & 0x2000000ULL) != 0L) |
| 1244 |
return jjStartNfaWithStates_0(12, 25, 9); |
| 1245 |
else if ((active0 & 0x80000000ULL) != 0L) |
| 1246 |
return jjStartNfaWithStates_0(12, 31, 9); |
| 1247 |
break; |
| 1248 |
case 105: |
| 1249 |
return jjMoveStringLiteralDfa13_0(active0, 0x100000000000000ULL, active1, 0x80ULL); |
| 1250 |
case 106: |
| 1251 |
return jjMoveStringLiteralDfa13_0(active0, 0x3084000000000000ULL, active1, 0L); |
| 1252 |
case 108: |
| 1253 |
return jjMoveStringLiteralDfa13_0(active0, 0x10000000ULL, active1, 0L); |
| 1254 |
case 109: |
| 1255 |
return jjMoveStringLiteralDfa13_0(active0, 0x4000000ULL, active1, 0L); |
| 1256 |
case 110: |
| 1257 |
if ((active0 & 0x1000000000000ULL) != 0L) |
| 1258 |
return jjStartNfaWithStates_0(12, 48, 9); |
| 1259 |
return jjMoveStringLiteralDfa13_0(active0, 0xc2000000000ULL, active1, 0x8010ULL); |
| 1260 |
case 111: |
| 1261 |
return jjMoveStringLiteralDfa13_0(active0, 0x10000ULL, active1, 0x30100ULL); |
| 1262 |
case 112: |
| 1263 |
return jjMoveStringLiteralDfa13_0(active0, 0x2000000000000ULL, active1, 0L); |
| 1264 |
case 114: |
| 1265 |
return jjMoveStringLiteralDfa13_0(active0, 0x4000000000800000ULL, active1, 0L); |
| 1266 |
case 115: |
| 1267 |
return jjMoveStringLiteralDfa13_0(active0, 0x810000000000ULL, active1, 0x4000ULL); |
| 1268 |
case 116: |
| 1269 |
return jjMoveStringLiteralDfa13_0(active0, 0x8070000800104000ULL, active1, 0x208ULL); |
| 1270 |
case 117: |
| 1271 |
return jjMoveStringLiteralDfa13_0(active0, 0x60020000ULL, active1, 0L); |
| 1272 |
default : |
| 1273 |
break; |
| 1274 |
} |
| 1275 |
return jjStartNfa_0(11, active0, active1); |
| 1276 |
} |
| 1277 |
|
| 1278 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa13_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1279 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1280 |
return jjStartNfa_0(11, old0, old1); |
| 1281 |
if (input_stream->endOfInput()) { |
| 1282 |
jjStopStringLiteralDfa_0(12, active0, active1); |
| 1283 |
return 13; |
| 1284 |
} |
| 1285 |
curChar = input_stream->readChar(); |
| 1286 |
switch(curChar) |
| 1287 |
{ |
| 1288 |
case 70: |
| 1289 |
return jjMoveStringLiteralDfa14_0(active0, 0x10000000000ULL, active1, 0L); |
| 1290 |
case 79: |
| 1291 |
return jjMoveStringLiteralDfa14_0(active0, 0x80000ULL, active1, 0L); |
| 1292 |
case 80: |
| 1293 |
return jjMoveStringLiteralDfa14_0(active0, 0x40000000000000ULL, active1, 0x8000ULL); |
| 1294 |
case 97: |
| 1295 |
return jjMoveStringLiteralDfa14_0(active0, 0x80000c0000020000ULL, active1, 0xcULL); |
| 1296 |
case 99: |
| 1297 |
return jjMoveStringLiteralDfa14_0(active0, 0xa00000001000000ULL, active1, 0L); |
| 1298 |
case 101: |
| 1299 |
if ((active0 & 0x40000000ULL) != 0L) |
| 1300 |
return jjStartNfaWithStates_0(13, 30, 9); |
| 1301 |
return jjMoveStringLiteralDfa14_0(active0, 0x3086800024000000ULL, active1, 0x4000ULL); |
| 1302 |
case 105: |
| 1303 |
return jjMoveStringLiteralDfa14_0(active0, 0x100b00800000ULL, active1, 0x10ULL); |
| 1304 |
case 106: |
| 1305 |
return jjMoveStringLiteralDfa14_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1306 |
case 108: |
| 1307 |
if ((active1 & 0x40ULL) != 0L) |
| 1308 |
return jjStartNfaWithStates_0(13, 70, 9); |
| 1309 |
break; |
| 1310 |
case 110: |
| 1311 |
if ((active1 & 0x100ULL) != 0L) |
| 1312 |
return jjStartNfaWithStates_0(13, 72, 9); |
| 1313 |
break; |
| 1314 |
case 111: |
| 1315 |
return jjMoveStringLiteralDfa14_0(active0, 0x100000000000000ULL, active1, 0x2ULL); |
| 1316 |
case 112: |
| 1317 |
return jjMoveStringLiteralDfa14_0(active0, 0x10000ULL, active1, 0x30000ULL); |
| 1318 |
case 114: |
| 1319 |
return jjMoveStringLiteralDfa14_0(active0, 0x400000000ULL, active1, 0x1001ULL); |
| 1320 |
case 115: |
| 1321 |
return jjMoveStringLiteralDfa14_0(active0, 0x408000000000ULL, active1, 0x800ULL); |
| 1322 |
case 116: |
| 1323 |
return jjMoveStringLiteralDfa14_0(active0, 0x4008002000000000ULL, active1, 0x400ULL); |
| 1324 |
case 117: |
| 1325 |
return jjMoveStringLiteralDfa14_0(active0, 0x10000000ULL, active1, 0L); |
| 1326 |
case 118: |
| 1327 |
return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x80ULL); |
| 1328 |
case 121: |
| 1329 |
if ((active0 & 0x4000ULL) != 0L) |
| 1330 |
{ |
| 1331 |
jjmatchedKind = 14; |
| 1332 |
jjmatchedPos = 13; |
| 1333 |
} |
| 1334 |
return jjMoveStringLiteralDfa14_0(active0, 0x30000000100000ULL, active1, 0x200ULL); |
| 1335 |
default : |
| 1336 |
break; |
| 1337 |
} |
| 1338 |
return jjStartNfa_0(12, active0, active1); |
| 1339 |
} |
| 1340 |
|
| 1341 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa14_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1342 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1343 |
return jjStartNfa_0(12, old0, old1); |
| 1344 |
if (input_stream->endOfInput()) { |
| 1345 |
jjStopStringLiteralDfa_0(13, active0, active1); |
| 1346 |
return 14; |
| 1347 |
} |
| 1348 |
curChar = input_stream->readChar(); |
| 1349 |
switch(curChar) |
| 1350 |
{ |
| 1351 |
case 65: |
| 1352 |
return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x200ULL); |
| 1353 |
case 67: |
| 1354 |
return jjMoveStringLiteralDfa15_0(active0, 0x100000ULL, active1, 0L); |
| 1355 |
case 68: |
| 1356 |
return jjMoveStringLiteralDfa15_0(active0, 0x10000000000000ULL, active1, 0L); |
| 1357 |
case 70: |
| 1358 |
return jjMoveStringLiteralDfa15_0(active0, 0x8000000000ULL, active1, 0L); |
| 1359 |
case 79: |
| 1360 |
return jjMoveStringLiteralDfa15_0(active0, 0x2000000000ULL, active1, 0L); |
| 1361 |
case 80: |
| 1362 |
return jjMoveStringLiteralDfa15_0(active0, 0x8008000000000000ULL, active1, 0x408ULL); |
| 1363 |
case 82: |
| 1364 |
return jjMoveStringLiteralDfa15_0(active0, 0x20000000000000ULL, active1, 0L); |
| 1365 |
case 99: |
| 1366 |
return jjMoveStringLiteralDfa15_0(active0, 0x3084000000800000ULL, active1, 0L); |
| 1367 |
case 100: |
| 1368 |
return jjMoveStringLiteralDfa15_0(active0, 0x400000000ULL, active1, 0L); |
| 1369 |
case 101: |
| 1370 |
return jjMoveStringLiteralDfa15_0(active0, 0x400000010010000ULL, active1, 0x30000ULL); |
| 1371 |
case 102: |
| 1372 |
if ((active0 & 0x80000ULL) != 0L) |
| 1373 |
return jjStartNfaWithStates_0(14, 19, 9); |
| 1374 |
break; |
| 1375 |
case 105: |
| 1376 |
return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x80ULL); |
| 1377 |
case 108: |
| 1378 |
if ((active0 & 0x20000ULL) != 0L) |
| 1379 |
return jjStartNfaWithStates_0(14, 17, 9); |
| 1380 |
return jjMoveStringLiteralDfa15_0(active0, 0xc0000000000ULL, active1, 0L); |
| 1381 |
case 109: |
| 1382 |
return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x2ULL); |
| 1383 |
case 110: |
| 1384 |
return jjMoveStringLiteralDfa15_0(active0, 0x100100304000000ULL, active1, 0x4ULL); |
| 1385 |
case 111: |
| 1386 |
return jjMoveStringLiteralDfa15_0(active0, 0x800000000ULL, active1, 0x1001ULL); |
| 1387 |
case 114: |
| 1388 |
return jjMoveStringLiteralDfa15_0(active0, 0x42010000000000ULL, active1, 0xc000ULL); |
| 1389 |
case 115: |
| 1390 |
if ((active0 & 0x800000000000ULL) != 0L) |
| 1391 |
return jjStartNfaWithStates_0(14, 47, 9); |
| 1392 |
return jjMoveStringLiteralDfa15_0(active0, 0x400020000000ULL, active1, 0x800ULL); |
| 1393 |
case 116: |
| 1394 |
return jjMoveStringLiteralDfa15_0(active0, 0xa00000001000000ULL, active1, 0x10ULL); |
| 1395 |
case 121: |
| 1396 |
return jjMoveStringLiteralDfa15_0(active0, 0x4000000000000000ULL, active1, 0L); |
| 1397 |
default : |
| 1398 |
break; |
| 1399 |
} |
| 1400 |
return jjStartNfa_0(13, active0, active1); |
| 1401 |
} |
| 1402 |
|
| 1403 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa15_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1404 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1405 |
return jjStartNfa_0(13, old0, old1); |
| 1406 |
if (input_stream->endOfInput()) { |
| 1407 |
jjStopStringLiteralDfa_0(14, active0, active1); |
| 1408 |
return 15; |
| 1409 |
} |
| 1410 |
curChar = input_stream->readChar(); |
| 1411 |
switch(curChar) |
| 1412 |
{ |
| 1413 |
case 70: |
| 1414 |
return jjMoveStringLiteralDfa16_0(active0, 0x20000000ULL, active1, 0L); |
| 1415 |
case 79: |
| 1416 |
return jjMoveStringLiteralDfa16_0(active0, 0x4000000000000000ULL, active1, 0L); |
| 1417 |
case 80: |
| 1418 |
return jjMoveStringLiteralDfa16_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1419 |
case 97: |
| 1420 |
return jjMoveStringLiteralDfa16_0(active0, 0x120100300000000ULL, active1, 0x2ULL); |
| 1421 |
case 99: |
| 1422 |
return jjMoveStringLiteralDfa16_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1423 |
case 100: |
| 1424 |
return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x80ULL); |
| 1425 |
case 101: |
| 1426 |
return jjMoveStringLiteralDfa16_0(active0, 0x400000000000ULL, active1, 0x800ULL); |
| 1427 |
case 102: |
| 1428 |
if ((active0 & 0x2000000000ULL) != 0L) |
| 1429 |
return jjStartNfaWithStates_0(15, 37, 9); |
| 1430 |
break; |
| 1431 |
case 103: |
| 1432 |
return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x4ULL); |
| 1433 |
case 104: |
| 1434 |
return jjMoveStringLiteralDfa16_0(active0, 0x100000ULL, active1, 0L); |
| 1435 |
case 105: |
| 1436 |
return jjMoveStringLiteralDfa16_0(active0, 0xc0401000000ULL, active1, 0x10ULL); |
| 1437 |
case 110: |
| 1438 |
return jjMoveStringLiteralDfa16_0(active0, 0x800000000ULL, active1, 0L); |
| 1439 |
case 111: |
| 1440 |
return jjMoveStringLiteralDfa16_0(active0, 0x50010000000000ULL, active1, 0x8000ULL); |
| 1441 |
case 112: |
| 1442 |
return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x1001ULL); |
| 1443 |
case 114: |
| 1444 |
return jjMoveStringLiteralDfa16_0(active0, 0x8008008000010000ULL, active1, 0x30408ULL); |
| 1445 |
case 115: |
| 1446 |
return jjMoveStringLiteralDfa16_0(active0, 0x10000000ULL, active1, 0x200ULL); |
| 1447 |
case 116: |
| 1448 |
return jjMoveStringLiteralDfa16_0(active0, 0x3086000004800000ULL, active1, 0x4000ULL); |
| 1449 |
default : |
| 1450 |
break; |
| 1451 |
} |
| 1452 |
return jjStartNfa_0(14, active0, active1); |
| 1453 |
} |
| 1454 |
|
| 1455 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa16_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1456 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1457 |
return jjStartNfa_0(14, old0, old1); |
| 1458 |
if (input_stream->endOfInput()) { |
| 1459 |
jjStopStringLiteralDfa_0(15, active0, active1); |
| 1460 |
return 16; |
| 1461 |
} |
| 1462 |
curChar = input_stream->readChar(); |
| 1463 |
switch(curChar) |
| 1464 |
{ |
| 1465 |
case 70: |
| 1466 |
return jjMoveStringLiteralDfa17_0(active0, 0x10000000ULL, active1, 0L); |
| 1467 |
case 79: |
| 1468 |
return jjMoveStringLiteralDfa17_0(active0, 0x804000000ULL, active1, 0L); |
| 1469 |
case 80: |
| 1470 |
return jjMoveStringLiteralDfa17_0(active0, 0x3084000000000000ULL, active1, 0L); |
| 1471 |
case 97: |
| 1472 |
return jjMoveStringLiteralDfa17_0(active0, 0x100000ULL, active1, 0L); |
| 1473 |
case 101: |
| 1474 |
if ((active1 & 0x4ULL) != 0L) |
| 1475 |
return jjStartNfaWithStates_0(16, 66, 9); |
| 1476 |
return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x1001ULL); |
| 1477 |
case 102: |
| 1478 |
if ((active0 & 0x4000000000000000ULL) != 0L) |
| 1479 |
return jjStartNfaWithStates_0(16, 62, 9); |
| 1480 |
break; |
| 1481 |
case 105: |
| 1482 |
return jjMoveStringLiteralDfa17_0(active0, 0x800000ULL, active1, 0x4002ULL); |
| 1483 |
case 108: |
| 1484 |
return jjMoveStringLiteralDfa17_0(active0, 0x100100300000000ULL, active1, 0L); |
| 1485 |
case 109: |
| 1486 |
if ((active0 & 0x10000000000ULL) != 0L) |
| 1487 |
return jjStartNfaWithStates_0(16, 40, 9); |
| 1488 |
return jjMoveStringLiteralDfa17_0(active0, 0x10000000000000ULL, active1, 0L); |
| 1489 |
case 110: |
| 1490 |
return jjMoveStringLiteralDfa17_0(active0, 0x20000400000000ULL, active1, 0L); |
| 1491 |
case 111: |
| 1492 |
return jjMoveStringLiteralDfa17_0(active0, 0x8008008001000000ULL, active1, 0x418ULL); |
| 1493 |
case 112: |
| 1494 |
return jjMoveStringLiteralDfa17_0(active0, 0x40000000000000ULL, active1, 0x8000ULL); |
| 1495 |
case 114: |
| 1496 |
return jjMoveStringLiteralDfa17_0(active0, 0xa00000020000000ULL, active1, 0x800ULL); |
| 1497 |
case 115: |
| 1498 |
if ((active0 & 0x400000000000ULL) != 0L) |
| 1499 |
return jjStartNfaWithStates_0(16, 46, 9); |
| 1500 |
return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x200ULL); |
| 1501 |
case 116: |
| 1502 |
return jjMoveStringLiteralDfa17_0(active0, 0x4000c0000010000ULL, active1, 0x30000ULL); |
| 1503 |
case 117: |
| 1504 |
return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x80ULL); |
| 1505 |
case 121: |
| 1506 |
return jjMoveStringLiteralDfa17_0(active0, 0x2000000000000ULL, active1, 0L); |
| 1507 |
default : |
| 1508 |
break; |
| 1509 |
} |
| 1510 |
return jjStartNfa_0(15, active0, active1); |
| 1511 |
} |
| 1512 |
|
| 1513 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa17_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1514 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1515 |
return jjStartNfa_0(15, old0, old1); |
| 1516 |
if (input_stream->endOfInput()) { |
| 1517 |
jjStopStringLiteralDfa_0(16, active0, active1); |
| 1518 |
return 17; |
| 1519 |
} |
| 1520 |
curChar = input_stream->readChar(); |
| 1521 |
switch(curChar) |
| 1522 |
{ |
| 1523 |
case 79: |
| 1524 |
return jjMoveStringLiteralDfa18_0(active0, 0x102000000000000ULL, active1, 0L); |
| 1525 |
case 80: |
| 1526 |
return jjMoveStringLiteralDfa18_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1527 |
case 97: |
| 1528 |
return jjMoveStringLiteralDfa18_0(active0, 0x10000400000000ULL, active1, 0x80ULL); |
| 1529 |
case 101: |
| 1530 |
return jjMoveStringLiteralDfa18_0(active0, 0x40000000000000ULL, active1, 0x8200ULL); |
| 1531 |
case 102: |
| 1532 |
if ((active0 & 0x4000000ULL) != 0L) |
| 1533 |
return jjStartNfaWithStates_0(17, 26, 9); |
| 1534 |
else if ((active0 & 0x800000000ULL) != 0L) |
| 1535 |
return jjStartNfaWithStates_0(17, 35, 9); |
| 1536 |
break; |
| 1537 |
case 103: |
| 1538 |
return jjMoveStringLiteralDfa18_0(active0, 0x20000000000000ULL, active1, 0L); |
| 1539 |
case 105: |
| 1540 |
return jjMoveStringLiteralDfa18_0(active0, 0x100300100000ULL, active1, 0L); |
| 1541 |
case 109: |
| 1542 |
if ((active0 & 0x8000000000ULL) != 0L) |
| 1543 |
return jjStartNfaWithStates_0(17, 39, 9); |
| 1544 |
break; |
| 1545 |
case 110: |
| 1546 |
if ((active1 & 0x2ULL) != 0L) |
| 1547 |
return jjStartNfaWithStates_0(17, 65, 9); |
| 1548 |
else if ((active1 & 0x10ULL) != 0L) |
| 1549 |
return jjStartNfaWithStates_0(17, 68, 9); |
| 1550 |
return jjMoveStringLiteralDfa18_0(active0, 0x1000000ULL, active1, 0L); |
| 1551 |
case 111: |
| 1552 |
return jjMoveStringLiteralDfa18_0(active0, 0xa00000020800000ULL, active1, 0x4000ULL); |
| 1553 |
case 112: |
| 1554 |
return jjMoveStringLiteralDfa18_0(active0, 0x8008000000000000ULL, active1, 0x408ULL); |
| 1555 |
case 114: |
| 1556 |
return jjMoveStringLiteralDfa18_0(active0, 0x3084000010000000ULL, active1, 0x1001ULL); |
| 1557 |
case 116: |
| 1558 |
return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x800ULL); |
| 1559 |
case 121: |
| 1560 |
if ((active0 & 0x10000ULL) != 0L) |
| 1561 |
{ |
| 1562 |
jjmatchedKind = 16; |
| 1563 |
jjmatchedPos = 17; |
| 1564 |
} |
| 1565 |
else if ((active0 & 0x40000000000ULL) != 0L) |
| 1566 |
return jjStartNfaWithStates_0(17, 42, 9); |
| 1567 |
else if ((active0 & 0x80000000000ULL) != 0L) |
| 1568 |
return jjStartNfaWithStates_0(17, 43, 9); |
| 1569 |
return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x30000ULL); |
| 1570 |
default : |
| 1571 |
break; |
| 1572 |
} |
| 1573 |
return jjStartNfa_0(16, active0, active1); |
| 1574 |
} |
| 1575 |
|
| 1576 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa18_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1577 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1578 |
return jjStartNfa_0(16, old0, old1); |
| 1579 |
if (input_stream->endOfInput()) { |
| 1580 |
jjStopStringLiteralDfa_0(17, active0, active1); |
| 1581 |
return 18; |
| 1582 |
} |
| 1583 |
curChar = input_stream->readChar(); |
| 1584 |
switch(curChar) |
| 1585 |
{ |
| 1586 |
case 68: |
| 1587 |
return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x10000ULL); |
| 1588 |
case 79: |
| 1589 |
return jjMoveStringLiteralDfa19_0(active0, 0x1000000ULL, active1, 0L); |
| 1590 |
case 82: |
| 1591 |
return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x20000ULL); |
| 1592 |
case 98: |
| 1593 |
return jjMoveStringLiteralDfa19_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1594 |
case 101: |
| 1595 |
if ((active0 & 0x20000000000000ULL) != 0L) |
| 1596 |
return jjStartNfaWithStates_0(18, 53, 9); |
| 1597 |
return jjMoveStringLiteralDfa19_0(active0, 0x8008000000000000ULL, active1, 0x408ULL); |
| 1598 |
case 102: |
| 1599 |
if ((active0 & 0x2000000000000ULL) != 0L) |
| 1600 |
return jjStartNfaWithStates_0(18, 49, 9); |
| 1601 |
break; |
| 1602 |
case 105: |
| 1603 |
return jjMoveStringLiteralDfa19_0(active0, 0x10000000000000ULL, active1, 0x800ULL); |
| 1604 |
case 108: |
| 1605 |
return jjMoveStringLiteralDfa19_0(active0, 0x400000000ULL, active1, 0x80ULL); |
| 1606 |
case 109: |
| 1607 |
if ((active0 & 0x20000000ULL) != 0L) |
| 1608 |
return jjStartNfaWithStates_0(18, 29, 9); |
| 1609 |
break; |
| 1610 |
case 110: |
| 1611 |
if ((active0 & 0x100000ULL) != 0L) |
| 1612 |
return jjStartNfaWithStates_0(18, 20, 9); |
| 1613 |
else if ((active0 & 0x800000ULL) != 0L) |
| 1614 |
return jjStartNfaWithStates_0(18, 23, 9); |
| 1615 |
else if ((active1 & 0x4000ULL) != 0L) |
| 1616 |
return jjStartNfaWithStates_0(18, 78, 9); |
| 1617 |
break; |
| 1618 |
case 111: |
| 1619 |
return jjMoveStringLiteralDfa19_0(active0, 0x3084000010000000ULL, active1, 0L); |
| 1620 |
case 112: |
| 1621 |
return jjMoveStringLiteralDfa19_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1622 |
case 114: |
| 1623 |
return jjMoveStringLiteralDfa19_0(active0, 0x440000000000000ULL, active1, 0x8200ULL); |
| 1624 |
case 116: |
| 1625 |
return jjMoveStringLiteralDfa19_0(active0, 0x100300000000ULL, active1, 0x1001ULL); |
| 1626 |
default : |
| 1627 |
break; |
| 1628 |
} |
| 1629 |
return jjStartNfa_0(17, active0, active1); |
| 1630 |
} |
| 1631 |
|
| 1632 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa19_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1633 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1634 |
return jjStartNfa_0(17, old0, old1); |
| 1635 |
if (input_stream->endOfInput()) { |
| 1636 |
jjStopStringLiteralDfa_0(18, active0, active1); |
| 1637 |
return 19; |
| 1638 |
} |
| 1639 |
curChar = input_stream->readChar(); |
| 1640 |
switch(curChar) |
| 1641 |
{ |
| 1642 |
case 97: |
| 1643 |
return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x20000ULL); |
| 1644 |
case 101: |
| 1645 |
return jjMoveStringLiteralDfa20_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1646 |
case 102: |
| 1647 |
if ((active0 & 0x1000000ULL) != 0L) |
| 1648 |
return jjStartNfaWithStates_0(19, 24, 9); |
| 1649 |
break; |
| 1650 |
case 105: |
| 1651 |
return jjMoveStringLiteralDfa20_0(active0, 0x400000000ULL, active1, 0x1ULL); |
| 1652 |
case 106: |
| 1653 |
return jjMoveStringLiteralDfa20_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1654 |
case 109: |
| 1655 |
if ((active0 & 0x10000000ULL) != 0L) |
| 1656 |
return jjStartNfaWithStates_0(19, 28, 9); |
| 1657 |
break; |
| 1658 |
case 110: |
| 1659 |
if ((active0 & 0x10000000000000ULL) != 0L) |
| 1660 |
return jjStartNfaWithStates_0(19, 52, 9); |
| 1661 |
break; |
| 1662 |
case 111: |
| 1663 |
return jjMoveStringLiteralDfa20_0(active0, 0x400000000000000ULL, active1, 0x10800ULL); |
| 1664 |
case 112: |
| 1665 |
return jjMoveStringLiteralDfa20_0(active0, 0x3084000000000000ULL, active1, 0L); |
| 1666 |
case 114: |
| 1667 |
return jjMoveStringLiteralDfa20_0(active0, 0x8008000000000000ULL, active1, 0x408ULL); |
| 1668 |
case 115: |
| 1669 |
if ((active1 & 0x80ULL) != 0L) |
| 1670 |
return jjStartNfaWithStates_0(19, 71, 9); |
| 1671 |
break; |
| 1672 |
case 116: |
| 1673 |
return jjMoveStringLiteralDfa20_0(active0, 0x40000000000000ULL, active1, 0x8200ULL); |
| 1674 |
case 121: |
| 1675 |
if ((active0 & 0x100000000ULL) != 0L) |
| 1676 |
return jjStartNfaWithStates_0(19, 32, 9); |
| 1677 |
else if ((active0 & 0x200000000ULL) != 0L) |
| 1678 |
return jjStartNfaWithStates_0(19, 33, 9); |
| 1679 |
else if ((active0 & 0x100000000000ULL) != 0L) |
| 1680 |
return jjStartNfaWithStates_0(19, 44, 9); |
| 1681 |
return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x1000ULL); |
| 1682 |
default : |
| 1683 |
break; |
| 1684 |
} |
| 1685 |
return jjStartNfa_0(18, active0, active1); |
| 1686 |
} |
| 1687 |
|
| 1688 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa20_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1689 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1690 |
return jjStartNfa_0(18, old0, old1); |
| 1691 |
if (input_stream->endOfInput()) { |
| 1692 |
jjStopStringLiteralDfa_0(19, active0, active1); |
| 1693 |
return 20; |
| 1694 |
} |
| 1695 |
curChar = input_stream->readChar(); |
| 1696 |
switch(curChar) |
| 1697 |
{ |
| 1698 |
case 65: |
| 1699 |
return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x1000ULL); |
| 1700 |
case 101: |
| 1701 |
return jjMoveStringLiteralDfa21_0(active0, 0x3184000000000000ULL, active1, 0x1ULL); |
| 1702 |
case 105: |
| 1703 |
return jjMoveStringLiteralDfa21_0(active0, 0x40000000000000ULL, active1, 0x200ULL); |
| 1704 |
case 109: |
| 1705 |
return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x10000ULL); |
| 1706 |
case 110: |
| 1707 |
if ((active1 & 0x800ULL) != 0L) |
| 1708 |
return jjStartNfaWithStates_0(20, 75, 9); |
| 1709 |
return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x20000ULL); |
| 1710 |
case 112: |
| 1711 |
return jjMoveStringLiteralDfa21_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1712 |
case 114: |
| 1713 |
return jjMoveStringLiteralDfa21_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1714 |
case 116: |
| 1715 |
return jjMoveStringLiteralDfa21_0(active0, 0x8008000400000000ULL, active1, 0x408ULL); |
| 1716 |
case 121: |
| 1717 |
return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x8000ULL); |
| 1718 |
default : |
| 1719 |
break; |
| 1720 |
} |
| 1721 |
return jjStartNfa_0(19, active0, active1); |
| 1722 |
} |
| 1723 |
|
| 1724 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa21_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1725 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1726 |
return jjStartNfa_0(19, old0, old1); |
| 1727 |
if (input_stream->endOfInput()) { |
| 1728 |
jjStopStringLiteralDfa_0(20, active0, active1); |
| 1729 |
return 21; |
| 1730 |
} |
| 1731 |
curChar = input_stream->readChar(); |
| 1732 |
switch(curChar) |
| 1733 |
{ |
| 1734 |
case 79: |
| 1735 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x8000ULL); |
| 1736 |
case 97: |
| 1737 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x10000ULL); |
| 1738 |
case 99: |
| 1739 |
return jjMoveStringLiteralDfa22_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1740 |
case 101: |
| 1741 |
return jjMoveStringLiteralDfa22_0(active0, 0x440000000000000ULL, active1, 0L); |
| 1742 |
case 103: |
| 1743 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x20000ULL); |
| 1744 |
case 105: |
| 1745 |
return jjMoveStringLiteralDfa22_0(active0, 0x8008000000000000ULL, active1, 0L); |
| 1746 |
case 111: |
| 1747 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x200ULL); |
| 1748 |
case 114: |
| 1749 |
return jjMoveStringLiteralDfa22_0(active0, 0x3084000000000000ULL, active1, 0L); |
| 1750 |
case 115: |
| 1751 |
if ((active1 & 0x1ULL) != 0L) |
| 1752 |
return jjStartNfaWithStates_0(21, 64, 9); |
| 1753 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x1000ULL); |
| 1754 |
case 116: |
| 1755 |
return jjMoveStringLiteralDfa22_0(active0, 0xa00000000000000ULL, active1, 0L); |
| 1756 |
case 121: |
| 1757 |
if ((active0 & 0x400000000ULL) != 0L) |
| 1758 |
return jjStartNfaWithStates_0(21, 34, 9); |
| 1759 |
else if ((active1 & 0x8ULL) != 0L) |
| 1760 |
return jjStartNfaWithStates_0(21, 67, 9); |
| 1761 |
return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x400ULL); |
| 1762 |
default : |
| 1763 |
break; |
| 1764 |
} |
| 1765 |
return jjStartNfa_0(20, active0, active1); |
| 1766 |
} |
| 1767 |
|
| 1768 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa22_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1769 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1770 |
return jjStartNfa_0(20, old0, old1); |
| 1771 |
if (input_stream->endOfInput()) { |
| 1772 |
jjStopStringLiteralDfa_0(21, active0, active1); |
| 1773 |
return 22; |
| 1774 |
} |
| 1775 |
curChar = input_stream->readChar(); |
| 1776 |
switch(curChar) |
| 1777 |
{ |
| 1778 |
case 65: |
| 1779 |
return jjMoveStringLiteralDfa23_0(active0, 0L, active1, 0x400ULL); |
| 1780 |
case 101: |
| 1781 |
if ((active1 & 0x20000ULL) != 0L) |
| 1782 |
return jjStartNfaWithStates_0(22, 81, 9); |
| 1783 |
return jjMoveStringLiteralDfa23_0(active0, 0x8008000000000000ULL, active1, 0L); |
| 1784 |
case 102: |
| 1785 |
if ((active1 & 0x8000ULL) != 0L) |
| 1786 |
return jjStartNfaWithStates_0(22, 79, 9); |
| 1787 |
break; |
| 1788 |
case 105: |
| 1789 |
return jjMoveStringLiteralDfa23_0(active0, 0L, active1, 0x10000ULL); |
| 1790 |
case 110: |
| 1791 |
if ((active1 & 0x200ULL) != 0L) |
| 1792 |
return jjStartNfaWithStates_0(22, 73, 9); |
| 1793 |
break; |
| 1794 |
case 114: |
| 1795 |
return jjMoveStringLiteralDfa23_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1796 |
case 115: |
| 1797 |
if ((active0 & 0x40000000000000ULL) != 0L) |
| 1798 |
return jjStartNfaWithStates_0(22, 54, 9); |
| 1799 |
return jjMoveStringLiteralDfa23_0(active0, 0L, active1, 0x1000ULL); |
| 1800 |
case 116: |
| 1801 |
return jjMoveStringLiteralDfa23_0(active0, 0x3184000000000000ULL, active1, 0L); |
| 1802 |
case 121: |
| 1803 |
if ((active0 & 0x200000000000000ULL) != 0L) |
| 1804 |
return jjStartNfaWithStates_0(22, 57, 9); |
| 1805 |
else if ((active0 & 0x800000000000000ULL) != 0L) |
| 1806 |
return jjStartNfaWithStates_0(22, 59, 9); |
| 1807 |
break; |
| 1808 |
default : |
| 1809 |
break; |
| 1810 |
} |
| 1811 |
return jjStartNfa_0(21, active0, active1); |
| 1812 |
} |
| 1813 |
|
| 1814 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa23_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1815 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1816 |
return jjStartNfa_0(21, old0, old1); |
| 1817 |
if (input_stream->endOfInput()) { |
| 1818 |
jjStopStringLiteralDfa_0(22, active0, active1); |
| 1819 |
return 23; |
| 1820 |
} |
| 1821 |
curChar = input_stream->readChar(); |
| 1822 |
switch(curChar) |
| 1823 |
{ |
| 1824 |
case 80: |
| 1825 |
return jjMoveStringLiteralDfa24_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1826 |
case 101: |
| 1827 |
return jjMoveStringLiteralDfa24_0(active0, 0L, active1, 0x1000ULL); |
| 1828 |
case 105: |
| 1829 |
return jjMoveStringLiteralDfa24_0(active0, 0x4000000000000ULL, active1, 0L); |
| 1830 |
case 110: |
| 1831 |
if ((active1 & 0x10000ULL) != 0L) |
| 1832 |
return jjStartNfaWithStates_0(23, 80, 9); |
| 1833 |
break; |
| 1834 |
case 115: |
| 1835 |
if ((active0 & 0x8000000000000ULL) != 0L) |
| 1836 |
return jjStartNfaWithStates_0(23, 51, 9); |
| 1837 |
else if ((active0 & 0x8000000000000000ULL) != 0L) |
| 1838 |
return jjStartNfaWithStates_0(23, 63, 9); |
| 1839 |
return jjMoveStringLiteralDfa24_0(active0, 0L, active1, 0x400ULL); |
| 1840 |
case 116: |
| 1841 |
return jjMoveStringLiteralDfa24_0(active0, 0x400000000000000ULL, active1, 0L); |
| 1842 |
case 121: |
| 1843 |
if ((active0 & 0x80000000000000ULL) != 0L) |
| 1844 |
return jjStartNfaWithStates_0(23, 55, 9); |
| 1845 |
else if ((active0 & 0x1000000000000000ULL) != 0L) |
| 1846 |
return jjStartNfaWithStates_0(23, 60, 9); |
| 1847 |
else if ((active0 & 0x2000000000000000ULL) != 0L) |
| 1848 |
return jjStartNfaWithStates_0(23, 61, 9); |
| 1849 |
break; |
| 1850 |
default : |
| 1851 |
break; |
| 1852 |
} |
| 1853 |
return jjStartNfa_0(22, active0, active1); |
| 1854 |
} |
| 1855 |
|
| 1856 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa24_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1857 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1858 |
return jjStartNfa_0(22, old0, old1); |
| 1859 |
if (input_stream->endOfInput()) { |
| 1860 |
jjStopStringLiteralDfa_0(23, active0, active1); |
| 1861 |
return 24; |
| 1862 |
} |
| 1863 |
curChar = input_stream->readChar(); |
| 1864 |
switch(curChar) |
| 1865 |
{ |
| 1866 |
case 101: |
| 1867 |
return jjMoveStringLiteralDfa25_0(active0, 0x4000000000000ULL, active1, 0L); |
| 1868 |
case 114: |
| 1869 |
return jjMoveStringLiteralDfa25_0(active0, 0x100000000000000ULL, active1, 0x1000ULL); |
| 1870 |
case 115: |
| 1871 |
return jjMoveStringLiteralDfa25_0(active0, 0L, active1, 0x400ULL); |
| 1872 |
case 121: |
| 1873 |
if ((active0 & 0x400000000000000ULL) != 0L) |
| 1874 |
return jjStartNfaWithStates_0(24, 58, 9); |
| 1875 |
break; |
| 1876 |
default : |
| 1877 |
break; |
| 1878 |
} |
| 1879 |
return jjStartNfa_0(23, active0, active1); |
| 1880 |
} |
| 1881 |
|
| 1882 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa25_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1883 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1884 |
return jjStartNfa_0(23, old0, old1); |
| 1885 |
if (input_stream->endOfInput()) { |
| 1886 |
jjStopStringLiteralDfa_0(24, active0, active1); |
| 1887 |
return 25; |
| 1888 |
} |
| 1889 |
curChar = input_stream->readChar(); |
| 1890 |
switch(curChar) |
| 1891 |
{ |
| 1892 |
case 101: |
| 1893 |
return jjMoveStringLiteralDfa26_0(active0, 0L, active1, 0x400ULL); |
| 1894 |
case 111: |
| 1895 |
return jjMoveStringLiteralDfa26_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1896 |
case 115: |
| 1897 |
if ((active0 & 0x4000000000000ULL) != 0L) |
| 1898 |
return jjStartNfaWithStates_0(25, 50, 9); |
| 1899 |
break; |
| 1900 |
case 116: |
| 1901 |
return jjMoveStringLiteralDfa26_0(active0, 0L, active1, 0x1000ULL); |
| 1902 |
default : |
| 1903 |
break; |
| 1904 |
} |
| 1905 |
return jjStartNfa_0(24, active0, active1); |
| 1906 |
} |
| 1907 |
|
| 1908 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa26_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1909 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1910 |
return jjStartNfa_0(24, old0, old1); |
| 1911 |
if (input_stream->endOfInput()) { |
| 1912 |
jjStopStringLiteralDfa_0(25, active0, active1); |
| 1913 |
return 26; |
| 1914 |
} |
| 1915 |
curChar = input_stream->readChar(); |
| 1916 |
switch(curChar) |
| 1917 |
{ |
| 1918 |
case 105: |
| 1919 |
return jjMoveStringLiteralDfa27_0(active0, 0L, active1, 0x1000ULL); |
| 1920 |
case 112: |
| 1921 |
return jjMoveStringLiteralDfa27_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1922 |
case 114: |
| 1923 |
return jjMoveStringLiteralDfa27_0(active0, 0L, active1, 0x400ULL); |
| 1924 |
default : |
| 1925 |
break; |
| 1926 |
} |
| 1927 |
return jjStartNfa_0(25, active0, active1); |
| 1928 |
} |
| 1929 |
|
| 1930 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa27_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1931 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1932 |
return jjStartNfa_0(25, old0, old1); |
| 1933 |
if (input_stream->endOfInput()) { |
| 1934 |
jjStopStringLiteralDfa_0(26, active0, active1); |
| 1935 |
return 27; |
| 1936 |
} |
| 1937 |
curChar = input_stream->readChar(); |
| 1938 |
switch(curChar) |
| 1939 |
{ |
| 1940 |
case 101: |
| 1941 |
return jjMoveStringLiteralDfa28_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1942 |
case 111: |
| 1943 |
return jjMoveStringLiteralDfa28_0(active0, 0L, active1, 0x1000ULL); |
| 1944 |
case 116: |
| 1945 |
return jjMoveStringLiteralDfa28_0(active0, 0L, active1, 0x400ULL); |
| 1946 |
default : |
| 1947 |
break; |
| 1948 |
} |
| 1949 |
return jjStartNfa_0(26, active0, active1); |
| 1950 |
} |
| 1951 |
|
| 1952 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa28_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1953 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1954 |
return jjStartNfa_0(26, old0, old1); |
| 1955 |
if (input_stream->endOfInput()) { |
| 1956 |
jjStopStringLiteralDfa_0(27, active0, active1); |
| 1957 |
return 28; |
| 1958 |
} |
| 1959 |
curChar = input_stream->readChar(); |
| 1960 |
switch(curChar) |
| 1961 |
{ |
| 1962 |
case 105: |
| 1963 |
return jjMoveStringLiteralDfa29_0(active0, 0L, active1, 0x400ULL); |
| 1964 |
case 110: |
| 1965 |
if ((active1 & 0x1000ULL) != 0L) |
| 1966 |
return jjStartNfaWithStates_0(28, 76, 9); |
| 1967 |
break; |
| 1968 |
case 114: |
| 1969 |
return jjMoveStringLiteralDfa29_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1970 |
default : |
| 1971 |
break; |
| 1972 |
} |
| 1973 |
return jjStartNfa_0(27, active0, active1); |
| 1974 |
} |
| 1975 |
|
| 1976 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa29_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1977 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1978 |
return jjStartNfa_0(27, old0, old1); |
| 1979 |
if (input_stream->endOfInput()) { |
| 1980 |
jjStopStringLiteralDfa_0(28, active0, active1); |
| 1981 |
return 29; |
| 1982 |
} |
| 1983 |
curChar = input_stream->readChar(); |
| 1984 |
switch(curChar) |
| 1985 |
{ |
| 1986 |
case 111: |
| 1987 |
return jjMoveStringLiteralDfa30_0(active0, 0L, active1, 0x400ULL); |
| 1988 |
case 116: |
| 1989 |
return jjMoveStringLiteralDfa30_0(active0, 0x100000000000000ULL, active1, 0L); |
| 1990 |
default : |
| 1991 |
break; |
| 1992 |
} |
| 1993 |
return jjStartNfa_0(28, active0, active1); |
| 1994 |
} |
| 1995 |
|
| 1996 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa30_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){ |
| 1997 |
if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| 1998 |
return jjStartNfa_0(28, old0, old1); |
| 1999 |
if (input_stream->endOfInput()) { |
| 2000 |
jjStopStringLiteralDfa_0(29, active0, active1); |
| 2001 |
return 30; |
| 2002 |
} |
| 2003 |
curChar = input_stream->readChar(); |
| 2004 |
switch(curChar) |
| 2005 |
{ |
| 2006 |
case 110: |
| 2007 |
if ((active1 & 0x400ULL) != 0L) |
| 2008 |
return jjStartNfaWithStates_0(30, 74, 9); |
| 2009 |
break; |
| 2010 |
case 121: |
| 2011 |
if ((active0 & 0x100000000000000ULL) != 0L) |
| 2012 |
return jjStartNfaWithStates_0(30, 56, 9); |
| 2013 |
break; |
| 2014 |
default : |
| 2015 |
break; |
| 2016 |
} |
| 2017 |
return jjStartNfa_0(29, active0, active1); |
| 2018 |
} |
| 2019 |
|
| 2020 |
int OWL2FunctionalStyleParserTokenManager::jjStartNfaWithStates_0(int pos, int kind, int state){ |
| 2021 |
jjmatchedKind = kind; |
| 2022 |
jjmatchedPos = pos; |
| 2023 |
if (input_stream->endOfInput()) { return pos + 1; } |
| 2024 |
curChar = input_stream->readChar(); |
| 2025 |
return jjMoveNfa_0(state, pos + 1); |
| 2026 |
} |
| 2027 |
|
| 2028 |
int OWL2FunctionalStyleParserTokenManager::jjMoveNfa_0(int startState, int curPos){ |
| 2029 |
int startsAt = 0; |
| 2030 |
jjnewStateCnt = 9; |
| 2031 |
int i = 1; |
| 2032 |
jjstateSet[0] = startState; |
| 2033 |
int kind = 0x7fffffff; |
| 2034 |
for (;;) |
| 2035 |
{ |
| 2036 |
if (++jjround == 0x7fffffff) |
| 2037 |
ReInitRounds(); |
| 2038 |
if (curChar < 64) |
| 2039 |
{ |
| 2040 |
unsigned long long l = 1ULL << curChar; |
| 2041 |
if (l == 1); |
| 2042 |
do |
| 2043 |
{ |
| 2044 |
switch(jjstateSet[--i]) |
| 2045 |
{ |
| 2046 |
case 9: |
| 2047 |
if ((0x3ff600000000000ULL & l) != 0L) |
| 2048 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2049 |
else if (curChar == 58) |
| 2050 |
{ |
| 2051 |
if (kind > 84) |
| 2052 |
kind = 84; |
| 2053 |
} |
| 2054 |
if ((0x3ff200000000000ULL & l) != 0L) |
| 2055 |
jjstateSet[jjnewStateCnt++] = 8; |
| 2056 |
break; |
| 2057 |
case 1: |
| 2058 |
if ((0x3ff000000000000ULL & l) != 0L) |
| 2059 |
{ |
| 2060 |
if (kind > 82) |
| 2061 |
kind = 82; |
| 2062 |
{ jjCheckNAdd(0); } |
| 2063 |
} |
| 2064 |
else if (curChar == 58) |
| 2065 |
{ |
| 2066 |
if (kind > 84) |
| 2067 |
kind = 84; |
| 2068 |
} |
| 2069 |
break; |
| 2070 |
case 0: |
| 2071 |
if ((0x3ff000000000000ULL & l) == 0L) |
| 2072 |
break; |
| 2073 |
if (kind > 82) |
| 2074 |
kind = 82; |
| 2075 |
{ jjCheckNAdd(0); } |
| 2076 |
break; |
| 2077 |
case 3: |
| 2078 |
if (curChar == 45) |
| 2079 |
{ jjCheckNAdd(4); } |
| 2080 |
break; |
| 2081 |
case 4: |
| 2082 |
if ((0x3ff000000000000ULL & l) == 0L) |
| 2083 |
break; |
| 2084 |
if (kind > 83) |
| 2085 |
kind = 83; |
| 2086 |
{ jjCheckNAddTwoStates(3, 4); } |
| 2087 |
break; |
| 2088 |
case 6: |
| 2089 |
if ((0x3ff600000000000ULL & l) != 0L) |
| 2090 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2091 |
break; |
| 2092 |
case 7: |
| 2093 |
if ((0x3ff200000000000ULL & l) != 0L) |
| 2094 |
jjstateSet[jjnewStateCnt++] = 8; |
| 2095 |
break; |
| 2096 |
case 8: |
| 2097 |
if (curChar == 58) |
| 2098 |
kind = 84; |
| 2099 |
break; |
| 2100 |
default : break; |
| 2101 |
} |
| 2102 |
} while(i != startsAt); |
| 2103 |
} |
| 2104 |
else if (curChar < 128) |
| 2105 |
{ |
| 2106 |
unsigned long long l = 1ULL << (curChar & 077); |
| 2107 |
if (l == 1); |
| 2108 |
do |
| 2109 |
{ |
| 2110 |
switch(jjstateSet[--i]) |
| 2111 |
{ |
| 2112 |
case 9: |
| 2113 |
if ((0x7fffffe87fffffeULL & l) != 0L) |
| 2114 |
{ jjCheckNAdd(8); } |
| 2115 |
if ((0x7fffffe87fffffeULL & l) != 0L) |
| 2116 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2117 |
break; |
| 2118 |
case 1: |
| 2119 |
if ((0x7fffffe07fffffeULL & l) != 0L) |
| 2120 |
{ jjCheckNAddStates(0, 2); } |
| 2121 |
else if (curChar == 64) |
| 2122 |
{ jjCheckNAdd(2); } |
| 2123 |
break; |
| 2124 |
case 2: |
| 2125 |
if ((0x7fffffe07fffffeULL & l) == 0L) |
| 2126 |
break; |
| 2127 |
if (kind > 83) |
| 2128 |
kind = 83; |
| 2129 |
{ jjCheckNAddTwoStates(2, 3); } |
| 2130 |
break; |
| 2131 |
case 4: |
| 2132 |
if ((0x7fffffe07fffffeULL & l) == 0L) |
| 2133 |
break; |
| 2134 |
if (kind > 83) |
| 2135 |
kind = 83; |
| 2136 |
{ jjCheckNAddTwoStates(3, 4); } |
| 2137 |
break; |
| 2138 |
case 5: |
| 2139 |
if ((0x7fffffe07fffffeULL & l) != 0L) |
| 2140 |
{ jjCheckNAddStates(0, 2); } |
| 2141 |
break; |
| 2142 |
case 6: |
| 2143 |
if ((0x7fffffe87fffffeULL & l) != 0L) |
| 2144 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2145 |
break; |
| 2146 |
case 7: |
| 2147 |
if ((0x7fffffe87fffffeULL & l) != 0L) |
| 2148 |
{ jjCheckNAdd(8); } |
| 2149 |
break; |
| 2150 |
default : break; |
| 2151 |
} |
| 2152 |
} while(i != startsAt); |
| 2153 |
} |
| 2154 |
else |
| 2155 |
{ |
| 2156 |
int hiByte = (curChar >> 8); |
| 2157 |
int i1 = hiByte >> 6; |
| 2158 |
unsigned long long l1 = 1ULL << (hiByte & 077); |
| 2159 |
int i2 = (curChar & 0xff) >> 6; |
| 2160 |
unsigned long long l2 = 1ULL << (curChar & 077); |
| 2161 |
do |
| 2162 |
{ |
| 2163 |
switch(jjstateSet[--i]) |
| 2164 |
{ |
| 2165 |
case 9: |
| 2166 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2)) |
| 2167 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2168 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2)) |
| 2169 |
{ jjCheckNAdd(8); } |
| 2170 |
break; |
| 2171 |
case 1: |
| 2172 |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) |
| 2173 |
{ jjCheckNAddStates(0, 2); } |
| 2174 |
break; |
| 2175 |
case 6: |
| 2176 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2)) |
| 2177 |
{ jjCheckNAddTwoStates(6, 7); } |
| 2178 |
break; |
| 2179 |
case 7: |
| 2180 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2)) |
| 2181 |
{ jjCheckNAdd(8); } |
| 2182 |
break; |
| 2183 |
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break; |
| 2184 |
} |
| 2185 |
} while(i != startsAt); |
| 2186 |
} |
| 2187 |
if (kind != 0x7fffffff) |
| 2188 |
{ |
| 2189 |
jjmatchedKind = kind; |
| 2190 |
jjmatchedPos = curPos; |
| 2191 |
kind = 0x7fffffff; |
| 2192 |
} |
| 2193 |
++curPos; |
| 2194 |
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 9 - startsAt))) |
| 2195 |
return curPos; |
| 2196 |
if (input_stream->endOfInput()) { return curPos; } |
| 2197 |
curChar = input_stream->readChar(); |
| 2198 |
} |
| 2199 |
} |
| 2200 |
|
| 2201 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_3(){ |
| 2202 |
return jjMoveNfa_3(0, 0); |
| 2203 |
} |
| 2204 |
|
| 2205 |
int OWL2FunctionalStyleParserTokenManager::jjMoveNfa_3(int startState, int curPos){ |
| 2206 |
int startsAt = 0; |
| 2207 |
jjnewStateCnt = 3; |
| 2208 |
int i = 1; |
| 2209 |
jjstateSet[0] = startState; |
| 2210 |
int kind = 0x7fffffff; |
| 2211 |
for (;;) |
| 2212 |
{ |
| 2213 |
if (++jjround == 0x7fffffff) |
| 2214 |
ReInitRounds(); |
| 2215 |
if (curChar < 64) |
| 2216 |
{ |
| 2217 |
unsigned long long l = 1ULL << curChar; |
| 2218 |
if (l == 1); |
| 2219 |
do |
| 2220 |
{ |
| 2221 |
switch(jjstateSet[--i]) |
| 2222 |
{ |
| 2223 |
case 0: |
| 2224 |
if ((0x3ff000000000000ULL & l) == 0L) |
| 2225 |
break; |
| 2226 |
if (kind > 96) |
| 2227 |
kind = 96; |
| 2228 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2229 |
break; |
| 2230 |
case 1: |
| 2231 |
if ((0x3ff600000000000ULL & l) != 0L) |
| 2232 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2233 |
break; |
| 2234 |
case 2: |
| 2235 |
if ((0x3ff200000000000ULL & l) != 0L && kind > 96) |
| 2236 |
kind = 96; |
| 2237 |
break; |
| 2238 |
default : break; |
| 2239 |
} |
| 2240 |
} while(i != startsAt); |
| 2241 |
} |
| 2242 |
else if (curChar < 128) |
| 2243 |
{ |
| 2244 |
unsigned long long l = 1ULL << (curChar & 077); |
| 2245 |
if (l == 1); |
| 2246 |
do |
| 2247 |
{ |
| 2248 |
switch(jjstateSet[--i]) |
| 2249 |
{ |
| 2250 |
case 0: |
| 2251 |
if ((0x7fffffe87fffffeULL & l) == 0L) |
| 2252 |
break; |
| 2253 |
if (kind > 96) |
| 2254 |
kind = 96; |
| 2255 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2256 |
break; |
| 2257 |
case 1: |
| 2258 |
if ((0x7fffffe87fffffeULL & l) != 0L) |
| 2259 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2260 |
break; |
| 2261 |
case 2: |
| 2262 |
if ((0x7fffffe87fffffeULL & l) != 0L && kind > 96) |
| 2263 |
kind = 96; |
| 2264 |
break; |
| 2265 |
default : break; |
| 2266 |
} |
| 2267 |
} while(i != startsAt); |
| 2268 |
} |
| 2269 |
else |
| 2270 |
{ |
| 2271 |
int hiByte = (curChar >> 8); |
| 2272 |
int i1 = hiByte >> 6; |
| 2273 |
unsigned long long l1 = 1ULL << (hiByte & 077); |
| 2274 |
int i2 = (curChar & 0xff) >> 6; |
| 2275 |
unsigned long long l2 = 1ULL << (curChar & 077); |
| 2276 |
do |
| 2277 |
{ |
| 2278 |
switch(jjstateSet[--i]) |
| 2279 |
{ |
| 2280 |
case 0: |
| 2281 |
if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
| 2282 |
break; |
| 2283 |
if (kind > 96) |
| 2284 |
kind = 96; |
| 2285 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2286 |
break; |
| 2287 |
case 1: |
| 2288 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2)) |
| 2289 |
{ jjCheckNAddTwoStates(1, 2); } |
| 2290 |
break; |
| 2291 |
case 2: |
| 2292 |
if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 96) |
| 2293 |
kind = 96; |
| 2294 |
break; |
| 2295 |
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break; |
| 2296 |
} |
| 2297 |
} while(i != startsAt); |
| 2298 |
} |
| 2299 |
if (kind != 0x7fffffff) |
| 2300 |
{ |
| 2301 |
jjmatchedKind = kind; |
| 2302 |
jjmatchedPos = curPos; |
| 2303 |
kind = 0x7fffffff; |
| 2304 |
} |
| 2305 |
++curPos; |
| 2306 |
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt))) |
| 2307 |
return curPos; |
| 2308 |
if (input_stream->endOfInput()) { return curPos; } |
| 2309 |
curChar = input_stream->readChar(); |
| 2310 |
} |
| 2311 |
} |
| 2312 |
|
| 2313 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_5(){ |
| 2314 |
switch(curChar) |
| 2315 |
{ |
| 2316 |
case 34: |
| 2317 |
return jjStopAtPos(0, 99); |
| 2318 |
default : |
| 2319 |
return 1; |
| 2320 |
} |
| 2321 |
} |
| 2322 |
|
| 2323 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_1(){ |
| 2324 |
return jjMoveNfa_1(0, 0); |
| 2325 |
} |
| 2326 |
|
| 2327 |
int OWL2FunctionalStyleParserTokenManager::jjMoveNfa_1(int startState, int curPos){ |
| 2328 |
int startsAt = 0; |
| 2329 |
jjnewStateCnt = 1; |
| 2330 |
int i = 1; |
| 2331 |
jjstateSet[0] = startState; |
| 2332 |
int kind = 0x7fffffff; |
| 2333 |
for (;;) |
| 2334 |
{ |
| 2335 |
if (++jjround == 0x7fffffff) |
| 2336 |
ReInitRounds(); |
| 2337 |
if (curChar < 64) |
| 2338 |
{ |
| 2339 |
unsigned long long l = 1ULL << curChar; |
| 2340 |
if (l == 1); |
| 2341 |
do |
| 2342 |
{ |
| 2343 |
switch(jjstateSet[--i]) |
| 2344 |
{ |
| 2345 |
case 0: |
| 2346 |
if ((0xaffffffa00000000ULL & l) == 0L) |
| 2347 |
break; |
| 2348 |
kind = 94; |
| 2349 |
jjstateSet[jjnewStateCnt++] = 0; |
| 2350 |
break; |
| 2351 |
default : break; |
| 2352 |
} |
| 2353 |
} while(i != startsAt); |
| 2354 |
} |
| 2355 |
else if (curChar < 128) |
| 2356 |
{ |
| 2357 |
unsigned long long l = 1ULL << (curChar & 077); |
| 2358 |
if (l == 1); |
| 2359 |
do |
| 2360 |
{ |
| 2361 |
switch(jjstateSet[--i]) |
| 2362 |
{ |
| 2363 |
case 0: |
| 2364 |
if ((0xc7fffffeafffffffULL & l) == 0L) |
| 2365 |
break; |
| 2366 |
kind = 94; |
| 2367 |
jjstateSet[jjnewStateCnt++] = 0; |
| 2368 |
break; |
| 2369 |
default : break; |
| 2370 |
} |
| 2371 |
} while(i != startsAt); |
| 2372 |
} |
| 2373 |
else |
| 2374 |
{ |
| 2375 |
int hiByte = (curChar >> 8); |
| 2376 |
int i1 = hiByte >> 6; |
| 2377 |
unsigned long long l1 = 1ULL << (hiByte & 077); |
| 2378 |
int i2 = (curChar & 0xff) >> 6; |
| 2379 |
unsigned long long l2 = 1ULL << (curChar & 077); |
| 2380 |
do |
| 2381 |
{ |
| 2382 |
switch(jjstateSet[--i]) |
| 2383 |
{ |
| 2384 |
case 0: |
| 2385 |
if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) |
| 2386 |
break; |
| 2387 |
if (kind > 94) |
| 2388 |
kind = 94; |
| 2389 |
jjstateSet[jjnewStateCnt++] = 0; |
| 2390 |
break; |
| 2391 |
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break; |
| 2392 |
} |
| 2393 |
} while(i != startsAt); |
| 2394 |
} |
| 2395 |
if (kind != 0x7fffffff) |
| 2396 |
{ |
| 2397 |
jjmatchedKind = kind; |
| 2398 |
jjmatchedPos = curPos; |
| 2399 |
kind = 0x7fffffff; |
| 2400 |
} |
| 2401 |
++curPos; |
| 2402 |
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 1 - startsAt))) |
| 2403 |
return curPos; |
| 2404 |
if (input_stream->endOfInput()) { return curPos; } |
| 2405 |
curChar = input_stream->readChar(); |
| 2406 |
} |
| 2407 |
} |
| 2408 |
|
| 2409 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_6(){ |
| 2410 |
switch(curChar) |
| 2411 |
{ |
| 2412 |
case 10: |
| 2413 |
return jjStopAtPos(0, 100); |
| 2414 |
case 13: |
| 2415 |
return jjStopAtPos(0, 101); |
| 2416 |
default : |
| 2417 |
return 1; |
| 2418 |
} |
| 2419 |
} |
| 2420 |
|
| 2421 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_2(){ |
| 2422 |
switch(curChar) |
| 2423 |
{ |
| 2424 |
case 62: |
| 2425 |
return jjStopAtPos(0, 95); |
| 2426 |
default : |
| 2427 |
return 1; |
| 2428 |
} |
| 2429 |
} |
| 2430 |
|
| 2431 |
int OWL2FunctionalStyleParserTokenManager::jjMoveStringLiteralDfa0_4(){ |
| 2432 |
return jjMoveNfa_4(3, 0); |
| 2433 |
} |
| 2434 |
|
| 2435 |
int OWL2FunctionalStyleParserTokenManager::jjMoveNfa_4(int startState, int curPos){ |
| 2436 |
int startsAt = 0; |
| 2437 |
jjnewStateCnt = 3; |
| 2438 |
int i = 1; |
| 2439 |
jjstateSet[0] = startState; |
| 2440 |
int kind = 0x7fffffff; |
| 2441 |
for (;;) |
| 2442 |
{ |
| 2443 |
if (++jjround == 0x7fffffff) |
| 2444 |
ReInitRounds(); |
| 2445 |
if (curChar < 64) |
| 2446 |
{ |
| 2447 |
unsigned long long l = 1ULL << curChar; |
| 2448 |
if (l == 1); |
| 2449 |
do |
| 2450 |
{ |
| 2451 |
switch(jjstateSet[--i]) |
| 2452 |
{ |
| 2453 |
case 3: |
| 2454 |
case 0: |
| 2455 |
if ((0xfffffffbffffffffULL & l) == 0L) |
| 2456 |
break; |
| 2457 |
if (kind > 98) |
| 2458 |
kind = 98; |
| 2459 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2460 |
break; |
| 2461 |
case 2: |
| 2462 |
if ((0x8400000000ULL & l) == 0L) |
| 2463 |
break; |
| 2464 |
if (kind > 98) |
| 2465 |
kind = 98; |
| 2466 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2467 |
break; |
| 2468 |
default : break; |
| 2469 |
} |
| 2470 |
} while(i != startsAt); |
| 2471 |
} |
| 2472 |
else if (curChar < 128) |
| 2473 |
{ |
| 2474 |
unsigned long long l = 1ULL << (curChar & 077); |
| 2475 |
if (l == 1); |
| 2476 |
do |
| 2477 |
{ |
| 2478 |
switch(jjstateSet[--i]) |
| 2479 |
{ |
| 2480 |
case 3: |
| 2481 |
if ((0xffffffffefffffffULL & l) != 0L) |
| 2482 |
{ |
| 2483 |
if (kind > 98) |
| 2484 |
kind = 98; |
| 2485 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2486 |
} |
| 2487 |
else if (curChar == 92) |
| 2488 |
jjstateSet[jjnewStateCnt++] = 2; |
| 2489 |
break; |
| 2490 |
case 0: |
| 2491 |
if ((0xffffffffefffffffULL & l) == 0L) |
| 2492 |
break; |
| 2493 |
kind = 98; |
| 2494 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2495 |
break; |
| 2496 |
case 1: |
| 2497 |
if (curChar == 92) |
| 2498 |
jjstateSet[jjnewStateCnt++] = 2; |
| 2499 |
break; |
| 2500 |
case 2: |
| 2501 |
if (curChar != 92) |
| 2502 |
break; |
| 2503 |
if (kind > 98) |
| 2504 |
kind = 98; |
| 2505 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2506 |
break; |
| 2507 |
default : break; |
| 2508 |
} |
| 2509 |
} while(i != startsAt); |
| 2510 |
} |
| 2511 |
else |
| 2512 |
{ |
| 2513 |
int hiByte = (curChar >> 8); |
| 2514 |
int i1 = hiByte >> 6; |
| 2515 |
unsigned long long l1 = 1ULL << (hiByte & 077); |
| 2516 |
int i2 = (curChar & 0xff) >> 6; |
| 2517 |
unsigned long long l2 = 1ULL << (curChar & 077); |
| 2518 |
do |
| 2519 |
{ |
| 2520 |
switch(jjstateSet[--i]) |
| 2521 |
{ |
| 2522 |
case 3: |
| 2523 |
case 0: |
| 2524 |
if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) |
| 2525 |
break; |
| 2526 |
if (kind > 98) |
| 2527 |
kind = 98; |
| 2528 |
{ jjCheckNAddTwoStates(0, 1); } |
| 2529 |
break; |
| 2530 |
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break; |
| 2531 |
} |
| 2532 |
} while(i != startsAt); |
| 2533 |
} |
| 2534 |
if (kind != 0x7fffffff) |
| 2535 |
{ |
| 2536 |
jjmatchedKind = kind; |
| 2537 |
jjmatchedPos = curPos; |
| 2538 |
kind = 0x7fffffff; |
| 2539 |
} |
| 2540 |
++curPos; |
| 2541 |
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt))) |
| 2542 |
return curPos; |
| 2543 |
if (input_stream->endOfInput()) { return curPos; } |
| 2544 |
curChar = input_stream->readChar(); |
| 2545 |
} |
| 2546 |
} |
| 2547 |
|
| 2548 |
bool OWL2FunctionalStyleParserTokenManager::jjCanMove_0(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){ |
| 2549 |
switch(hiByte) |
| 2550 |
{ |
| 2551 |
case 0: |
| 2552 |
return ((jjbitVec2[i2] & l2) != 0L); |
| 2553 |
case 3: |
| 2554 |
return ((jjbitVec3[i2] & l2) != 0L); |
| 2555 |
case 32: |
| 2556 |
return ((jjbitVec4[i2] & l2) != 0L); |
| 2557 |
case 33: |
| 2558 |
return ((jjbitVec5[i2] & l2) != 0L); |
| 2559 |
case 47: |
| 2560 |
return ((jjbitVec6[i2] & l2) != 0L); |
| 2561 |
case 48: |
| 2562 |
return ((jjbitVec7[i2] & l2) != 0L); |
| 2563 |
case 253: |
| 2564 |
return ((jjbitVec8[i2] & l2) != 0L); |
| 2565 |
case 255: |
| 2566 |
return ((jjbitVec9[i2] & l2) != 0L); |
| 2567 |
default : |
| 2568 |
if ((jjbitVec0[i1] & l1) != 0L) |
| 2569 |
return true; |
| 2570 |
return false; |
| 2571 |
} |
| 2572 |
} |
| 2573 |
|
| 2574 |
bool OWL2FunctionalStyleParserTokenManager::jjCanMove_1(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){ |
| 2575 |
switch(hiByte) |
| 2576 |
{ |
| 2577 |
case 0: |
| 2578 |
return ((jjbitVec10[i2] & l2) != 0L); |
| 2579 |
case 3: |
| 2580 |
return ((jjbitVec11[i2] & l2) != 0L); |
| 2581 |
case 32: |
| 2582 |
return ((jjbitVec12[i2] & l2) != 0L); |
| 2583 |
case 33: |
| 2584 |
return ((jjbitVec5[i2] & l2) != 0L); |
| 2585 |
case 47: |
| 2586 |
return ((jjbitVec6[i2] & l2) != 0L); |
| 2587 |
case 48: |
| 2588 |
return ((jjbitVec7[i2] & l2) != 0L); |
| 2589 |
case 253: |
| 2590 |
return ((jjbitVec8[i2] & l2) != 0L); |
| 2591 |
case 255: |
| 2592 |
return ((jjbitVec9[i2] & l2) != 0L); |
| 2593 |
default : |
| 2594 |
if ((jjbitVec0[i1] & l1) != 0L) |
| 2595 |
return true; |
| 2596 |
return false; |
| 2597 |
} |
| 2598 |
} |
| 2599 |
|
| 2600 |
bool OWL2FunctionalStyleParserTokenManager::jjCanMove_2(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){ |
| 2601 |
switch(hiByte) |
| 2602 |
{ |
| 2603 |
case 0: |
| 2604 |
return ((jjbitVec13[i2] & l2) != 0L); |
| 2605 |
default : |
| 2606 |
if ((jjbitVec7[i1] & l1) != 0L) |
| 2607 |
return true; |
| 2608 |
return false; |
| 2609 |
} |
| 2610 |
} |
| 2611 |
|
| 2612 |
/** Token literal values. */ |
| 2613 |
|
| 2614 |
Token * OWL2FunctionalStyleParserTokenManager::jjFillToken(){ |
| 2615 |
Token *t; |
| 2616 |
JAVACC_STRING_TYPE curTokenImage; |
| 2617 |
int beginLine; |
| 2618 |
int endLine; |
| 2619 |
int beginColumn; |
| 2620 |
int endColumn; |
| 2621 |
if (jjmatchedPos < 0) |
| 2622 |
{ |
| 2623 |
curTokenImage = image.c_str(); |
| 2624 |
if (input_stream->getTrackLineColumn()) { |
| 2625 |
beginLine = endLine = input_stream->getEndLine(); |
| 2626 |
beginColumn = endColumn = input_stream->getEndColumn(); |
| 2627 |
} |
| 2628 |
} |
| 2629 |
else |
| 2630 |
{ |
| 2631 |
JAVACC_STRING_TYPE im = jjstrLiteralImages[jjmatchedKind]; |
| 2632 |
curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im; |
| 2633 |
if (input_stream->getTrackLineColumn()) { |
| 2634 |
beginLine = input_stream->getBeginLine(); |
| 2635 |
beginColumn = input_stream->getBeginColumn(); |
| 2636 |
endLine = input_stream->getEndLine(); |
| 2637 |
endColumn = input_stream->getEndColumn(); |
| 2638 |
} |
| 2639 |
} |
| 2640 |
t = Token::newToken(jjmatchedKind, curTokenImage); |
| 2641 |
t->specialToken = NULL; |
| 2642 |
t->next = NULL; |
| 2643 |
|
| 2644 |
if (input_stream->getTrackLineColumn()) { |
| 2645 |
t->beginLine = beginLine; |
| 2646 |
t->endLine = endLine; |
| 2647 |
t->beginColumn = beginColumn; |
| 2648 |
t->endColumn = endColumn; |
| 2649 |
} |
| 2650 |
|
| 2651 |
return t; |
| 2652 |
} |
| 2653 |
const int defaultLexState = 0; |
| 2654 |
/** Get the next Token. */ |
| 2655 |
|
| 2656 |
Token * OWL2FunctionalStyleParserTokenManager::getNextToken(){ |
| 2657 |
Token *matchedToken; |
| 2658 |
int curPos = 0; |
| 2659 |
|
| 2660 |
for (;;) |
| 2661 |
{ |
| 2662 |
EOFLoop: |
| 2663 |
if (input_stream->endOfInput()) |
| 2664 |
{ |
| 2665 |
jjmatchedKind = 0; |
| 2666 |
jjmatchedPos = -1; |
| 2667 |
matchedToken = jjFillToken(); |
| 2668 |
return matchedToken; |
| 2669 |
} |
| 2670 |
curChar = input_stream->BeginToken(); |
| 2671 |
image = jjimage; |
| 2672 |
image.clear(); |
| 2673 |
jjimageLen = 0; |
| 2674 |
|
| 2675 |
switch(curLexState) |
| 2676 |
{ |
| 2677 |
case 0: |
| 2678 |
{ input_stream->backup(0); |
| 2679 |
while (curChar <= 32 && (0x100002600ULL & (1ULL << curChar)) != 0L) |
| 2680 |
{ |
| 2681 |
if (input_stream->endOfInput()) { goto EOFLoop; } |
| 2682 |
curChar = input_stream->BeginToken(); |
| 2683 |
} |
| 2684 |
} |
| 2685 |
jjmatchedKind = 0x7fffffff; |
| 2686 |
jjmatchedPos = 0; |
| 2687 |
curPos = jjMoveStringLiteralDfa0_0(); |
| 2688 |
break; |
| 2689 |
case 1: |
| 2690 |
jjmatchedKind = 94; |
| 2691 |
jjmatchedPos = -1; |
| 2692 |
curPos = 0; |
| 2693 |
curPos = jjMoveStringLiteralDfa0_1(); |
| 2694 |
break; |
| 2695 |
case 2: |
| 2696 |
jjmatchedKind = 0x7fffffff; |
| 2697 |
jjmatchedPos = 0; |
| 2698 |
curPos = jjMoveStringLiteralDfa0_2(); |
| 2699 |
break; |
| 2700 |
case 3: |
| 2701 |
jjmatchedKind = 97; |
| 2702 |
jjmatchedPos = -1; |
| 2703 |
curPos = 0; |
| 2704 |
curPos = jjMoveStringLiteralDfa0_3(); |
| 2705 |
break; |
| 2706 |
case 4: |
| 2707 |
jjmatchedKind = 98; |
| 2708 |
jjmatchedPos = -1; |
| 2709 |
curPos = 0; |
| 2710 |
curPos = jjMoveStringLiteralDfa0_4(); |
| 2711 |
break; |
| 2712 |
case 5: |
| 2713 |
jjmatchedKind = 0x7fffffff; |
| 2714 |
jjmatchedPos = 0; |
| 2715 |
curPos = jjMoveStringLiteralDfa0_5(); |
| 2716 |
break; |
| 2717 |
case 6: |
| 2718 |
jjmatchedKind = 0x7fffffff; |
| 2719 |
jjmatchedPos = 0; |
| 2720 |
curPos = jjMoveStringLiteralDfa0_6(); |
| 2721 |
if (jjmatchedPos == 0 && jjmatchedKind > 102) |
| 2722 |
{ |
| 2723 |
jjmatchedKind = 102; |
| 2724 |
} |
| 2725 |
break; |
| 2726 |
} |
| 2727 |
if (jjmatchedKind != 0x7fffffff) |
| 2728 |
{ |
| 2729 |
if (jjmatchedPos + 1 < curPos) |
| 2730 |
input_stream->backup(curPos - jjmatchedPos - 1); |
| 2731 |
if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L) |
| 2732 |
{ |
| 2733 |
matchedToken = jjFillToken(); |
| 2734 |
TokenLexicalActions(matchedToken); |
| 2735 |
if (jjnewLexState[jjmatchedKind] != -1) |
| 2736 |
curLexState = jjnewLexState[jjmatchedKind]; |
| 2737 |
return matchedToken; |
| 2738 |
} |
| 2739 |
else |
| 2740 |
{ |
| 2741 |
SkipLexicalActions(NULL); |
| 2742 |
if (jjnewLexState[jjmatchedKind] != -1) |
| 2743 |
curLexState = jjnewLexState[jjmatchedKind]; |
| 2744 |
goto EOFLoop; |
| 2745 |
} |
| 2746 |
} |
| 2747 |
int error_line = input_stream->getEndLine(); |
| 2748 |
int error_column = input_stream->getEndColumn(); |
| 2749 |
JAVACC_STRING_TYPE error_after; |
| 2750 |
bool EOFSeen = false; |
| 2751 |
if (input_stream->endOfInput()) { |
| 2752 |
EOFSeen = true; |
| 2753 |
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage(); |
| 2754 |
if (curChar == '\n' || curChar == '\r') { |
| 2755 |
error_line++; |
| 2756 |
error_column = 0; |
| 2757 |
} |
| 2758 |
else |
| 2759 |
error_column++; |
| 2760 |
} |
| 2761 |
if (!EOFSeen) { |
| 2762 |
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage(); |
| 2763 |
} |
| 2764 |
lexicalError(); |
| 2765 |
} |
| 2766 |
} |
| 2767 |
|
| 2768 |
|
| 2769 |
void OWL2FunctionalStyleParserTokenManager::SkipLexicalActions(Token *matchedToken){ |
| 2770 |
switch(jjmatchedKind) |
| 2771 |
{ |
| 2772 |
default : |
| 2773 |
break; |
| 2774 |
} |
| 2775 |
} |
| 2776 |
|
| 2777 |
void OWL2FunctionalStyleParserTokenManager::TokenLexicalActions(Token *matchedToken){ |
| 2778 |
switch(jjmatchedKind) |
| 2779 |
{ |
| 2780 |
default : |
| 2781 |
break; |
| 2782 |
} |
| 2783 |
} |
| 2784 |
/** Reinitialise parser. */ |
| 2785 |
void OWL2FunctionalStyleParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState, OWL2FunctionalStyleParser *parserArg) { |
| 2786 |
if (input_stream) delete input_stream; |
| 2787 |
jjmatchedPos = jjnewStateCnt = 0; |
| 2788 |
curLexState = lexState; |
| 2789 |
input_stream = stream; |
| 2790 |
ReInitRounds(); |
| 2791 |
debugStream = stdout; // init |
| 2792 |
SwitchTo(lexState); |
| 2793 |
parser = parserArg; |
| 2794 |
} |
| 2795 |
|
| 2796 |
void OWL2FunctionalStyleParserTokenManager::ReInitRounds() { |
| 2797 |
int i; |
| 2798 |
jjround = 0x80000001; |
| 2799 |
for (i = 9; i-- > 0;) |
| 2800 |
jjrounds[i] = 0x80000000; |
| 2801 |
} |
| 2802 |
|
| 2803 |
/** Switch to specified lex state. */ |
| 2804 |
void OWL2FunctionalStyleParserTokenManager::SwitchTo(int lexState) { |
| 2805 |
if (lexState >= 7 || lexState < 0) |
| 2806 |
assert(false); |
| 2807 |
//throw 1;//new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); |
| 2808 |
else |
| 2809 |
curLexState = lexState; |
| 2810 |
} |
| 2811 |
|
| 2812 |
/** Constructor. */ |
| 2813 |
OWL2FunctionalStyleParserTokenManager::OWL2FunctionalStyleParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState, OWL2FunctionalStyleParser *parserArg) |
| 2814 |
: CTokenManager() |
| 2815 |
{ |
| 2816 |
input_stream = NULL; |
| 2817 |
ReInit(stream, lexState, parserArg); |
| 2818 |
} |
| 2819 |
|
| 2820 |
// Destructor |
| 2821 |
OWL2FunctionalStyleParserTokenManager::~OWL2FunctionalStyleParserTokenManager () { |
| 2822 |
if (input_stream) delete input_stream; |
| 2823 |
} |
| 2824 |
} |
| 2825 |
} |
| 2826 |
} |