0001: /*
0002: * This file is part of the GeOxygene project source files.
0003: *
0004: * GeOxygene aims at providing an open framework which implements OGC/ISO specifications for
0005: * the development and deployment of geographic (GIS) applications. It is a open source
0006: * contribution of the COGIT laboratory at the Institut Géographique National (the French
0007: * National Mapping Agency).
0008: *
0009: * See: http://oxygene-project.sourceforge.net
0010: *
0011: * Copyright (C) 2005 Institut Géographique National
0012: *
0013: * This library is free software; you can redistribute it and/or modify it under the terms
0014: * of the GNU Lesser General Public License as published by the Free Software Foundation;
0015: * either version 2.1 of the License, or any later version.
0016: *
0017: * This library is distributed in the hope that it will be useful, but WITHOUT ANY
0018: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0019: * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
0020: *
0021: * You should have received a copy of the GNU Lesser General Public License along with
0022: * this library (see file LICENSE if present); if not, write to the Free Software
0023: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0024: *
0025: */
0026:
0027: /* Generated By:JavaCC: Do not edit this line. WktGeOxygeneTokenManager.java */
0028: package fr.ign.cogit.geoxygene.util.conversion;
0029:
0030: public class WktGeOxygeneTokenManager implements WktGeOxygeneConstants {
0031: public java.io.PrintStream debugStream = System.out;
0032:
0033: public void setDebugStream(java.io.PrintStream ds) {
0034: debugStream = ds;
0035: }
0036:
0037: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
0038: switch (pos) {
0039: default:
0040: return -1;
0041: }
0042: }
0043:
0044: private final int jjStartNfa_0(int pos, long active0) {
0045: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0046: pos + 1);
0047: }
0048:
0049: private final int jjStopAtPos(int pos, int kind) {
0050: jjmatchedKind = kind;
0051: jjmatchedPos = pos;
0052: return pos + 1;
0053: }
0054:
0055: private final int jjStartNfaWithStates_0(int pos, int kind,
0056: int state) {
0057: jjmatchedKind = kind;
0058: jjmatchedPos = pos;
0059: try {
0060: curChar = input_stream.readChar();
0061: } catch (java.io.IOException e) {
0062: return pos + 1;
0063: }
0064: return jjMoveNfa_0(state, pos + 1);
0065: }
0066:
0067: private final int jjMoveStringLiteralDfa0_0() {
0068: switch (curChar) {
0069: case 10:
0070: return jjStopAtPos(0, 6);
0071: case 40:
0072: return jjStopAtPos(0, 9);
0073: case 41:
0074: return jjStopAtPos(0, 10);
0075: case 44:
0076: return jjStopAtPos(0, 12);
0077: case 69:
0078: return jjMoveStringLiteralDfa1_0(0x800L);
0079: case 71:
0080: return jjMoveStringLiteralDfa1_0(0x80000L);
0081: case 76:
0082: return jjMoveStringLiteralDfa1_0(0x8000L);
0083: case 77:
0084: return jjMoveStringLiteralDfa1_0(0x54000L);
0085: case 80:
0086: return jjMoveStringLiteralDfa1_0(0x22000L);
0087: default:
0088: return jjMoveNfa_0(0, 0);
0089: }
0090: }
0091:
0092: private final int jjMoveStringLiteralDfa1_0(long active0) {
0093: try {
0094: curChar = input_stream.readChar();
0095: } catch (java.io.IOException e) {
0096: jjStopStringLiteralDfa_0(0, active0);
0097: return 1;
0098: }
0099: switch (curChar) {
0100: case 69:
0101: return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
0102: case 73:
0103: return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
0104: case 77:
0105: return jjMoveStringLiteralDfa2_0(active0, 0x800L);
0106: case 79:
0107: return jjMoveStringLiteralDfa2_0(active0, 0x22000L);
0108: case 85:
0109: return jjMoveStringLiteralDfa2_0(active0, 0x54000L);
0110: default:
0111: break;
0112: }
0113: return jjStartNfa_0(0, active0);
0114: }
0115:
0116: private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
0117: if (((active0 &= old0)) == 0L)
0118: return jjStartNfa_0(0, old0);
0119: try {
0120: curChar = input_stream.readChar();
0121: } catch (java.io.IOException e) {
0122: jjStopStringLiteralDfa_0(1, active0);
0123: return 2;
0124: }
0125: switch (curChar) {
0126: case 73:
0127: return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
0128: case 76:
0129: return jjMoveStringLiteralDfa3_0(active0, 0x74000L);
0130: case 78:
0131: return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
0132: case 79:
0133: return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
0134: case 80:
0135: return jjMoveStringLiteralDfa3_0(active0, 0x800L);
0136: default:
0137: break;
0138: }
0139: return jjStartNfa_0(1, active0);
0140: }
0141:
0142: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0143: if (((active0 &= old0)) == 0L)
0144: return jjStartNfa_0(1, old0);
0145: try {
0146: curChar = input_stream.readChar();
0147: } catch (java.io.IOException e) {
0148: jjStopStringLiteralDfa_0(2, active0);
0149: return 3;
0150: }
0151: switch (curChar) {
0152: case 69:
0153: return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
0154: case 77:
0155: return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
0156: case 78:
0157: return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
0158: case 84:
0159: return jjMoveStringLiteralDfa4_0(active0, 0x54800L);
0160: case 89:
0161: return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
0162: default:
0163: break;
0164: }
0165: return jjStartNfa_0(2, active0);
0166: }
0167:
0168: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0169: if (((active0 &= old0)) == 0L)
0170: return jjStartNfa_0(2, old0);
0171: try {
0172: curChar = input_stream.readChar();
0173: } catch (java.io.IOException e) {
0174: jjStopStringLiteralDfa_0(3, active0);
0175: return 4;
0176: }
0177: switch (curChar) {
0178: case 69:
0179: return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
0180: case 71:
0181: return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
0182: case 73:
0183: return jjMoveStringLiteralDfa5_0(active0, 0x54000L);
0184: case 83:
0185: return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
0186: case 84:
0187: if ((active0 & 0x2000L) != 0L)
0188: return jjStopAtPos(4, 13);
0189: break;
0190: case 89:
0191: if ((active0 & 0x800L) != 0L)
0192: return jjStopAtPos(4, 11);
0193: break;
0194: default:
0195: break;
0196: }
0197: return jjStartNfa_0(3, active0);
0198: }
0199:
0200: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0201: if (((active0 &= old0)) == 0L)
0202: return jjStartNfa_0(3, old0);
0203: try {
0204: curChar = input_stream.readChar();
0205: } catch (java.io.IOException e) {
0206: jjStopStringLiteralDfa_0(4, active0);
0207: return 5;
0208: }
0209: switch (curChar) {
0210: case 76:
0211: return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
0212: case 79:
0213: return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
0214: case 80:
0215: return jjMoveStringLiteralDfa6_0(active0, 0x44000L);
0216: case 84:
0217: return jjMoveStringLiteralDfa6_0(active0, 0x88000L);
0218: default:
0219: break;
0220: }
0221: return jjStartNfa_0(4, active0);
0222: }
0223:
0224: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0225: if (((active0 &= old0)) == 0L)
0226: return jjStartNfa_0(4, old0);
0227: try {
0228: curChar = input_stream.readChar();
0229: } catch (java.io.IOException e) {
0230: jjStopStringLiteralDfa_0(5, active0);
0231: return 6;
0232: }
0233: switch (curChar) {
0234: case 73:
0235: return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
0236: case 78:
0237: if ((active0 & 0x20000L) != 0L)
0238: return jjStopAtPos(6, 17);
0239: break;
0240: case 79:
0241: return jjMoveStringLiteralDfa7_0(active0, 0x44000L);
0242: case 82:
0243: return jjMoveStringLiteralDfa7_0(active0, 0x88000L);
0244: default:
0245: break;
0246: }
0247: return jjStartNfa_0(5, active0);
0248: }
0249:
0250: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0251: if (((active0 &= old0)) == 0L)
0252: return jjStartNfa_0(5, old0);
0253: try {
0254: curChar = input_stream.readChar();
0255: } catch (java.io.IOException e) {
0256: jjStopStringLiteralDfa_0(6, active0);
0257: return 7;
0258: }
0259: switch (curChar) {
0260: case 73:
0261: return jjMoveStringLiteralDfa8_0(active0, 0xc000L);
0262: case 76:
0263: return jjMoveStringLiteralDfa8_0(active0, 0x40000L);
0264: case 78:
0265: return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
0266: case 89:
0267: return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
0268: default:
0269: break;
0270: }
0271: return jjStartNfa_0(6, active0);
0272: }
0273:
0274: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0275: if (((active0 &= old0)) == 0L)
0276: return jjStartNfa_0(6, old0);
0277: try {
0278: curChar = input_stream.readChar();
0279: } catch (java.io.IOException e) {
0280: jjStopStringLiteralDfa_0(7, active0);
0281: return 8;
0282: }
0283: switch (curChar) {
0284: case 67:
0285: return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
0286: case 69:
0287: return jjMoveStringLiteralDfa9_0(active0, 0x10000L);
0288: case 78:
0289: return jjMoveStringLiteralDfa9_0(active0, 0xc000L);
0290: case 89:
0291: return jjMoveStringLiteralDfa9_0(active0, 0x40000L);
0292: default:
0293: break;
0294: }
0295: return jjStartNfa_0(7, active0);
0296: }
0297:
0298: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0299: if (((active0 &= old0)) == 0L)
0300: return jjStartNfa_0(7, old0);
0301: try {
0302: curChar = input_stream.readChar();
0303: } catch (java.io.IOException e) {
0304: jjStopStringLiteralDfa_0(8, active0);
0305: return 9;
0306: }
0307: switch (curChar) {
0308: case 71:
0309: if ((active0 & 0x8000L) != 0L)
0310: return jjStopAtPos(9, 15);
0311: return jjMoveStringLiteralDfa10_0(active0, 0x40000L);
0312: case 79:
0313: return jjMoveStringLiteralDfa10_0(active0, 0x80000L);
0314: case 83:
0315: return jjMoveStringLiteralDfa10_0(active0, 0x10000L);
0316: case 84:
0317: if ((active0 & 0x4000L) != 0L)
0318: return jjStopAtPos(9, 14);
0319: break;
0320: default:
0321: break;
0322: }
0323: return jjStartNfa_0(8, active0);
0324: }
0325:
0326: private final int jjMoveStringLiteralDfa10_0(long old0, long active0) {
0327: if (((active0 &= old0)) == 0L)
0328: return jjStartNfa_0(8, old0);
0329: try {
0330: curChar = input_stream.readChar();
0331: } catch (java.io.IOException e) {
0332: jjStopStringLiteralDfa_0(9, active0);
0333: return 10;
0334: }
0335: switch (curChar) {
0336: case 76:
0337: return jjMoveStringLiteralDfa11_0(active0, 0x80000L);
0338: case 79:
0339: return jjMoveStringLiteralDfa11_0(active0, 0x40000L);
0340: case 84:
0341: return jjMoveStringLiteralDfa11_0(active0, 0x10000L);
0342: default:
0343: break;
0344: }
0345: return jjStartNfa_0(9, active0);
0346: }
0347:
0348: private final int jjMoveStringLiteralDfa11_0(long old0, long active0) {
0349: if (((active0 &= old0)) == 0L)
0350: return jjStartNfa_0(9, old0);
0351: try {
0352: curChar = input_stream.readChar();
0353: } catch (java.io.IOException e) {
0354: jjStopStringLiteralDfa_0(10, active0);
0355: return 11;
0356: }
0357: switch (curChar) {
0358: case 76:
0359: return jjMoveStringLiteralDfa12_0(active0, 0x80000L);
0360: case 78:
0361: if ((active0 & 0x40000L) != 0L)
0362: return jjStopAtPos(11, 18);
0363: break;
0364: case 82:
0365: return jjMoveStringLiteralDfa12_0(active0, 0x10000L);
0366: default:
0367: break;
0368: }
0369: return jjStartNfa_0(10, active0);
0370: }
0371:
0372: private final int jjMoveStringLiteralDfa12_0(long old0, long active0) {
0373: if (((active0 &= old0)) == 0L)
0374: return jjStartNfa_0(10, old0);
0375: try {
0376: curChar = input_stream.readChar();
0377: } catch (java.io.IOException e) {
0378: jjStopStringLiteralDfa_0(11, active0);
0379: return 12;
0380: }
0381: switch (curChar) {
0382: case 69:
0383: return jjMoveStringLiteralDfa13_0(active0, 0x80000L);
0384: case 73:
0385: return jjMoveStringLiteralDfa13_0(active0, 0x10000L);
0386: default:
0387: break;
0388: }
0389: return jjStartNfa_0(11, active0);
0390: }
0391:
0392: private final int jjMoveStringLiteralDfa13_0(long old0, long active0) {
0393: if (((active0 &= old0)) == 0L)
0394: return jjStartNfa_0(11, old0);
0395: try {
0396: curChar = input_stream.readChar();
0397: } catch (java.io.IOException e) {
0398: jjStopStringLiteralDfa_0(12, active0);
0399: return 13;
0400: }
0401: switch (curChar) {
0402: case 67:
0403: return jjMoveStringLiteralDfa14_0(active0, 0x80000L);
0404: case 78:
0405: return jjMoveStringLiteralDfa14_0(active0, 0x10000L);
0406: default:
0407: break;
0408: }
0409: return jjStartNfa_0(12, active0);
0410: }
0411:
0412: private final int jjMoveStringLiteralDfa14_0(long old0, long active0) {
0413: if (((active0 &= old0)) == 0L)
0414: return jjStartNfa_0(12, old0);
0415: try {
0416: curChar = input_stream.readChar();
0417: } catch (java.io.IOException e) {
0418: jjStopStringLiteralDfa_0(13, active0);
0419: return 14;
0420: }
0421: switch (curChar) {
0422: case 71:
0423: if ((active0 & 0x10000L) != 0L)
0424: return jjStopAtPos(14, 16);
0425: break;
0426: case 84:
0427: return jjMoveStringLiteralDfa15_0(active0, 0x80000L);
0428: default:
0429: break;
0430: }
0431: return jjStartNfa_0(13, active0);
0432: }
0433:
0434: private final int jjMoveStringLiteralDfa15_0(long old0, long active0) {
0435: if (((active0 &= old0)) == 0L)
0436: return jjStartNfa_0(13, old0);
0437: try {
0438: curChar = input_stream.readChar();
0439: } catch (java.io.IOException e) {
0440: jjStopStringLiteralDfa_0(14, active0);
0441: return 15;
0442: }
0443: switch (curChar) {
0444: case 73:
0445: return jjMoveStringLiteralDfa16_0(active0, 0x80000L);
0446: default:
0447: break;
0448: }
0449: return jjStartNfa_0(14, active0);
0450: }
0451:
0452: private final int jjMoveStringLiteralDfa16_0(long old0, long active0) {
0453: if (((active0 &= old0)) == 0L)
0454: return jjStartNfa_0(14, old0);
0455: try {
0456: curChar = input_stream.readChar();
0457: } catch (java.io.IOException e) {
0458: jjStopStringLiteralDfa_0(15, active0);
0459: return 16;
0460: }
0461: switch (curChar) {
0462: case 79:
0463: return jjMoveStringLiteralDfa17_0(active0, 0x80000L);
0464: default:
0465: break;
0466: }
0467: return jjStartNfa_0(15, active0);
0468: }
0469:
0470: private final int jjMoveStringLiteralDfa17_0(long old0, long active0) {
0471: if (((active0 &= old0)) == 0L)
0472: return jjStartNfa_0(15, old0);
0473: try {
0474: curChar = input_stream.readChar();
0475: } catch (java.io.IOException e) {
0476: jjStopStringLiteralDfa_0(16, active0);
0477: return 17;
0478: }
0479: switch (curChar) {
0480: case 78:
0481: if ((active0 & 0x80000L) != 0L)
0482: return jjStopAtPos(17, 19);
0483: break;
0484: default:
0485: break;
0486: }
0487: return jjStartNfa_0(16, active0);
0488: }
0489:
0490: private final void jjCheckNAdd(int state) {
0491: if (jjrounds[state] != jjround) {
0492: jjstateSet[jjnewStateCnt++] = state;
0493: jjrounds[state] = jjround;
0494: }
0495: }
0496:
0497: private final void jjAddStates(int start, int end) {
0498: do {
0499: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0500: } while (start++ != end);
0501: }
0502:
0503: private final void jjCheckNAddTwoStates(int state1, int state2) {
0504: jjCheckNAdd(state1);
0505: jjCheckNAdd(state2);
0506: }
0507:
0508: private final void jjCheckNAddStates(int start, int end) {
0509: do {
0510: jjCheckNAdd(jjnextStates[start]);
0511: } while (start++ != end);
0512: }
0513:
0514: private final void jjCheckNAddStates(int start) {
0515: jjCheckNAdd(jjnextStates[start]);
0516: jjCheckNAdd(jjnextStates[start + 1]);
0517: }
0518:
0519: private final int jjMoveNfa_0(int startState, int curPos) {
0520: int[] nextStates;
0521: int startsAt = 0;
0522: jjnewStateCnt = 50;
0523: int i = 1;
0524: jjstateSet[0] = startState;
0525: int j, kind = 0x7fffffff;
0526: for (;;) {
0527: if (++jjround == 0x7fffffff)
0528: ReInitRounds();
0529: if (curChar < 64) {
0530: long l = 1L << curChar;
0531: MatchLoop: do {
0532: switch (jjstateSet[--i]) {
0533: case 0:
0534: if ((0x3ff000000000000L & l) != 0L) {
0535: if (kind > 1)
0536: kind = 1;
0537: jjCheckNAddStates(0, 14);
0538: } else if ((0x280000000000L & l) != 0L)
0539: jjAddStates(15, 18);
0540: else if (curChar == 46)
0541: jjCheckNAddStates(19, 22);
0542: break;
0543: case 1:
0544: if (curChar == 46)
0545: jjCheckNAddTwoStates(2, 23);
0546: break;
0547: case 2:
0548: if ((0x3ff000000000000L & l) != 0L)
0549: jjCheckNAddStates(23, 25);
0550: break;
0551: case 4:
0552: if ((0x280000000000L & l) != 0L)
0553: jjCheckNAdd(5);
0554: break;
0555: case 5:
0556: if ((0x3ff000000000000L & l) != 0L)
0557: jjCheckNAddTwoStates(5, 6);
0558: break;
0559: case 6:
0560: if (curChar == 32)
0561: jjCheckNAddStates(26, 29);
0562: break;
0563: case 7:
0564: if ((0x280000000000L & l) != 0L)
0565: jjCheckNAddTwoStates(8, 14);
0566: break;
0567: case 8:
0568: if (curChar == 46)
0569: jjCheckNAddTwoStates(9, 13);
0570: break;
0571: case 9:
0572: if ((0x3ff000000000000L & l) == 0L)
0573: break;
0574: if (kind > 5)
0575: kind = 5;
0576: jjCheckNAddTwoStates(9, 10);
0577: break;
0578: case 11:
0579: if ((0x280000000000L & l) != 0L)
0580: jjCheckNAdd(12);
0581: break;
0582: case 12:
0583: if ((0x3ff000000000000L & l) == 0L)
0584: break;
0585: if (kind > 5)
0586: kind = 5;
0587: jjCheckNAdd(12);
0588: break;
0589: case 13:
0590: if ((0x3ff000000000000L & l) == 0L)
0591: break;
0592: if (kind > 5)
0593: kind = 5;
0594: jjCheckNAdd(13);
0595: break;
0596: case 14:
0597: if ((0x3ff000000000000L & l) == 0L)
0598: break;
0599: if (kind > 5)
0600: kind = 5;
0601: jjCheckNAddStates(30, 36);
0602: break;
0603: case 15:
0604: if ((0x3ff000000000000L & l) == 0L)
0605: break;
0606: if (kind > 5)
0607: kind = 5;
0608: jjCheckNAddTwoStates(15, 10);
0609: break;
0610: case 16:
0611: if ((0x3ff000000000000L & l) == 0L)
0612: break;
0613: if (kind > 5)
0614: kind = 5;
0615: jjCheckNAddStates(37, 39);
0616: break;
0617: case 17:
0618: if (curChar == 46)
0619: jjCheckNAdd(18);
0620: break;
0621: case 18:
0622: if ((0x3ff000000000000L & l) == 0L)
0623: break;
0624: if (kind > 5)
0625: kind = 5;
0626: jjCheckNAddTwoStates(18, 10);
0627: break;
0628: case 19:
0629: if ((0x3ff000000000000L & l) == 0L)
0630: break;
0631: if (kind > 5)
0632: kind = 5;
0633: jjCheckNAddTwoStates(19, 20);
0634: break;
0635: case 20:
0636: if (curChar == 46)
0637: jjCheckNAdd(21);
0638: break;
0639: case 21:
0640: if ((0x3ff000000000000L & l) == 0L)
0641: break;
0642: if (kind > 5)
0643: kind = 5;
0644: jjCheckNAdd(21);
0645: break;
0646: case 22:
0647: if ((0x3ff000000000000L & l) == 0L)
0648: break;
0649: if (kind > 5)
0650: kind = 5;
0651: jjCheckNAdd(22);
0652: break;
0653: case 23:
0654: if ((0x3ff000000000000L & l) != 0L)
0655: jjCheckNAddTwoStates(23, 6);
0656: break;
0657: case 24:
0658: if ((0x3ff000000000000L & l) != 0L)
0659: jjCheckNAddStates(40, 47);
0660: break;
0661: case 25:
0662: if ((0x3ff000000000000L & l) != 0L)
0663: jjCheckNAddStates(48, 50);
0664: break;
0665: case 26:
0666: if ((0x3ff000000000000L & l) != 0L)
0667: jjCheckNAddStates(51, 54);
0668: break;
0669: case 27:
0670: if (curChar == 46)
0671: jjCheckNAdd(28);
0672: break;
0673: case 28:
0674: if ((0x3ff000000000000L & l) != 0L)
0675: jjCheckNAddStates(55, 57);
0676: break;
0677: case 29:
0678: if ((0x3ff000000000000L & l) != 0L)
0679: jjCheckNAddStates(58, 60);
0680: break;
0681: case 30:
0682: if (curChar == 46)
0683: jjCheckNAdd(31);
0684: break;
0685: case 31:
0686: if ((0x3ff000000000000L & l) != 0L)
0687: jjCheckNAddTwoStates(31, 6);
0688: break;
0689: case 32:
0690: if ((0x3ff000000000000L & l) != 0L)
0691: jjCheckNAddTwoStates(32, 6);
0692: break;
0693: case 33:
0694: if (curChar == 46)
0695: jjCheckNAddTwoStates(34, 38);
0696: break;
0697: case 34:
0698: if ((0x3ff000000000000L & l) == 0L)
0699: break;
0700: if (kind > 1)
0701: kind = 1;
0702: jjCheckNAddTwoStates(34, 35);
0703: break;
0704: case 36:
0705: if ((0x280000000000L & l) != 0L)
0706: jjCheckNAdd(37);
0707: break;
0708: case 37:
0709: if ((0x3ff000000000000L & l) == 0L)
0710: break;
0711: if (kind > 1)
0712: kind = 1;
0713: jjCheckNAdd(37);
0714: break;
0715: case 38:
0716: if ((0x3ff000000000000L & l) == 0L)
0717: break;
0718: if (kind > 1)
0719: kind = 1;
0720: jjCheckNAdd(38);
0721: break;
0722: case 39:
0723: if ((0x3ff000000000000L & l) == 0L)
0724: break;
0725: if (kind > 1)
0726: kind = 1;
0727: jjCheckNAddStates(61, 67);
0728: break;
0729: case 40:
0730: if ((0x3ff000000000000L & l) == 0L)
0731: break;
0732: if (kind > 1)
0733: kind = 1;
0734: jjCheckNAddTwoStates(40, 35);
0735: break;
0736: case 41:
0737: if ((0x3ff000000000000L & l) == 0L)
0738: break;
0739: if (kind > 1)
0740: kind = 1;
0741: jjCheckNAddStates(68, 70);
0742: break;
0743: case 42:
0744: if (curChar == 46)
0745: jjCheckNAdd(43);
0746: break;
0747: case 43:
0748: if ((0x3ff000000000000L & l) == 0L)
0749: break;
0750: if (kind > 1)
0751: kind = 1;
0752: jjCheckNAddTwoStates(43, 35);
0753: break;
0754: case 44:
0755: if ((0x3ff000000000000L & l) == 0L)
0756: break;
0757: if (kind > 1)
0758: kind = 1;
0759: jjCheckNAddTwoStates(44, 45);
0760: break;
0761: case 45:
0762: if (curChar == 46)
0763: jjCheckNAdd(46);
0764: break;
0765: case 46:
0766: if ((0x3ff000000000000L & l) == 0L)
0767: break;
0768: if (kind > 1)
0769: kind = 1;
0770: jjCheckNAdd(46);
0771: break;
0772: case 47:
0773: if ((0x3ff000000000000L & l) == 0L)
0774: break;
0775: if (kind > 1)
0776: kind = 1;
0777: jjCheckNAdd(47);
0778: break;
0779: case 48:
0780: if (curChar == 46)
0781: jjCheckNAddStates(19, 22);
0782: break;
0783: case 49:
0784: if ((0x3ff000000000000L & l) == 0L)
0785: break;
0786: if (kind > 1)
0787: kind = 1;
0788: jjCheckNAddStates(0, 14);
0789: break;
0790: default:
0791: break;
0792: }
0793: } while (i != startsAt);
0794: } else if (curChar < 128) {
0795: long l = 1L << (curChar & 077);
0796: MatchLoop: do {
0797: switch (jjstateSet[--i]) {
0798: case 3:
0799: if ((0x2000000020L & l) != 0L)
0800: jjAddStates(71, 72);
0801: break;
0802: case 10:
0803: if ((0x2000000020L & l) != 0L)
0804: jjAddStates(73, 74);
0805: break;
0806: case 35:
0807: if ((0x2000000020L & l) != 0L)
0808: jjAddStates(75, 76);
0809: break;
0810: default:
0811: break;
0812: }
0813: } while (i != startsAt);
0814: } else {
0815: int i2 = (curChar & 0xff) >> 6;
0816: long l2 = 1L << (curChar & 077);
0817: MatchLoop: do {
0818: switch (jjstateSet[--i]) {
0819: default:
0820: break;
0821: }
0822: } while (i != startsAt);
0823: }
0824: if (kind != 0x7fffffff) {
0825: jjmatchedKind = kind;
0826: jjmatchedPos = curPos;
0827: kind = 0x7fffffff;
0828: }
0829: ++curPos;
0830: if ((i = jjnewStateCnt) == (startsAt = 50 - (jjnewStateCnt = startsAt)))
0831: return curPos;
0832: try {
0833: curChar = input_stream.readChar();
0834: } catch (java.io.IOException e) {
0835: return curPos;
0836: }
0837: }
0838: }
0839:
0840: static final int[] jjnextStates = { 40, 41, 42, 35, 44, 45, 47, 25,
0841: 26, 27, 3, 29, 30, 32, 6, 1, 24, 33, 39, 34, 38, 2, 23, 2,
0842: 3, 6, 6, 7, 8, 14, 15, 16, 17, 10, 19, 20, 22, 16, 17, 10,
0843: 25, 26, 27, 3, 29, 30, 32, 6, 25, 3, 6, 26, 27, 3, 6, 28,
0844: 3, 6, 29, 30, 6, 40, 41, 42, 35, 44, 45, 47, 41, 42, 35, 4,
0845: 5, 11, 12, 36, 37, };
0846: public static final String[] jjstrLiteralImages = {
0847: "",
0848: null,
0849: null,
0850: null,
0851: null,
0852: null,
0853: "\12",
0854: null,
0855: null,
0856: "\50",
0857: "\51",
0858: "\105\115\120\124\131",
0859: "\54",
0860: "\120\117\111\116\124",
0861: "\115\125\114\124\111\120\117\111\116\124",
0862: "\114\111\116\105\123\124\122\111\116\107",
0863: "\115\125\114\124\111\114\111\116\105\123\124\122\111\116\107",
0864: "\120\117\114\131\107\117\116",
0865: "\115\125\114\124\111\120\117\114\131\107\117\116",
0866: "\107\105\117\115\105\124\122\131\103\117\114\114\105\103\124\111\117\116", };
0867: public static final String[] lexStateNames = { "DEFAULT", };
0868: static final long[] jjtoToken = { 0xffe63L, };
0869: static final long[] jjtoSkip = { 0x180L, };
0870: private SimpleCharStream input_stream;
0871: private final int[] jjrounds = new int[50];
0872: private final int[] jjstateSet = new int[100];
0873: protected char curChar;
0874:
0875: public WktGeOxygeneTokenManager(SimpleCharStream stream) {
0876: if (SimpleCharStream.staticFlag)
0877: throw new Error(
0878: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
0879: input_stream = stream;
0880: }
0881:
0882: public WktGeOxygeneTokenManager(SimpleCharStream stream,
0883: int lexState) {
0884: this (stream);
0885: SwitchTo(lexState);
0886: }
0887:
0888: public void ReInit(SimpleCharStream stream) {
0889: jjmatchedPos = jjnewStateCnt = 0;
0890: curLexState = defaultLexState;
0891: input_stream = stream;
0892: ReInitRounds();
0893: }
0894:
0895: private final void ReInitRounds() {
0896: int i;
0897: jjround = 0x80000001;
0898: for (i = 50; i-- > 0;)
0899: jjrounds[i] = 0x80000000;
0900: }
0901:
0902: public void ReInit(SimpleCharStream stream, int lexState) {
0903: ReInit(stream);
0904: SwitchTo(lexState);
0905: }
0906:
0907: public void SwitchTo(int lexState) {
0908: if (lexState >= 1 || lexState < 0)
0909: throw new TokenMgrError(
0910: "Error: Ignoring invalid lexical state : "
0911: + lexState + ". State unchanged.",
0912: TokenMgrError.INVALID_LEXICAL_STATE);
0913: else
0914: curLexState = lexState;
0915: }
0916:
0917: private final Token jjFillToken() {
0918: Token t = Token.newToken(jjmatchedKind);
0919: t.kind = jjmatchedKind;
0920: String im = jjstrLiteralImages[jjmatchedKind];
0921: t.image = (im == null) ? input_stream.GetImage() : im;
0922: t.beginLine = input_stream.getBeginLine();
0923: t.beginColumn = input_stream.getBeginColumn();
0924: t.endLine = input_stream.getEndLine();
0925: t.endColumn = input_stream.getEndColumn();
0926: return t;
0927: }
0928:
0929: int curLexState = 0;
0930: int defaultLexState = 0;
0931: int jjnewStateCnt;
0932: int jjround;
0933: int jjmatchedPos;
0934: int jjmatchedKind;
0935:
0936: public final Token getNextToken() {
0937: int kind;
0938: Token specialToken = null;
0939: Token matchedToken;
0940: int curPos = 0;
0941:
0942: EOFLoop: for (;;) {
0943: try {
0944: curChar = input_stream.BeginToken();
0945: } catch (java.io.IOException e) {
0946: jjmatchedKind = 0;
0947: matchedToken = jjFillToken();
0948: return matchedToken;
0949: }
0950:
0951: try {
0952: input_stream.backup(0);
0953: while (curChar <= 32
0954: && (0x100000200L & (1L << curChar)) != 0L)
0955: curChar = input_stream.BeginToken();
0956: } catch (java.io.IOException e1) {
0957: continue EOFLoop;
0958: }
0959: jjmatchedKind = 0x7fffffff;
0960: jjmatchedPos = 0;
0961: curPos = jjMoveStringLiteralDfa0_0();
0962: if (jjmatchedKind != 0x7fffffff) {
0963: if (jjmatchedPos + 1 < curPos)
0964: input_stream.backup(curPos - jjmatchedPos - 1);
0965: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
0966: matchedToken = jjFillToken();
0967: return matchedToken;
0968: } else {
0969: continue EOFLoop;
0970: }
0971: }
0972: int error_line = input_stream.getEndLine();
0973: int error_column = input_stream.getEndColumn();
0974: String error_after = null;
0975: boolean EOFSeen = false;
0976: try {
0977: input_stream.readChar();
0978: input_stream.backup(1);
0979: } catch (java.io.IOException e1) {
0980: EOFSeen = true;
0981: error_after = curPos <= 1 ? "" : input_stream
0982: .GetImage();
0983: if (curChar == '\n' || curChar == '\r') {
0984: error_line++;
0985: error_column = 0;
0986: } else
0987: error_column++;
0988: }
0989: if (!EOFSeen) {
0990: input_stream.backup(1);
0991: error_after = curPos <= 1 ? "" : input_stream
0992: .GetImage();
0993: }
0994: throw new TokenMgrError(EOFSeen, curLexState, error_line,
0995: error_column, error_after, curChar,
0996: TokenMgrError.LEXICAL_ERROR);
0997: }
0998: }
0999:
1000: }
|