KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > annotation > factory > ast > AnnotationParserTokenManager


1 /*
2   * JBoss, Home of Professional Open Source
3   * Copyright 2005, JBoss Inc., and individual contributors as indicated
4   * by the @authors tag. See the copyright.txt in the distribution for a
5   * full listing of individual contributors.
6   *
7   * This is free software; you can redistribute it and/or modify it
8   * under the terms of the GNU Lesser General Public License as
9   * published by the Free Software Foundation; either version 2.1 of
10   * the License, or (at your option) any later version.
11   *
12   * This software is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * Lesser General Public License for more details.
16   *
17   * You should have received a copy of the GNU Lesser General Public
18   * License along with this software; if not, write to the Free
19   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21   */

22 package org.jboss.annotation.factory.ast;
23
24 public class AnnotationParserTokenManager implements AnnotationParserConstants
25 {
26   public java.io.PrintStream JavaDoc debugStream = System.out;
27   public void setDebugStream(java.io.PrintStream JavaDoc ds) { debugStream = ds; }
28 private final int jjStopStringLiteralDfa_0(int pos, long active0)
29 {
30    switch (pos)
31    {
32       default :
33          return -1;
34    }
35 }
36 private final int jjStartNfa_0(int pos, long active0)
37 {
38    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
39 }
40 private final int jjStopAtPos(int pos, int kind)
41 {
42    jjmatchedKind = kind;
43    jjmatchedPos = pos;
44    return pos + 1;
45 }
46 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
47 {
48    jjmatchedKind = kind;
49    jjmatchedPos = pos;
50    try { curChar = input_stream.readChar(); }
51    catch(java.io.IOException JavaDoc e) { return pos + 1; }
52    return jjMoveNfa_0(state, pos + 1);
53 }
54 private final int jjMoveStringLiteralDfa0_0()
55 {
56    switch(curChar)
57    {
58       case 10:
59          return jjStopAtPos(0, 8);
60       case 13:
61          return jjMoveStringLiteralDfa1_0(0x80L);
62       case 40:
63          return jjStopAtPos(0, 10);
64       case 41:
65          return jjStopAtPos(0, 11);
66       case 44:
67          return jjStopAtPos(0, 12);
68       case 61:
69          return jjStopAtPos(0, 13);
70       case 64:
71          return jjStopAtPos(0, 9);
72       case 123:
73          return jjStopAtPos(0, 14);
74       case 125:
75          return jjStopAtPos(0, 15);
76       default :
77          return jjMoveNfa_0(1, 0);
78    }
79 }
80 private final int jjMoveStringLiteralDfa1_0(long active0)
81 {
82    try { curChar = input_stream.readChar(); }
83    catch(java.io.IOException JavaDoc e) {
84       jjStopStringLiteralDfa_0(0, active0);
85       return 1;
86    }
87    switch(curChar)
88    {
89       case 10:
90          if ((active0 & 0x80L) != 0L)
91             return jjStopAtPos(1, 7);
92          break;
93       default :
94          break;
95    }
96    return jjStartNfa_0(0, active0);
97 }
98 private final void jjCheckNAdd(int state)
99 {
100    if (jjrounds[state] != jjround)
101    {
102       jjstateSet[jjnewStateCnt++] = state;
103       jjrounds[state] = jjround;
104    }
105 }
106 private final void jjAddStates(int start, int end)
107 {
108    do {
109       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
110    } while (start++ != end);
111 }
112 private final void jjCheckNAddTwoStates(int state1, int state2)
113 {
114    jjCheckNAdd(state1);
115    jjCheckNAdd(state2);
116 }
117 private final void jjCheckNAddStates(int start, int end)
118 {
119    do {
120       jjCheckNAdd(jjnextStates[start]);
121    } while (start++ != end);
122 }
123 private final void jjCheckNAddStates(int start)
124 {
125    jjCheckNAdd(jjnextStates[start]);
126    jjCheckNAdd(jjnextStates[start + 1]);
127 }
128 static final long[] jjbitVec0 = {
129    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
130 };
131 private final int jjMoveNfa_0(int startState, int curPos)
132 {
133    int[] nextStates;
134    int startsAt = 0;
135    jjnewStateCnt = 27;
136    int i = 1;
137    jjstateSet[0] = startState;
138    int j, kind = 0x7fffffff;
139    for (;;)
140    {
141       if (++jjround == 0x7fffffff)
142          ReInitRounds();
143       if (curChar < 64)
144       {
145          long l = 1L << curChar;
146          MatchLoop: do
147          {
148             switch(jjstateSet[--i])
149             {
150                case 1:
151                   if ((0x3ff401000000000L & l) != 0L)
152                   {
153                      if (kind > 3)
154                         kind = 3;
155                      jjCheckNAdd(0);
156                   }
157                   else if (curChar == 34)
158                      jjCheckNAddStates(0, 2);
159                   else if (curChar == 39)
160                      jjAddStates(3, 4);
161                   break;
162                case 0:
163                   if ((0x3ff401000000000L & l) == 0L)
164                      break;
165                   if (kind > 3)
166                      kind = 3;
167                   jjCheckNAdd(0);
168                   break;
169                case 2:
170                   if ((0xffffff7fffffdbffL & l) != 0L)
171                      jjCheckNAdd(3);
172                   break;
173                case 3:
174                   if (curChar == 39 && kind > 5)
175                      kind = 5;
176                   break;
177                case 5:
178                   if ((0x8000008400000000L & l) != 0L)
179                      jjCheckNAdd(3);
180                   break;
181                case 6:
182                   if (curChar == 48)
183                      jjCheckNAddTwoStates(7, 3);
184                   break;
185                case 7:
186                   if ((0xff000000000000L & l) != 0L)
187                      jjCheckNAddTwoStates(7, 3);
188                   break;
189                case 8:
190                   if ((0x3fe000000000000L & l) != 0L)
191                      jjCheckNAddTwoStates(9, 3);
192                   break;
193                case 9:
194                   if ((0x3ff000000000000L & l) != 0L)
195                      jjCheckNAddTwoStates(9, 3);
196                   break;
197                case 10:
198                   if (curChar == 48)
199                      jjAddStates(5, 6);
200                   break;
201                case 12:
202                   if ((0x3ff000000000000L & l) != 0L)
203                      jjCheckNAddTwoStates(12, 3);
204                   break;
205                case 14:
206                   if (curChar == 34)
207                      jjCheckNAddStates(0, 2);
208                   break;
209                case 15:
210                   if ((0xfffffffbffffdbffL & l) != 0L)
211                      jjCheckNAddStates(0, 2);
212                   break;
213                case 17:
214                   if ((0x8000008400000000L & l) != 0L)
215                      jjCheckNAddStates(0, 2);
216                   break;
217                case 18:
218                   if (curChar == 34 && kind > 6)
219                      kind = 6;
220                   break;
221                case 19:
222                   if (curChar == 48)
223                      jjCheckNAddStates(7, 10);
224                   break;
225                case 20:
226                   if ((0xff000000000000L & l) != 0L)
227                      jjCheckNAddStates(7, 10);
228                   break;
229                case 21:
230                   if ((0x3fe000000000000L & l) != 0L)
231                      jjCheckNAddStates(11, 14);
232                   break;
233                case 22:
234                   if ((0x3ff000000000000L & l) != 0L)
235                      jjCheckNAddStates(11, 14);
236                   break;
237                case 23:
238                   if (curChar == 48)
239                      jjAddStates(15, 16);
240                   break;
241                case 25:
242                   if ((0x3ff000000000000L & l) != 0L)
243                      jjCheckNAddStates(17, 20);
244                   break;
245                default : break;
246             }
247          } while(i != startsAt);
248       }
249       else if (curChar < 128)
250       {
251          long l = 1L << (curChar & 077);
252          MatchLoop: do
253          {
254             switch(jjstateSet[--i])
255             {
256                case 1:
257                case 0:
258                   if ((0x7fffffe87fffffeL & l) == 0L)
259                      break;
260                   if (kind > 3)
261                      kind = 3;
262                   jjCheckNAdd(0);
263                   break;
264                case 2:
265                   if ((0xffffffffefffffffL & l) != 0L)
266                      jjCheckNAdd(3);
267                   break;
268                case 4:
269                   if (curChar == 92)
270                      jjAddStates(21, 24);
271                   break;
272                case 5:
273                   if ((0x54404610000000L & l) != 0L)
274                      jjCheckNAdd(3);
275                   break;
276                case 11:
277                   if (curChar == 120)
278                      jjCheckNAdd(12);
279                   break;
280                case 12:
281                   if ((0x7e0000007eL & l) != 0L)
282                      jjCheckNAddTwoStates(12, 3);
283                   break;
284                case 13:
285                   if (curChar == 88)
286                      jjCheckNAdd(12);
287                   break;
288                case 15:
289                   if ((0xffffffffefffffffL & l) != 0L)
290                      jjCheckNAddStates(0, 2);
291                   break;
292                case 16:
293                   if (curChar == 92)
294                      jjAddStates(25, 28);
295                   break;
296                case 17:
297                   if ((0x54404610000000L & l) != 0L)
298                      jjCheckNAddStates(0, 2);
299                   break;
300                case 24:
301                   if (curChar == 120)
302                      jjCheckNAdd(25);
303                   break;
304                case 25:
305                   if ((0x7e0000007eL & l) != 0L)
306                      jjCheckNAddStates(17, 20);
307                   break;
308                case 26:
309                   if (curChar == 88)
310                      jjCheckNAdd(25);
311                   break;
312                default : break;
313             }
314          } while(i != startsAt);
315       }
316       else
317       {
318          int i2 = (curChar & 0xff) >> 6;
319          long l2 = 1L << (curChar & 077);
320          MatchLoop: do
321          {
322             switch(jjstateSet[--i])
323             {
324                case 2:
325                   if ((jjbitVec0[i2] & l2) != 0L)
326                      jjstateSet[jjnewStateCnt++] = 3;
327                   break;
328                case 15:
329                   if ((jjbitVec0[i2] & l2) != 0L)
330                      jjAddStates(0, 2);
331                   break;
332                default : break;
333             }
334          } while(i != startsAt);
335       }
336       if (kind != 0x7fffffff)
337       {
338          jjmatchedKind = kind;
339          jjmatchedPos = curPos;
340          kind = 0x7fffffff;
341       }
342       ++curPos;
343       if ((i = jjnewStateCnt) == (startsAt = 27 - (jjnewStateCnt = startsAt)))
344          return curPos;
345       try { curChar = input_stream.readChar(); }
346       catch(java.io.IOException JavaDoc e) { return curPos; }
347    }
348 }
349 static final int[] jjnextStates = {
350    15, 16, 18, 2, 4, 11, 13, 15, 16, 20, 18, 15, 16, 22, 18, 24,
351    26, 15, 16, 25, 18, 5, 6, 8, 10, 17, 19, 21, 23,
352 };
353 public static final String JavaDoc[] jjstrLiteralImages = {
354 "", null, null, null, null, null, null, "\15\12", "\12", "\100", "\50", "\51",
355 "\54", "\75", "\173", "\175", };
356 public static final String JavaDoc[] lexStateNames = {
357    "DEFAULT",
358 };
359 static final long[] jjtoToken = {
360    0xffe9L,
361 };
362 static final long[] jjtoSkip = {
363    0x6L,
364 };
365 protected SimpleCharStream input_stream;
366 private final int[] jjrounds = new int[27];
367 private final int[] jjstateSet = new int[54];
368 protected char curChar;
369 public AnnotationParserTokenManager(SimpleCharStream stream)
370 {
371    if (SimpleCharStream.staticFlag)
372       throw new Error JavaDoc("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
373    input_stream = stream;
374 }
375 public AnnotationParserTokenManager(SimpleCharStream stream, int lexState)
376 {
377    this(stream);
378    SwitchTo(lexState);
379 }
380 public void ReInit(SimpleCharStream stream)
381 {
382    jjmatchedPos = jjnewStateCnt = 0;
383    curLexState = defaultLexState;
384    input_stream = stream;
385    ReInitRounds();
386 }
387 private final void ReInitRounds()
388 {
389    int i;
390    jjround = 0x80000001;
391    for (i = 27; i-- > 0;)
392       jjrounds[i] = 0x80000000;
393 }
394 public void ReInit(SimpleCharStream stream, int lexState)
395 {
396    ReInit(stream);
397    SwitchTo(lexState);
398 }
399 public void SwitchTo(int lexState)
400 {
401    if (lexState >= 1 || lexState < 0)
402       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
403    else
404       curLexState = lexState;
405 }
406
407 protected Token jjFillToken()
408 {
409    Token t = Token.newToken(jjmatchedKind);
410    t.kind = jjmatchedKind;
411    String JavaDoc im = jjstrLiteralImages[jjmatchedKind];
412    t.image = (im == null) ? input_stream.GetImage() : im;
413    t.beginLine = input_stream.getBeginLine();
414    t.beginColumn = input_stream.getBeginColumn();
415    t.endLine = input_stream.getEndLine();
416    t.endColumn = input_stream.getEndColumn();
417    return t;
418 }
419
420 int curLexState = 0;
421 int defaultLexState = 0;
422 int jjnewStateCnt;
423 int jjround;
424 int jjmatchedPos;
425 int jjmatchedKind;
426
427 public Token getNextToken()
428 {
429   int kind;
430   Token specialToken = null;
431   Token matchedToken;
432   int curPos = 0;
433
434   EOFLoop :
435   for (;;)
436   {
437    try
438    {
439       curChar = input_stream.BeginToken();
440    }
441    catch(java.io.IOException JavaDoc e)
442    {
443       jjmatchedKind = 0;
444       matchedToken = jjFillToken();
445       return matchedToken;
446    }
447
448    try { input_stream.backup(0);
449       while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
450          curChar = input_stream.BeginToken();
451    }
452    catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
453    jjmatchedKind = 0x7fffffff;
454    jjmatchedPos = 0;
455    curPos = jjMoveStringLiteralDfa0_0();
456    if (jjmatchedKind != 0x7fffffff)
457    {
458       if (jjmatchedPos + 1 < curPos)
459          input_stream.backup(curPos - jjmatchedPos - 1);
460       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
461       {
462          matchedToken = jjFillToken();
463          return matchedToken;
464       }
465       else
466       {
467          continue EOFLoop;
468       }
469    }
470    int error_line = input_stream.getEndLine();
471    int error_column = input_stream.getEndColumn();
472    String JavaDoc error_after = null;
473    boolean EOFSeen = false;
474    try { input_stream.readChar(); input_stream.backup(1); }
475    catch (java.io.IOException JavaDoc e1) {
476       EOFSeen = true;
477       error_after = curPos <= 1 ? "" : input_stream.GetImage();
478       if (curChar == '\n' || curChar == '\r') {
479          error_line++;
480          error_column = 0;
481       }
482       else
483          error_column++;
484    }
485    if (!EOFSeen) {
486       input_stream.backup(1);
487       error_after = curPos <= 1 ? "" : input_stream.GetImage();
488    }
489    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
490   }
491 }
492
493 }
494
Popular Tags