Source code

001/* Generated By:JJTree&JavaCC: Do not edit this line. MatrixParserTokenManager.java */
002/* Parser for matrices written in matlab format.
003
004 Copyright (c) 1998-2008 The Regents of the University of California.
005 All rights reserved.
006 Permission is hereby granted, without written agreement and without
007 license or royalty fees, to use, copy, modify, and distribute this
008 software and its documentation for any purpose, provided that the above
009 copyright notice and the following two paragraphs appear in all copies
010 of this software.
011
012 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
013 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
014 ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
015 THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
016 SUCH DAMAGE.
017
018 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
019 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
020 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
021 PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
022 CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
023 ENHANCEMENTS, OR MODIFICATIONS.
024
025                                        PT_COPYRIGHT_VERSION_2
026                                        COPYRIGHTENDKEY
027*/
028package ptolemy.data.expr;
029
030/** Token Manager. */
031public class MatrixParserTokenManager implements MatrixParserConstants {
032
033    /** Debug output. */
034    public java.io.PrintStream debugStream = System.out;
035
036    /** Set debug output. */
037    public void setDebugStream(java.io.PrintStream ds) {
038        debugStream = ds;
039    }
040
041    private int jjStopAtPos(int pos, int kind) {
042        jjmatchedKind = kind;
043        jjmatchedPos = pos;
044        return pos + 1;
045    }
046
047    private int jjMoveStringLiteralDfa0_0() {
048        switch (curChar) {
049        case 44:
050            return jjStopAtPos(0, 16);
051        case 59:
052            return jjStopAtPos(0, 14);
053        case 91:
054            return jjStopAtPos(0, 13);
055        case 93:
056            return jjStopAtPos(0, 15);
057        default:
058            return jjMoveNfa_0(2, 0);
059        }
060    }
061
062    static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL,
063            0xffffffffffffffffL };
064
065    private int jjMoveNfa_0(int startState, int curPos) {
066        int startsAt = 0;
067        jjnewStateCnt = 23;
068        int i = 1;
069        jjstateSet[0] = startState;
070        int kind = 0x7fffffff;
071        for (;;) {
072            if (++jjround == 0x7fffffff) {
073                ReInitRounds();
074            }
075            if (curChar < 64) {
076                long l = 1L << curChar;
077                do {
078                    switch (jjstateSet[--i]) {
079                    case 2:
080                        if ((0x3ff000000000000L & l) != 0L) {
081                            if (kind > 5) {
082                                kind = 5;
083                            }
084                            jjCheckNAddStates(0, 7);
085                        } else if ((0x280000000000L & l) != 0L) {
086                            if (kind > 11) {
087                                kind = 11;
088                            }
089                        } else if (curChar == 46) {
090                            jjCheckNAddTwoStates(7, 11);
091                        } else if (curChar == 35) {
092                            jjCheckNAddTwoStates(4, 5);
093                        }
094                        break;
095                    case 1:
096                        if ((0x3ff008000000000L & l) == 0L) {
097                            break;
098                        }
099                        if (kind > 9) {
100                            kind = 9;
101                        }
102                        jjstateSet[jjnewStateCnt++] = 1;
103                        break;
104                    case 3:
105                        if (curChar == 35) {
106                            jjCheckNAddTwoStates(4, 5);
107                        }
108                        break;
109                    case 4:
110                        if ((0xffffffffffffdbffL & l) != 0L) {
111                            jjCheckNAddTwoStates(4, 5);
112                        }
113                        break;
114                    case 5:
115                        if ((0x2400L & l) != 0L) {
116                            kind = 12;
117                        }
118                        break;
119                    case 6:
120                        if (curChar == 46) {
121                            jjCheckNAddTwoStates(7, 11);
122                        }
123                        break;
124                    case 7:
125                        if ((0x3ff000000000000L & l) == 0L) {
126                            break;
127                        }
128                        if (kind > 5) {
129                            kind = 5;
130                        }
131                        jjCheckNAddTwoStates(7, 8);
132                        break;
133                    case 9:
134                        if ((0x280000000000L & l) != 0L) {
135                            jjCheckNAdd(10);
136                        }
137                        break;
138                    case 10:
139                        if ((0x3ff000000000000L & l) == 0L) {
140                            break;
141                        }
142                        if (kind > 5) {
143                            kind = 5;
144                        }
145                        jjCheckNAdd(10);
146                        break;
147                    case 11:
148                        if ((0x3ff000000000000L & l) == 0L) {
149                            break;
150                        }
151                        if (kind > 5) {
152                            kind = 5;
153                        }
154                        jjCheckNAdd(11);
155                        break;
156                    case 12:
157                        if ((0x3ff000000000000L & l) == 0L) {
158                            break;
159                        }
160                        if (kind > 5) {
161                            kind = 5;
162                        }
163                        jjCheckNAddStates(0, 7);
164                        break;
165                    case 13:
166                        if ((0x3ff000000000000L & l) == 0L) {
167                            break;
168                        }
169                        if (kind > 5) {
170                            kind = 5;
171                        }
172                        jjCheckNAddTwoStates(13, 8);
173                        break;
174                    case 14:
175                        if ((0x3ff000000000000L & l) == 0L) {
176                            break;
177                        }
178                        if (kind > 5) {
179                            kind = 5;
180                        }
181                        jjCheckNAddStates(8, 10);
182                        break;
183                    case 15:
184                        if (curChar == 46) {
185                            jjCheckNAdd(16);
186                        }
187                        break;
188                    case 16:
189                        if ((0x3ff000000000000L & l) == 0L) {
190                            break;
191                        }
192                        if (kind > 5) {
193                            kind = 5;
194                        }
195                        jjCheckNAddTwoStates(16, 8);
196                        break;
197                    case 17:
198                        if ((0x3ff000000000000L & l) == 0L) {
199                            break;
200                        }
201                        if (kind > 5) {
202                            kind = 5;
203                        }
204                        jjCheckNAddTwoStates(17, 18);
205                        break;
206                    case 18:
207                        if (curChar == 46) {
208                            jjCheckNAdd(19);
209                        }
210                        break;
211                    case 19:
212                        if ((0x3ff000000000000L & l) == 0L) {
213                            break;
214                        }
215                        if (kind > 5) {
216                            kind = 5;
217                        }
218                        jjCheckNAdd(19);
219                        break;
220                    case 20:
221                        if ((0x3ff000000000000L & l) == 0L) {
222                            break;
223                        }
224                        if (kind > 5) {
225                            kind = 5;
226                        }
227                        jjCheckNAdd(20);
228                        break;
229                    case 21:
230                        if ((0x3ff000000000000L & l) == 0L) {
231                            break;
232                        }
233                        if (kind > 10) {
234                            kind = 10;
235                        }
236                        jjCheckNAddTwoStates(22, 21);
237                        break;
238                    case 22:
239                        if ((0x3ff000000000000L & l) == 0L) {
240                            break;
241                        }
242                        if (kind > 10) {
243                            kind = 10;
244                        }
245                        jjCheckNAdd(22);
246                        break;
247                    default:
248                        break;
249                    }
250                } while (i != startsAt);
251            } else if (curChar < 128) {
252                long l = 1L << (curChar & 077);
253                do {
254                    switch (jjstateSet[--i]) {
255                    case 2:
256                    case 0:
257                        if ((0x7fffffe87fffffeL & l) == 0L) {
258                            break;
259                        }
260                        if (kind > 9) {
261                            kind = 9;
262                        }
263                        jjCheckNAddTwoStates(0, 1);
264                        break;
265                    case 1:
266                        if ((0x7fffffe87fffffeL & l) == 0L) {
267                            break;
268                        }
269                        if (kind > 9) {
270                            kind = 9;
271                        }
272                        jjCheckNAdd(1);
273                        break;
274                    case 4:
275                        jjAddStates(11, 12);
276                        break;
277                    case 8:
278                        if ((0x2000000020L & l) != 0L) {
279                            jjAddStates(13, 14);
280                        }
281                        break;
282                    default:
283                        break;
284                    }
285                } while (i != startsAt);
286            } else {
287                int i2 = (curChar & 0xff) >> 6;
288                long l2 = 1L << (curChar & 077);
289                do {
290                    switch (jjstateSet[--i]) {
291                    case 4:
292                        if ((jjbitVec0[i2] & l2) != 0L) {
293                            jjAddStates(11, 12);
294                        }
295                        break;
296                    default:
297                        break;
298                    }
299                } while (i != startsAt);
300            }
301            if (kind != 0x7fffffff) {
302                jjmatchedKind = kind;
303                jjmatchedPos = curPos;
304                kind = 0x7fffffff;
305            }
306            ++curPos;
307            if ((i = jjnewStateCnt) == (startsAt = 23
308                    - (jjnewStateCnt = startsAt))) {
309                return curPos;
310            }
311            try {
312                curChar = input_stream.readChar();
313            } catch (java.io.IOException e) {
314                return curPos;
315            }
316        }
317    }
318
319    static final int[] jjnextStates = { 13, 14, 15, 8, 17, 18, 20, 21, 14, 15,
320            8, 4, 5, 9, 10, };
321
322    /** Token literal values. */
323    public static final String[] jjstrLiteralImages = { "", null, null, null,
324            null, null, null, null, null, null, null, null, null, "\133", "\73",
325            "\135", "\54", };
326
327    /** Lexer state names. */
328    public static final String[] lexStateNames = { "DEFAULT", };
329    static final long[] jjtoToken = { 0x1ee21L, };
330    static final long[] jjtoSkip = { 0x101eL, };
331    static final long[] jjtoSpecial = { 0x1000L, };
332    protected SimpleCharStream input_stream;
333    private final int[] jjrounds = new int[23];
334    private final int[] jjstateSet = new int[46];
335    protected char curChar;
336
337    /** Constructor. */
338    public MatrixParserTokenManager(SimpleCharStream stream) {
339        if (SimpleCharStream.staticFlag) {
340            throw new Error(
341                    "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
342        }
343        input_stream = stream;
344    }
345
346    /** Constructor. */
347    public MatrixParserTokenManager(SimpleCharStream stream, int lexState) {
348        this(stream);
349        SwitchTo(lexState);
350    }
351
352    /** Reinitialise parser. */
353    public void ReInit(SimpleCharStream stream) {
354        jjmatchedPos = jjnewStateCnt = 0;
355        curLexState = defaultLexState;
356        input_stream = stream;
357        ReInitRounds();
358    }
359
360    private void ReInitRounds() {
361        int i;
362        jjround = 0x80000001;
363        for (i = 23; i-- > 0;) {
364            jjrounds[i] = 0x80000000;
365        }
366    }
367
368    /** Reinitialise parser. */
369    public void ReInit(SimpleCharStream stream, int lexState) {
370        ReInit(stream);
371        SwitchTo(lexState);
372    }
373
374    /** Switch to specified lex state. */
375    public void SwitchTo(int lexState) {
376        if (lexState >= 1 || lexState < 0) {
377            throw new TokenMgrError(
378                    "Error: Ignoring invalid lexical state : " + lexState
379                            + ". State unchanged.",
380                    TokenMgrError.INVALID_LEXICAL_STATE);
381        } else {
382            curLexState = lexState;
383        }
384    }
385
386    protected Token jjFillToken() {
387        final Token t;
388        final String curTokenImage;
389        final int beginLine;
390        final int endLine;
391        final int beginColumn;
392        final int endColumn;
393        String im = jjstrLiteralImages[jjmatchedKind];
394        curTokenImage = (im == null) ? input_stream.GetImage() : im;
395        beginLine = input_stream.getBeginLine();
396        beginColumn = input_stream.getBeginColumn();
397        endLine = input_stream.getEndLine();
398        endColumn = input_stream.getEndColumn();
399        t = Token.newToken(jjmatchedKind, curTokenImage);
400
401        t.beginLine = beginLine;
402        t.endLine = endLine;
403        t.beginColumn = beginColumn;
404        t.endColumn = endColumn;
405
406        return t;
407    }
408
409    int curLexState = 0;
410    int defaultLexState = 0;
411    int jjnewStateCnt;
412    int jjround;
413    int jjmatchedPos;
414    int jjmatchedKind;
415
416    /** Get the next Token. */
417    public Token getNextToken() {
418        Token specialToken = null;
419        Token matchedToken;
420        int curPos = 0;
421
422        EOFLoop: for (;;) {
423            try {
424                curChar = input_stream.BeginToken();
425            } catch (java.io.IOException e) {
426                jjmatchedKind = 0;
427                matchedToken = jjFillToken();
428                matchedToken.specialToken = specialToken;
429                return matchedToken;
430            }
431
432            try {
433                input_stream.backup(0);
434                while (curChar <= 32
435                        && (0x100002600L & (1L << curChar)) != 0L) {
436                    curChar = input_stream.BeginToken();
437                }
438            } catch (java.io.IOException e1) {
439                continue EOFLoop;
440            }
441            jjmatchedKind = 0x7fffffff;
442            jjmatchedPos = 0;
443            curPos = jjMoveStringLiteralDfa0_0();
444            if (jjmatchedKind != 0x7fffffff) {
445                if (jjmatchedPos + 1 < curPos) {
446                    input_stream.backup(curPos - jjmatchedPos - 1);
447                }
448                if ((jjtoToken[jjmatchedKind >> 6]
449                        & (1L << (jjmatchedKind & 077))) != 0L) {
450                    matchedToken = jjFillToken();
451                    matchedToken.specialToken = specialToken;
452                    return matchedToken;
453                } else {
454                    if ((jjtoSpecial[jjmatchedKind >> 6]
455                            & (1L << (jjmatchedKind & 077))) != 0L) {
456                        matchedToken = jjFillToken();
457                        if (specialToken == null) {
458                            specialToken = matchedToken;
459                        } else {
460                            matchedToken.specialToken = specialToken;
461                            specialToken = (specialToken.next = matchedToken);
462                        }
463                    }
464                    continue EOFLoop;
465                }
466            }
467            int error_line = input_stream.getEndLine();
468            int error_column = input_stream.getEndColumn();
469            String error_after = null;
470            boolean EOFSeen = false;
471            try {
472                input_stream.readChar();
473                input_stream.backup(1);
474            } catch (java.io.IOException e1) {
475                EOFSeen = true;
476                error_after = curPos <= 1 ? "" : input_stream.GetImage();
477                if (curChar == '\n' || curChar == '\r') {
478                    error_line++;
479                    error_column = 0;
480                } else {
481                    error_column++;
482                }
483            }
484            if (!EOFSeen) {
485                input_stream.backup(1);
486                error_after = curPos <= 1 ? "" : input_stream.GetImage();
487            }
488            throw new TokenMgrError(EOFSeen, curLexState, error_line,
489                    error_column, error_after, curChar,
490                    TokenMgrError.LEXICAL_ERROR);
491        }
492    }
493
494    private void jjCheckNAdd(int state) {
495        if (jjrounds[state] != jjround) {
496            jjstateSet[jjnewStateCnt++] = state;
497            jjrounds[state] = jjround;
498        }
499    }
500
501    private void jjAddStates(int start, int end) {
502        do {
503            jjstateSet[jjnewStateCnt++] = jjnextStates[start];
504        } while (start++ != end);
505    }
506
507    private void jjCheckNAddTwoStates(int state1, int state2) {
508        jjCheckNAdd(state1);
509        jjCheckNAdd(state2);
510    }
511
512    private void jjCheckNAddStates(int start, int end) {
513        do {
514            jjCheckNAdd(jjnextStates[start]);
515        } while (start++ != end);
516    }
517
518}