001/* Generated By:JavaCC: Do not edit this line. VersionParserTokenManager.java */
002/*
003 *  jDTAUS Core RI Client Container
004 *  Copyright (C) 2005 Christian Schulte
005 *  <cs@schulte.it>
006 *
007 *  This library is free software; you can redistribute it and/or
008 *  modify it under the terms of the GNU Lesser General Public
009 *  License as published by the Free Software Foundation; either
010 *  version 2.1 of the License, or any later version.
011 *
012 *  This library is distributed in the hope that it will be useful,
013 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
014 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
015 *  Lesser General Public License for more details.
016 *
017 *  You should have received a copy of the GNU Lesser General Public
018 *  License along with this library; if not, write to the Free Software
019 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
020 *
021 *  $JDTAUS: VersionParser.jj 8641 2012-09-27 06:45:17Z schulte $
022 *
023 */
024package org.jdtaus.core.container.ri.client.versioning;
025import java.io.StringReader;
026import java.util.List;
027import java.util.LinkedList;
028import java.util.Locale;
029import java.text.NumberFormat;
030
031/** Token Manager. */
032public class VersionParserTokenManager implements VersionParserConstants
033{
034
035  /** Debug output. */
036  public  java.io.PrintStream debugStream = System.out;
037  /** Set debug output. */
038  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
039private int jjMoveStringLiteralDfa0_0()
040{
041   return jjMoveNfa_0(1, 0);
042}
043static final long[] jjbitVec0 = {
044   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
045};
046private int jjMoveNfa_0(int startState, int curPos)
047{
048   int startsAt = 0;
049   jjnewStateCnt = 3;
050   int i = 1;
051   jjstateSet[0] = startState;
052   int kind = 0x7fffffff;
053   for (;;)
054   {
055      if (++jjround == 0x7fffffff)
056         ReInitRounds();
057      if (curChar < 64)
058      {
059         long l = 1L << curChar;
060         do
061         {
062            switch(jjstateSet[--i])
063            {
064               case 1:
065                  if ((0xfc001f7affffc8ffL & l) != 0L)
066                  {
067                     if (kind > 3)
068                        kind = 3;
069                     jjCheckNAdd(2);
070                  }
071                  else if ((0xe08500003700L & l) != 0L)
072                  {
073                     if (kind > 2)
074                        kind = 2;
075                  }
076                  else if ((0x3ff000000000000L & l) != 0L)
077                  {
078                     if (kind > 1)
079                        kind = 1;
080                     jjCheckNAdd(0);
081                  }
082                  break;
083               case 0:
084                  if ((0x3ff000000000000L & l) == 0L)
085                     break;
086                  kind = 1;
087                  jjCheckNAdd(0);
088                  break;
089               case 2:
090                  if ((0xfc001f7affffc8ffL & l) == 0L)
091                     break;
092                  kind = 3;
093                  jjCheckNAdd(2);
094                  break;
095               default : break;
096            }
097         } while(i != startsAt);
098      }
099      else if (curChar < 128)
100      {
101         long l = 1L << (curChar & 077);
102         do
103         {
104            switch(jjstateSet[--i])
105            {
106               case 1:
107                  if ((0xffffffff6ffffffeL & l) != 0L)
108                  {
109                     if (kind > 3)
110                        kind = 3;
111                     jjCheckNAdd(2);
112                  }
113                  else if ((0x90000001L & l) != 0L)
114                  {
115                     if (kind > 2)
116                        kind = 2;
117                  }
118                  break;
119               case 2:
120                  if ((0xffffffff6ffffffeL & l) == 0L)
121                     break;
122                  kind = 3;
123                  jjCheckNAdd(2);
124                  break;
125               default : break;
126            }
127         } while(i != startsAt);
128      }
129      else
130      {
131         int i2 = (curChar & 0xff) >> 6;
132         long l2 = 1L << (curChar & 077);
133         do
134         {
135            switch(jjstateSet[--i])
136            {
137               case 1:
138               case 2:
139                  if ((jjbitVec0[i2] & l2) == 0L)
140                     break;
141                  if (kind > 3)
142                     kind = 3;
143                  jjCheckNAdd(2);
144                  break;
145               default : break;
146            }
147         } while(i != startsAt);
148      }
149      if (kind != 0x7fffffff)
150      {
151         jjmatchedKind = kind;
152         jjmatchedPos = curPos;
153         kind = 0x7fffffff;
154      }
155      ++curPos;
156      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
157         return curPos;
158      try { curChar = input_stream.readChar(); }
159      catch(java.io.IOException e) { return curPos; }
160   }
161}
162static final int[] jjnextStates = {
163};
164
165/** Token literal values. */
166public static final String[] jjstrLiteralImages = {
167"", null, null, null, };
168
169/** Lexer state names. */
170public static final String[] lexStateNames = {
171   "DEFAULT",
172};
173protected SimpleCharStream input_stream;
174private final int[] jjrounds = new int[3];
175private final int[] jjstateSet = new int[6];
176protected char curChar;
177/** Constructor. */
178public VersionParserTokenManager(SimpleCharStream stream){
179   if (SimpleCharStream.staticFlag)
180      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
181   input_stream = stream;
182}
183
184/** Constructor. */
185public VersionParserTokenManager(SimpleCharStream stream, int lexState){
186   this(stream);
187   SwitchTo(lexState);
188}
189
190/** Reinitialise parser. */
191public void ReInit(SimpleCharStream stream)
192{
193   jjmatchedPos = jjnewStateCnt = 0;
194   curLexState = defaultLexState;
195   input_stream = stream;
196   ReInitRounds();
197}
198private void ReInitRounds()
199{
200   int i;
201   jjround = 0x80000001;
202   for (i = 3; i-- > 0;)
203      jjrounds[i] = 0x80000000;
204}
205
206/** Reinitialise parser. */
207public void ReInit(SimpleCharStream stream, int lexState)
208{
209   ReInit(stream);
210   SwitchTo(lexState);
211}
212
213/** Switch to specified lex state. */
214public void SwitchTo(int lexState)
215{
216   if (lexState >= 1 || lexState < 0)
217      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
218   else
219      curLexState = lexState;
220}
221
222protected Token jjFillToken()
223{
224   final Token t;
225   final String curTokenImage;
226   final int beginLine;
227   final int endLine;
228   final int beginColumn;
229   final int endColumn;
230   String im = jjstrLiteralImages[jjmatchedKind];
231   curTokenImage = (im == null) ? input_stream.GetImage() : im;
232   beginLine = input_stream.getBeginLine();
233   beginColumn = input_stream.getBeginColumn();
234   endLine = input_stream.getEndLine();
235   endColumn = input_stream.getEndColumn();
236   t = Token.newToken(jjmatchedKind, curTokenImage);
237
238   t.beginLine = beginLine;
239   t.endLine = endLine;
240   t.beginColumn = beginColumn;
241   t.endColumn = endColumn;
242
243   return t;
244}
245
246int curLexState = 0;
247int defaultLexState = 0;
248int jjnewStateCnt;
249int jjround;
250int jjmatchedPos;
251int jjmatchedKind;
252
253/** Get the next Token. */
254public Token getNextToken() 
255{
256  Token matchedToken;
257  int curPos = 0;
258
259  EOFLoop :
260  for (;;)
261  {
262   try
263   {
264      curChar = input_stream.BeginToken();
265   }
266   catch(java.io.IOException e)
267   {
268      jjmatchedKind = 0;
269      matchedToken = jjFillToken();
270      return matchedToken;
271   }
272
273   jjmatchedKind = 0x7fffffff;
274   jjmatchedPos = 0;
275   curPos = jjMoveStringLiteralDfa0_0();
276   if (jjmatchedKind != 0x7fffffff)
277   {
278      if (jjmatchedPos + 1 < curPos)
279         input_stream.backup(curPos - jjmatchedPos - 1);
280         matchedToken = jjFillToken();
281         return matchedToken;
282   }
283   int error_line = input_stream.getEndLine();
284   int error_column = input_stream.getEndColumn();
285   String error_after = null;
286   boolean EOFSeen = false;
287   try { input_stream.readChar(); input_stream.backup(1); }
288   catch (java.io.IOException e1) {
289      EOFSeen = true;
290      error_after = curPos <= 1 ? "" : input_stream.GetImage();
291      if (curChar == '\n' || curChar == '\r') {
292         error_line++;
293         error_column = 0;
294      }
295      else
296         error_column++;
297   }
298   if (!EOFSeen) {
299      input_stream.backup(1);
300      error_after = curPos <= 1 ? "" : input_stream.GetImage();
301   }
302   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
303  }
304}
305
306private void jjCheckNAdd(int state)
307{
308   if (jjrounds[state] != jjround)
309   {
310      jjstateSet[jjnewStateCnt++] = state;
311      jjrounds[state] = jjround;
312   }
313}
314private void jjAddStates(int start, int end)
315{
316   do {
317      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
318   } while (start++ != end);
319}
320private void jjCheckNAddTwoStates(int state1, int state2)
321{
322   jjCheckNAdd(state1);
323   jjCheckNAdd(state2);
324}
325
326}