| 1 | /* Generated By:JavaCC: Do not edit this line. VersionParserTokenManager.java */ |
| 2 | /* |
| 3 | * jDTAUS Core RI Client Container |
| 4 | * Copyright (C) 2005 Christian Schulte |
| 5 | * <cs@schulte.it> |
| 6 | * |
| 7 | * This library is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU Lesser General Public |
| 9 | * License as published by the Free Software Foundation; either |
| 10 | * version 2.1 of the License, or any later version. |
| 11 | * |
| 12 | * This library 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 library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | * |
| 21 | * $JDTAUS: VersionParser.jj 8641 2012-09-27 06:45:17Z schulte $ |
| 22 | * |
| 23 | */ |
| 24 | package org.jdtaus.core.container.ri.client.versioning; |
| 25 | import java.io.StringReader; |
| 26 | import java.util.List; |
| 27 | import java.util.LinkedList; |
| 28 | import java.util.Locale; |
| 29 | import java.text.NumberFormat; |
| 30 | |
| 31 | /** Token Manager. */ |
| 32 | public class VersionParserTokenManager implements VersionParserConstants |
| 33 | { |
| 34 | |
| 35 | /** Debug output. */ |
| 36 | public java.io.PrintStream debugStream = System.out; |
| 37 | /** Set debug output. */ |
| 38 | public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } |
| 39 | private int jjMoveStringLiteralDfa0_0() |
| 40 | { |
| 41 | return jjMoveNfa_0(1, 0); |
| 42 | } |
| 43 | static final long[] jjbitVec0 = { |
| 44 | 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
| 45 | }; |
| 46 | private int jjMoveNfa_0(int startState, int curPos) |
| 47 | { |
| 48 | int startsAt = 0; |
| 49 | jjnewStateCnt = 3; |
| 50 | int i = 1; |
| 51 | jjstateSet[0] = startState; |
| 52 | int kind = 0x7fffffff; |
| 53 | for (;;) |
| 54 | { |
| 55 | if (++jjround == 0x7fffffff) |
| 56 | ReInitRounds(); |
| 57 | if (curChar < 64) |
| 58 | { |
| 59 | long l = 1L << curChar; |
| 60 | do |
| 61 | { |
| 62 | switch(jjstateSet[--i]) |
| 63 | { |
| 64 | case 1: |
| 65 | if ((0xfc001f7affffc8ffL & l) != 0L) |
| 66 | { |
| 67 | if (kind > 3) |
| 68 | kind = 3; |
| 69 | jjCheckNAdd(2); |
| 70 | } |
| 71 | else if ((0xe08500003700L & l) != 0L) |
| 72 | { |
| 73 | if (kind > 2) |
| 74 | kind = 2; |
| 75 | } |
| 76 | else if ((0x3ff000000000000L & l) != 0L) |
| 77 | { |
| 78 | if (kind > 1) |
| 79 | kind = 1; |
| 80 | jjCheckNAdd(0); |
| 81 | } |
| 82 | break; |
| 83 | case 0: |
| 84 | if ((0x3ff000000000000L & l) == 0L) |
| 85 | break; |
| 86 | kind = 1; |
| 87 | jjCheckNAdd(0); |
| 88 | break; |
| 89 | case 2: |
| 90 | if ((0xfc001f7affffc8ffL & l) == 0L) |
| 91 | break; |
| 92 | kind = 3; |
| 93 | jjCheckNAdd(2); |
| 94 | break; |
| 95 | default : break; |
| 96 | } |
| 97 | } while(i != startsAt); |
| 98 | } |
| 99 | 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 | } |
| 162 | static final int[] jjnextStates = { |
| 163 | }; |
| 164 | |
| 165 | /** Token literal values. */ |
| 166 | public static final String[] jjstrLiteralImages = { |
| 167 | "", null, null, null, }; |
| 168 | |
| 169 | /** Lexer state names. */ |
| 170 | public static final String[] lexStateNames = { |
| 171 | "DEFAULT", |
| 172 | }; |
| 173 | protected SimpleCharStream input_stream; |
| 174 | private final int[] jjrounds = new int[3]; |
| 175 | private final int[] jjstateSet = new int[6]; |
| 176 | protected char curChar; |
| 177 | /** Constructor. */ |
| 178 | public 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. */ |
| 185 | public VersionParserTokenManager(SimpleCharStream stream, int lexState){ |
| 186 | this(stream); |
| 187 | SwitchTo(lexState); |
| 188 | } |
| 189 | |
| 190 | /** Reinitialise parser. */ |
| 191 | public void ReInit(SimpleCharStream stream) |
| 192 | { |
| 193 | jjmatchedPos = jjnewStateCnt = 0; |
| 194 | curLexState = defaultLexState; |
| 195 | input_stream = stream; |
| 196 | ReInitRounds(); |
| 197 | } |
| 198 | private void ReInitRounds() |
| 199 | { |
| 200 | int i; |
| 201 | jjround = 0x80000001; |
| 202 | for (i = 3; i-- > 0;) |
| 203 | jjrounds[i] = 0x80000000; |
| 204 | } |
| 205 | |
| 206 | /** Reinitialise parser. */ |
| 207 | public void ReInit(SimpleCharStream stream, int lexState) |
| 208 | { |
| 209 | ReInit(stream); |
| 210 | SwitchTo(lexState); |
| 211 | } |
| 212 | |
| 213 | /** Switch to specified lex state. */ |
| 214 | public 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 | |
| 222 | protected 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 | |
| 246 | int curLexState = 0; |
| 247 | int defaultLexState = 0; |
| 248 | int jjnewStateCnt; |
| 249 | int jjround; |
| 250 | int jjmatchedPos; |
| 251 | int jjmatchedKind; |
| 252 | |
| 253 | /** Get the next Token. */ |
| 254 | public 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 | |
| 306 | private void jjCheckNAdd(int state) |
| 307 | { |
| 308 | if (jjrounds[state] != jjround) |
| 309 | { |
| 310 | jjstateSet[jjnewStateCnt++] = state; |
| 311 | jjrounds[state] = jjround; |
| 312 | } |
| 313 | } |
| 314 | private void jjAddStates(int start, int end) |
| 315 | { |
| 316 | do { |
| 317 | jjstateSet[jjnewStateCnt++] = jjnextStates[start]; |
| 318 | } while (start++ != end); |
| 319 | } |
| 320 | private void jjCheckNAddTwoStates(int state1, int state2) |
| 321 | { |
| 322 | jjCheckNAdd(state1); |
| 323 | jjCheckNAdd(state2); |
| 324 | } |
| 325 | |
| 326 | } |