1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 package org.jomc.util;
33 import java.io.StringReader;
34 import java.text.MessageFormat;
35 import java.text.NumberFormat;
36 import java.util.List;
37 import java.util.LinkedList;
38 import java.util.Locale;
39 import java.util.ResourceBundle;
40
41
42 public class VersionParserTokenManager implements VersionParserConstants
43 {
44
45
46 public java.io.PrintStream debugStream = System.out;
47
48 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
49 private int jjMoveStringLiteralDfa0_0()
50 {
51 return jjMoveNfa_0(1, 0);
52 }
53 static final long[] jjbitVec0 = {
54 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
55 };
56 private int jjMoveNfa_0(int startState, int curPos)
57 {
58 int startsAt = 0;
59 jjnewStateCnt = 3;
60 int i = 1;
61 jjstateSet[0] = startState;
62 int kind = 0x7fffffff;
63 for (;;)
64 {
65 if (++jjround == 0x7fffffff)
66 ReInitRounds();
67 if (curChar < 64)
68 {
69 long l = 1L << curChar;
70 do
71 {
72 switch(jjstateSet[--i])
73 {
74 case 1:
75 if ((0xfc001f7affffc8ffL & l) != 0L)
76 {
77 if (kind > 3)
78 kind = 3;
79 jjCheckNAdd(2);
80 }
81 else if ((0xe08500003700L & l) != 0L)
82 {
83 if (kind > 2)
84 kind = 2;
85 }
86 else if ((0x3ff000000000000L & l) != 0L)
87 {
88 if (kind > 1)
89 kind = 1;
90 jjCheckNAdd(0);
91 }
92 break;
93 case 0:
94 if ((0x3ff000000000000L & l) == 0L)
95 break;
96 kind = 1;
97 jjCheckNAdd(0);
98 break;
99 case 2:
100 if ((0xfc001f7affffc8ffL & l) == 0L)
101 break;
102 kind = 3;
103 jjCheckNAdd(2);
104 break;
105 default : break;
106 }
107 } while(i != startsAt);
108 }
109 else if (curChar < 128)
110 {
111 long l = 1L << (curChar & 077);
112 do
113 {
114 switch(jjstateSet[--i])
115 {
116 case 1:
117 if ((0xffffffff6ffffffeL & l) != 0L)
118 {
119 if (kind > 3)
120 kind = 3;
121 jjCheckNAdd(2);
122 }
123 else if ((0x90000001L & l) != 0L)
124 {
125 if (kind > 2)
126 kind = 2;
127 }
128 break;
129 case 2:
130 if ((0xffffffff6ffffffeL & l) == 0L)
131 break;
132 kind = 3;
133 jjCheckNAdd(2);
134 break;
135 default : break;
136 }
137 } while(i != startsAt);
138 }
139 else
140 {
141 int i2 = (curChar & 0xff) >> 6;
142 long l2 = 1L << (curChar & 077);
143 do
144 {
145 switch(jjstateSet[--i])
146 {
147 case 1:
148 case 2:
149 if ((jjbitVec0[i2] & l2) == 0L)
150 break;
151 if (kind > 3)
152 kind = 3;
153 jjCheckNAdd(2);
154 break;
155 default : break;
156 }
157 } while(i != startsAt);
158 }
159 if (kind != 0x7fffffff)
160 {
161 jjmatchedKind = kind;
162 jjmatchedPos = curPos;
163 kind = 0x7fffffff;
164 }
165 ++curPos;
166 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
167 return curPos;
168 try { curChar = input_stream.readChar(); }
169 catch(java.io.IOException e) { return curPos; }
170 }
171 }
172 static final int[] jjnextStates = {
173 };
174
175
176 public static final String[] jjstrLiteralImages = {
177 "", null, null, null, };
178
179
180 public static final String[] lexStateNames = {
181 "DEFAULT",
182 };
183 protected SimpleCharStream input_stream;
184 private final int[] jjrounds = new int[3];
185 private final int[] jjstateSet = new int[6];
186 protected char curChar;
187
188 public VersionParserTokenManager(SimpleCharStream stream){
189 if (SimpleCharStream.staticFlag)
190 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
191 input_stream = stream;
192 }
193
194
195 public VersionParserTokenManager(SimpleCharStream stream, int lexState){
196 this(stream);
197 SwitchTo(lexState);
198 }
199
200
201 public void ReInit(SimpleCharStream stream)
202 {
203 jjmatchedPos = jjnewStateCnt = 0;
204 curLexState = defaultLexState;
205 input_stream = stream;
206 ReInitRounds();
207 }
208 private void ReInitRounds()
209 {
210 int i;
211 jjround = 0x80000001;
212 for (i = 3; i-- > 0;)
213 jjrounds[i] = 0x80000000;
214 }
215
216
217 public void ReInit(SimpleCharStream stream, int lexState)
218 {
219 ReInit(stream);
220 SwitchTo(lexState);
221 }
222
223
224 public void SwitchTo(int lexState)
225 {
226 if (lexState >= 1 || lexState < 0)
227 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
228 else
229 curLexState = lexState;
230 }
231
232 protected Token jjFillToken()
233 {
234 final Token t;
235 final String curTokenImage;
236 final int beginLine;
237 final int endLine;
238 final int beginColumn;
239 final int endColumn;
240 String im = jjstrLiteralImages[jjmatchedKind];
241 curTokenImage = (im == null) ? input_stream.GetImage() : im;
242 beginLine = input_stream.getBeginLine();
243 beginColumn = input_stream.getBeginColumn();
244 endLine = input_stream.getEndLine();
245 endColumn = input_stream.getEndColumn();
246 t = Token.newToken(jjmatchedKind, curTokenImage);
247
248 t.beginLine = beginLine;
249 t.endLine = endLine;
250 t.beginColumn = beginColumn;
251 t.endColumn = endColumn;
252
253 return t;
254 }
255
256 int curLexState = 0;
257 int defaultLexState = 0;
258 int jjnewStateCnt;
259 int jjround;
260 int jjmatchedPos;
261 int jjmatchedKind;
262
263
264 public Token getNextToken()
265 {
266 Token matchedToken;
267 int curPos = 0;
268
269 EOFLoop :
270 for (;;)
271 {
272 try
273 {
274 curChar = input_stream.BeginToken();
275 }
276 catch(java.io.IOException e)
277 {
278 jjmatchedKind = 0;
279 matchedToken = jjFillToken();
280 return matchedToken;
281 }
282
283 jjmatchedKind = 0x7fffffff;
284 jjmatchedPos = 0;
285 curPos = jjMoveStringLiteralDfa0_0();
286 if (jjmatchedKind != 0x7fffffff)
287 {
288 if (jjmatchedPos + 1 < curPos)
289 input_stream.backup(curPos - jjmatchedPos - 1);
290 matchedToken = jjFillToken();
291 return matchedToken;
292 }
293 int error_line = input_stream.getEndLine();
294 int error_column = input_stream.getEndColumn();
295 String error_after = null;
296 boolean EOFSeen = false;
297 try { input_stream.readChar(); input_stream.backup(1); }
298 catch (java.io.IOException e1) {
299 EOFSeen = true;
300 error_after = curPos <= 1 ? "" : input_stream.GetImage();
301 if (curChar == '\n' || curChar == '\r') {
302 error_line++;
303 error_column = 0;
304 }
305 else
306 error_column++;
307 }
308 if (!EOFSeen) {
309 input_stream.backup(1);
310 error_after = curPos <= 1 ? "" : input_stream.GetImage();
311 }
312 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
313 }
314 }
315
316 private void jjCheckNAdd(int state)
317 {
318 if (jjrounds[state] != jjround)
319 {
320 jjstateSet[jjnewStateCnt++] = state;
321 jjrounds[state] = jjround;
322 }
323 }
324 private void jjAddStates(int start, int end)
325 {
326 do {
327 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
328 } while (start++ != end);
329 }
330 private void jjCheckNAddTwoStates(int state1, int state2)
331 {
332 jjCheckNAdd(state1);
333 jjCheckNAdd(state2);
334 }
335
336 }