Debian Codegraph @

Source/Parser/FunctionalJAVACC/OWL2FunctionalStyleParserTokenManager.cpp

raw
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 }