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