001    /* Generated By:JavaCC: Do not edit this line. VersionParserTokenManager.java */
002    /*
003     *   Copyright (c) 2009 The JOMC Project
004     *   Copyright (c) 2005 Christian Schulte <cs@jomc.org>
005     *   All rights reserved.
006     *
007     *   Redistribution and use in source and binary forms, with or without
008     *   modification, are permitted provided that the following conditions
009     *   are met:
010     *
011     *     o Redistributions of source code must retain the above copyright
012     *       notice, this list of conditions and the following disclaimer.
013     *
014     *     o Redistributions in binary form must reproduce the above copyright
015     *       notice, this list of conditions and the following disclaimer in
016     *       the documentation and/or other materials provided with the
017     *       distribution.
018     *
019     *   THIS SOFTWARE IS PROVIDED BY THE JOMC PROJECT AND CONTRIBUTORS "AS IS"
020     *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
021     *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
022     *   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE JOMC PROJECT OR
023     *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
024     *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
025     *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
026     *   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
027     *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
028     *   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
029     *   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
030     *
031     *   $Id: VersionParser.jj 733 2009-10-05 17:22:57Z schulte2005 $
032     *
033     */
034    package org.jomc.util;
035    import java.io.StringReader;
036    import java.util.List;
037    import java.util.LinkedList;
038    import java.util.Locale;
039    import java.text.NumberFormat;
040    
041    /** Token Manager. */
042    public class VersionParserTokenManager implements VersionParserConstants
043    {
044    
045      /** Debug output. */
046      public  java.io.PrintStream debugStream = System.out;
047      /** Set debug output. */
048      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
049    private int jjMoveStringLiteralDfa0_0()
050    {
051       return jjMoveNfa_0(1, 0);
052    }
053    static final long[] jjbitVec0 = {
054       0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
055    };
056    private int jjMoveNfa_0(int startState, int curPos)
057    {
058       int startsAt = 0;
059       jjnewStateCnt = 3;
060       int i = 1;
061       jjstateSet[0] = startState;
062       int kind = 0x7fffffff;
063       for (;;)
064       {
065          if (++jjround == 0x7fffffff)
066             ReInitRounds();
067          if (curChar < 64)
068          {
069             long l = 1L << curChar;
070             do
071             {
072                switch(jjstateSet[--i])
073                {
074                   case 1:
075                      if ((0xfc001f7affffc8ffL & l) != 0L)
076                      {
077                         if (kind > 3)
078                            kind = 3;
079                         jjCheckNAdd(2);
080                      }
081                      else if ((0xe08500003700L & l) != 0L)
082                      {
083                         if (kind > 2)
084                            kind = 2;
085                      }
086                      else if ((0x3ff000000000000L & l) != 0L)
087                      {
088                         if (kind > 1)
089                            kind = 1;
090                         jjCheckNAdd(0);
091                      }
092                      break;
093                   case 0:
094                      if ((0x3ff000000000000L & l) == 0L)
095                         break;
096                      kind = 1;
097                      jjCheckNAdd(0);
098                      break;
099                   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    /** Token literal values. */
176    public static final String[] jjstrLiteralImages = {
177    "", null, null, null, };
178    
179    /** Lexer state names. */
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    /** Constructor. */
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    /** Constructor. */
195    public VersionParserTokenManager(SimpleCharStream stream, int lexState){
196       this(stream);
197       SwitchTo(lexState);
198    }
199    
200    /** Reinitialise parser. */
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    /** Reinitialise parser. */
217    public void ReInit(SimpleCharStream stream, int lexState)
218    {
219       ReInit(stream);
220       SwitchTo(lexState);
221    }
222    
223    /** Switch to specified lex state. */
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    /** Get the next Token. */
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    }