Yylex.java Source File

00001 package edu.ksu.cis.bandera.abstraction.pvs;
00002 
00003 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00004  * Bandera, a Java(TM) analysis and transformation toolkit           *
00005  * Copyright (C) 1998-2001 SAnToS Laboratories (santos@cis.ksu.edu)  *
00006 
00007  * All rights reserved.                                              *
00008  *                                                                   *
00009  * This work was done as a project in the SAnToS Laboratory,         *
00010  * Department of Computing and Information Sciences, Kansas State    *
00011  * University, USA (http://www.cis.ksu.edu/santos).                  *
00012  * It is understood that any modification not identified as such is  *
00013  * not covered by the preceding statement.                           *
00014  *                                                                   *
00015  * This work is free software; you can redistribute it and/or        *
00016  * modify it under the terms of the GNU Library General Public       *
00017  * License as published by the Free Software Foundation; either      *
00018  * version 2 of the License, or (at your option) any later version.  *
00019  *                                                                   *
00020  * This work is distributed in the hope that it will be useful,      *
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
00023  * Library General Public License for more details.                  *
00024  *                                                                   *
00025  * You should have received a copy of the GNU Library General Public *
00026  * License along with this toolkit; if not, write to the             *
00027  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
00028  * Boston, MA  02111-1307, USA.                                      *
00029  *                                                                   *
00030  * Java is a trademark of Sun Microsystems, Inc.                     *
00031  *                                                                   *
00032  * To submit a bug report, send a comment, or get the latest news on *
00033  * this project and other SAnToS projects, please visit the web-site *
00034  *                http://www.cis.ksu.edu/santos                      *
00035  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
00036 import java_cup.runtime.Symbol;
00037 
00038 
00039 public class Yylex implements java_cup.runtime.Scanner {
00040     private final int YY_BUFFER_SIZE = 512;
00041     private final int YY_F = -1;
00042     private final int YY_NO_STATE = -1;
00043     private final int YY_NOT_ACCEPT = 0;
00044     private final int YY_START = 1;
00045     private final int YY_END = 2;
00046     private final int YY_NO_ANCHOR = 4;
00047     private final int YY_BOL = 128;
00048     private final int YY_EOF = 129;
00049  
00050     private java.io.BufferedReader yy_reader;
00051     private int yy_buffer_index;
00052     private int yy_buffer_read;
00053     private int yy_buffer_start;
00054     private int yy_buffer_end;
00055     private char yy_buffer[];
00056     private int yyline;
00057     private boolean yy_at_bol;
00058     private int yy_lexical_state;
00059 
00060     private boolean yy_eof_done = false;
00061     private final int YYINITIAL = 0;
00062     private final int yy_state_dtrans[] = {
00063         0
00064     };
00065     private boolean yy_last_was_cr=false;
00066     private final int YY_E_INTERNAL = 0;
00067     private final int YY_E_MATCH = 1;
00068     private java.lang.String yy_error_string[] = {
00069         "Error: Internal error.\n",
00070         "Error: Unmatched input.\n"
00071     };
00072     private int yy_acpt[] = {
00073         /* 0 */ YY_NOT_ACCEPT,
00074         /* 1 */ YY_NO_ANCHOR,
00075         /* 2 */ YY_NO_ANCHOR,
00076         /* 3 */ YY_NO_ANCHOR,
00077         /* 4 */ YY_NO_ANCHOR,
00078         /* 5 */ YY_NO_ANCHOR,
00079         /* 6 */ YY_NO_ANCHOR,
00080         /* 7 */ YY_NO_ANCHOR,
00081         /* 8 */ YY_NO_ANCHOR,
00082         /* 9 */ YY_NO_ANCHOR,
00083         /* 10 */ YY_NO_ANCHOR,
00084         /* 11 */ YY_NO_ANCHOR,
00085         /* 12 */ YY_NO_ANCHOR,
00086         /* 13 */ YY_NO_ANCHOR,
00087         /* 14 */ YY_NO_ANCHOR,
00088         /* 15 */ YY_NO_ANCHOR,
00089         /* 16 */ YY_NO_ANCHOR,
00090         /* 17 */ YY_NO_ANCHOR,
00091         /* 18 */ YY_NO_ANCHOR,
00092         /* 19 */ YY_NO_ANCHOR,
00093         /* 20 */ YY_NO_ANCHOR,
00094         /* 21 */ YY_NO_ANCHOR,
00095         /* 22 */ YY_NO_ANCHOR,
00096         /* 23 */ YY_NO_ANCHOR,
00097         /* 24 */ YY_NO_ANCHOR,
00098         /* 25 */ YY_NO_ANCHOR,
00099         /* 26 */ YY_NO_ANCHOR,
00100         /* 27 */ YY_NO_ANCHOR,
00101         /* 28 */ YY_NO_ANCHOR,
00102         /* 29 */ YY_NO_ANCHOR,
00103         /* 30 */ YY_NO_ANCHOR,
00104         /* 31 */ YY_NO_ANCHOR,
00105         /* 32 */ YY_NO_ANCHOR,
00106         /* 33 */ YY_NO_ANCHOR,
00107         /* 34 */ YY_NO_ANCHOR,
00108         /* 35 */ YY_NO_ANCHOR,
00109         /* 36 */ YY_NO_ANCHOR,
00110         /* 37 */ YY_NO_ANCHOR,
00111         /* 38 */ YY_NO_ANCHOR,
00112         /* 39 */ YY_NO_ANCHOR,
00113         /* 40 */ YY_NO_ANCHOR,
00114         /* 41 */ YY_NO_ANCHOR,
00115         /* 42 */ YY_NO_ANCHOR,
00116         /* 43 */ YY_NO_ANCHOR,
00117         /* 44 */ YY_NO_ANCHOR,
00118         /* 45 */ YY_NO_ANCHOR,
00119         /* 46 */ YY_NO_ANCHOR,
00120         /* 47 */ YY_NO_ANCHOR,
00121         /* 48 */ YY_NO_ANCHOR,
00122         /* 49 */ YY_NO_ANCHOR,
00123         /* 50 */ YY_NO_ANCHOR,
00124         /* 51 */ YY_NO_ANCHOR,
00125         /* 52 */ YY_NO_ANCHOR,
00126         /* 53 */ YY_NO_ANCHOR,
00127         /* 54 */ YY_NO_ANCHOR,
00128         /* 55 */ YY_NO_ANCHOR,
00129         /* 56 */ YY_NO_ANCHOR,
00130         /* 57 */ YY_NO_ANCHOR,
00131         /* 58 */ YY_NO_ANCHOR,
00132         /* 59 */ YY_NO_ANCHOR,
00133         /* 60 */ YY_NO_ANCHOR,
00134         /* 61 */ YY_NO_ANCHOR,
00135         /* 62 */ YY_NO_ANCHOR,
00136         /* 63 */ YY_NO_ANCHOR,
00137         /* 64 */ YY_NO_ANCHOR,
00138         /* 65 */ YY_NO_ANCHOR,
00139         /* 66 */ YY_NO_ANCHOR,
00140         /* 67 */ YY_NO_ANCHOR,
00141         /* 68 */ YY_NO_ANCHOR,
00142         /* 69 */ YY_NO_ANCHOR,
00143         /* 70 */ YY_NO_ANCHOR,
00144         /* 71 */ YY_NO_ANCHOR,
00145         /* 72 */ YY_NO_ANCHOR
00146     };
00147     private int yy_cmap[] = unpackFromString(1,130,
00148 "41:9,40:2,41,40:2,41:18,40,9,41:3,6,7,41,13,14,4,2,37,3,41,5,38:10,41,1,11," +
00149 "10,12,41:2,39:4,32,39:5,31,39:2,33,30,39:3,34,29,39:6,41:6,21,15,25,20,16,3" +
00150 "9,17,39,18,39:2,28,39,19,26,39:2,24,22,23,39:3,27,39:2,35,8,36,41:2,0:2")[0];
00151 
00152     private int yy_rmap[] = unpackFromString(1,73,
00153 "0,1:3,2,1:3,3,4,5,6,7,1:2,8,1:3,9,1:8,10:6,11,10,12,13,1,14,15,16,17,18,19," +
00154 "20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,10,42,43," +
00155 "44,45,46")[0];
00156 
00157     private int yy_nxt[][] = unpackFromString(47,42,
00158 "1,2,3,4,5,6,7,8,36,9,10,11,12,13,14,15,46,67,69,67:2,70,67:2,54,67:4,71,67:" +
00159 "5,16,17,18,19,67,20,38,-1:54,21,-1:36,22,-1:44,24,-1:41,25,-1:41,26,-1:41,2" +
00160 "7,-1:46,67,55,67:18,-1:3,67:2,-1:40,19,-1:18,67:20,-1:3,67:2,-1:17,67:3,53," +
00161 "67:16,-1:3,67:2,-1:10,23,-1:48,67:5,28,67:14,-1:3,67:2,-1:17,67:13,29,67:6," +
00162 "-1:3,67:2,-1:17,67:4,30,67:15,-1:3,67:2,-1:17,67:19,31,-1:3,67:2,-1:17,67:7" +
00163 ",32,67:12,-1:3,67:2,-1:17,67:13,33,67:6,-1:3,67:2,-1:17,67:8,34,67:11,-1:3," +
00164 "67:2,-1:17,67:4,35,67:15,-1:3,67:2,-1:17,67:4,37,67:7,56,67:7,-1:3,67:2,-1:" +
00165 "17,67:6,39,67:13,-1:3,67:2,-1:17,67:3,40,67:16,-1:3,67:2,-1:17,67:18,41,67," +
00166 "-1:3,67:2,-1:17,67:5,42,67:14,-1:3,67:2,-1:17,67:6,43,67:13,-1:3,67:2,-1:17" +
00167 ",67:10,44,67:9,-1:3,67:2,-1:17,67:11,45,67:8,-1:3,67:2,-1:17,67,47,67:18,-1" +
00168 ":3,67:2,-1:17,67:2,48,67:17,-1:3,67:2,-1:17,67:8,59,67:11,-1:3,67:2,-1:17,6" +
00169 "7:7,60,67:12,-1:3,67:2,-1:17,67:16,61,67:3,-1:3,67:2,-1:17,67,62,67:18,-1:3" +
00170 ",67:2,-1:17,67:8,64,67:11,-1:3,67:2,-1:17,67:17,49,67:2,-1:3,67:2,-1:17,67:" +
00171 "4,50,67:15,-1:3,67:2,-1:17,67:2,65,67:17,-1:3,67:2,-1:17,67:9,66,67:10,-1:3" +
00172 ",67:2,-1:17,67:9,51,67:10,-1:3,67:2,-1:17,67:6,52,67:13,-1:3,67:2,-1:17,67," +
00173 "63,67:18,-1:3,67:2,-1:17,67:4,72,67:15,-1:3,67:2,-1:17,57,67:19,-1:3,67:2,-" +
00174 "1:17,67:15,58,67:4,-1:3,67:2,-1:17,67:8,68,67:11,-1:3,67:2,-1:2");
00175 
00176     private Yylex () {
00177         yy_buffer = new char[YY_BUFFER_SIZE];
00178         yy_buffer_read = 0;
00179         yy_buffer_index = 0;
00180         yy_buffer_start = 0;
00181         yy_buffer_end = 0;
00182         yyline = 0;
00183         yy_at_bol = true;
00184         yy_lexical_state = YYINITIAL;
00185     }
00186     Yylex (java.io.InputStream instream) {
00187         this ();
00188         if (null == instream) {
00189             throw (new Error("Error: Bad input stream initializer."));
00190         }
00191         yy_reader = new java.io.BufferedReader(new java.io.InputStreamReader(instream));
00192     }
00193     public Yylex (java.io.Reader reader) {
00194         this ();
00195         if (null == reader) {
00196             throw (new Error("Error: Bad input stream initializer."));
00197         }
00198         yy_reader = new java.io.BufferedReader(reader);
00199     }
00200 public int line() {return yyline;}
00201     public java_cup.runtime.Symbol next_token ()
00202         throws java.io.IOException {
00203         int yy_lookahead;
00204         int yy_anchor = YY_NO_ANCHOR;
00205         int yy_state = yy_state_dtrans[yy_lexical_state];
00206         int yy_next_state = YY_NO_STATE;
00207         int yy_last_accept_state = YY_NO_STATE;
00208         boolean yy_initial = true;
00209         int yy_this_accept;
00210 
00211         yy_mark_start();
00212         yy_this_accept = yy_acpt[yy_state];
00213         if (YY_NOT_ACCEPT != yy_this_accept) {
00214             yy_last_accept_state = yy_state;
00215             yy_mark_end();
00216         }
00217         while (true) {
00218             if (yy_initial && yy_at_bol) yy_lookahead = YY_BOL;
00219             else yy_lookahead = yy_advance();
00220             yy_next_state = YY_F;
00221             yy_next_state = yy_nxt[yy_rmap[yy_state]][yy_cmap[yy_lookahead]];
00222             if (YY_EOF == yy_lookahead && true == yy_initial) {
00223                 return null;
00224             }
00225             if (YY_F != yy_next_state) {
00226                 yy_state = yy_next_state;
00227                 yy_initial = false;
00228                 yy_this_accept = yy_acpt[yy_state];
00229                 if (YY_NOT_ACCEPT != yy_this_accept) {
00230                     yy_last_accept_state = yy_state;
00231                     yy_mark_end();
00232                 }
00233             }
00234             else {
00235                 if (YY_NO_STATE == yy_last_accept_state) {
00236                     throw (new Error("Lexical Error: Unmatched Input."));
00237                 }
00238                 else {
00239                     yy_anchor = yy_acpt[yy_last_accept_state];
00240                     if (0 != (YY_END & yy_anchor)) {
00241                         yy_move_end();
00242                     }
00243                     yy_to_mark();
00244                     switch (yy_last_accept_state) {
00245                     case 1:
00246                         
00247                     case -2:
00248                         break;
00249                     case 2:
00250                         { return new Symbol(sym.SEMI); }
00251                     case -3:
00252                         break;
00253                     case 3:
00254                         { return new Symbol(sym.PLUS); }
00255                     case -4:
00256                         break;
00257                     case 4:
00258                         { return new Symbol(sym.MINUS); }
00259                     case -5:
00260                         break;
00261                     case 5:
00262                         { return new Symbol(sym.TIMES); }
00263                     case -6:
00264                         break;
00265                     case 6:
00266                         { return new Symbol(sym.DIV); }
00267                     case -7:
00268                         break;
00269                     case 7:
00270                         { return new Symbol(sym.MOD); }
00271                     case -8:
00272                         break;
00273                     case 8:
00274                         { System.err.println("Illegal character: "+yytext()); }
00275                     case -9:
00276                         break;
00277                     case 9:
00278                         { return new Symbol(sym.NOT); }
00279                     case -10:
00280                         break;
00281                     case 10:
00282                         { return new Symbol(sym.EQUAL); }
00283                     case -11:
00284                         break;
00285                     case 11:
00286                         { return new Symbol(sym.LT); }
00287                     case -12:
00288                         break;
00289                     case 12:
00290                         { return new Symbol(sym.GT); }
00291                     case -13:
00292                         break;
00293                     case 13:
00294                         { return new Symbol(sym.LPAREN); }
00295                     case -14:
00296                         break;
00297                     case 14:
00298                         { return new Symbol(sym.RPAREN); }
00299                     case -15:
00300                         break;
00301                     case 15:
00302                         { return new Symbol(sym.ID, yytext()); }
00303                     case -16:
00304                         break;
00305                     case 16:
00306                         { return new Symbol(sym.LBRACE); }
00307                     case -17:
00308                         break;
00309                     case 17:
00310                         { return new Symbol(sym.RBRACE); }
00311                     case -18:
00312                         break;
00313                     case 18:
00314                         { return new Symbol(sym.COMMA); }
00315                     case -19:
00316                         break;
00317                     case 19:
00318                         { return new Symbol(sym.NUMBER, new Integer(yytext())); }
00319                     case -20:
00320                         break;
00321                     case 20:
00322                         { /* ignore white space. */ }
00323                     case -21:
00324                         break;
00325                     case 21:
00326                         { return new Symbol(sym.ARROW); }
00327                     case -22:
00328                         break;
00329                     case 22:
00330                         { return new Symbol(sym.AND); }
00331                     case -23:
00332                         break;
00333                     case 23:
00334                         { return new Symbol(sym.OR); }
00335                     case -24:
00336                         break;
00337                     case 24:
00338                         { return new Symbol(sym.NE); }
00339                     case -25:
00340                         break;
00341                     case 25:
00342                         { return new Symbol(sym.EQ); }
00343                     case -26:
00344                         break;
00345                     case 26:
00346                         { return new Symbol(sym.LE); }
00347                     case -27:
00348                         break;
00349                     case 27:
00350                         { return new Symbol(sym.GE); }
00351                     case -28:
00352                         break;
00353                     case 28:
00354                         { return new Symbol(sym.END); }
00355                     case -29:
00356                         break;
00357                     case 29:
00358                         { return new Symbol(sym.FLOAT); }
00359                     case -30:
00360                         break;
00361                     case 30:
00362                         { return new Symbol(sym.BEGIN); }
00363                     case -31:
00364                         break;
00365                     case 31:
00366                         { return new Symbol(sym.TOKENS); }
00367                     case -32:
00368                         break;
00369                     case 32:
00370                         { return new Symbol(sym.EXTENDS); }
00371                     case -33:
00372                         break;
00373                     case 33:
00374                         { return new Symbol(sym.INT); }
00375                     case -34:
00376                         break;
00377                     case 34:
00378                         { return new Symbol(sym.ABSTRACT); }
00379                     case -35:
00380                         break;
00381                     case 35:
00382                         { return new Symbol(sym.ABSTRACTION); }
00383                     case -36:
00384                         break;
00385                     case 36:
00386                         { System.err.println("Illegal character: "+yytext()); }
00387                     case -37:
00388                         break;
00389                     case 37:
00390                         { return new Symbol(sym.ID, yytext()); }
00391                     case -38:
00392                         break;
00393                     case 38:
00394                         { System.err.println("Illegal character: "+yytext()); }
00395                     case -39:
00396                         break;
00397                     case 39:
00398                         { return new Symbol(sym.ID, yytext()); }
00399                     case -40:
00400                         break;
00401                     case 40:
00402                         { return new Symbol(sym.ID, yytext()); }
00403                     case -41:
00404                         break;
00405                     case 41:
00406                         { return new Symbol(sym.ID, yytext()); }
00407                     case -42:
00408                         break;
00409                     case 42:
00410                         { return new Symbol(sym.ID, yytext()); }
00411                     case -43:
00412                         break;
00413                     case 43:
00414                         { return new Symbol(sym.ID, yytext()); }
00415                     case -44:
00416                         break;
00417                     case 44:
00418                         { return new Symbol(sym.ID, yytext()); }
00419                     case -45:
00420                         break;
00421                     case 45:
00422                         { return new Symbol(sym.ID, yytext()); }
00423                     case -46:
00424                         break;
00425                     case 46:
00426                         { return new Symbol(sym.ID, yytext()); }
00427                     case -47:
00428                         break;
00429                     case 47:
00430                         { return new Symbol(sym.ID, yytext()); }
00431                     case -48:
00432                         break;
00433                     case 48:
00434                         { return new Symbol(sym.ID, yytext()); }
00435                     case -49:
00436                         break;
00437                     case 49:
00438                         { return new Symbol(sym.ID, yytext()); }
00439                     case -50:
00440                         break;
00441                     case 50:
00442                         { return new Symbol(sym.ID, yytext()); }
00443                     case -51:
00444                         break;
00445                     case 51:
00446                         { return new Symbol(sym.ID, yytext()); }
00447                     case -52:
00448                         break;
00449                     case 52:
00450                         { return new Symbol(sym.ID, yytext()); }
00451                     case -53:
00452                         break;
00453                     case 53:
00454                         { return new Symbol(sym.ID, yytext()); }
00455                     case -54:
00456                         break;
00457                     case 54:
00458                         { return new Symbol(sym.ID, yytext()); }
00459                     case -55:
00460                         break;
00461                     case 55:
00462                         { return new Symbol(sym.ID, yytext()); }
00463                     case -56:
00464                         break;
00465                     case 56:
00466                         { return new Symbol(sym.ID, yytext()); }
00467                     case -57:
00468                         break;
00469                     case 57:
00470                         { return new Symbol(sym.ID, yytext()); }
00471                     case -58:
00472                         break;
00473                     case 58:
00474                         { return new Symbol(sym.ID, yytext()); }
00475                     case -59:
00476                         break;
00477                     case 59:
00478                         { return new Symbol(sym.ID, yytext()); }
00479                     case -60:
00480                         break;
00481                     case 60:
00482                         { return new Symbol(sym.ID, yytext()); }
00483                     case -61:
00484                         break;
00485                     case 61:
00486                         { return new Symbol(sym.ID, yytext()); }
00487                     case -62:
00488                         break;
00489                     case 62:
00490                         { return new Symbol(sym.ID, yytext()); }
00491                     case -63:
00492                         break;
00493                     case 63:
00494                         { return new Symbol(sym.ID, yytext()); }
00495                     case -64:
00496                         break;
00497                     case 64:
00498                         { return new Symbol(sym.ID, yytext()); }
00499                     case -65:
00500                         break;
00501                     case 65:
00502                         { return new Symbol(sym.ID, yytext()); }
00503                     case -66:
00504                         break;
00505                     case 66:
00506                         { return new Symbol(sym.ID, yytext()); }
00507                     case -67:
00508                         break;
00509                     case 67:
00510                         { return new Symbol(sym.ID, yytext()); }
00511                     case -68:
00512                         break;
00513                     case 68:
00514                         { return new Symbol(sym.ID, yytext()); }
00515                     case -69:
00516                         break;
00517                     case 69:
00518                         { return new Symbol(sym.ID, yytext()); }
00519                     case -70:
00520                         break;
00521                     case 70:
00522                         { return new Symbol(sym.ID, yytext()); }
00523                     case -71:
00524                         break;
00525                     case 71:
00526                         { return new Symbol(sym.ID, yytext()); }
00527                     case -72:
00528                         break;
00529                     case 72:
00530                         { return new Symbol(sym.ID, yytext()); }
00531                     case -73:
00532                         break;
00533                     default:
00534                         yy_error(YY_E_INTERNAL,false);
00535                     case -1:
00536                     }
00537                     yy_initial = true;
00538                     yy_state = yy_state_dtrans[yy_lexical_state];
00539                     yy_next_state = YY_NO_STATE;
00540                     yy_last_accept_state = YY_NO_STATE;
00541                     yy_mark_start();
00542                     yy_this_accept = yy_acpt[yy_state];
00543                     if (YY_NOT_ACCEPT != yy_this_accept) {
00544                         yy_last_accept_state = yy_state;
00545                         yy_mark_end();
00546                     }
00547                 }
00548             }
00549         }
00550     }
00551     private int[][] unpackFromString(int size1, int size2, String st) {
00552         int colonIndex = -1;
00553         String lengthString;
00554         int sequenceLength = 0;
00555         int sequenceInteger = 0;
00556 
00557         int commaIndex;
00558         String workString;
00559 
00560         int res[][] = new int[size1][size2];
00561         for (int i= 0; i < size1; i++) {
00562             for (int j= 0; j < size2; j++) {
00563                 if (sequenceLength != 0) {
00564                     res[i][j] = sequenceInteger;
00565                     sequenceLength--;
00566                     continue;
00567                 }
00568                 commaIndex = st.indexOf(',');
00569                 workString = (commaIndex==-1) ? st :
00570                     st.substring(0, commaIndex);
00571                 st = st.substring(commaIndex+1);
00572                 colonIndex = workString.indexOf(':');
00573                 if (colonIndex == -1) {
00574                     res[i][j]=Integer.parseInt(workString);
00575                     continue;
00576                 }
00577                 lengthString =
00578                     workString.substring(colonIndex+1);
00579                 sequenceLength=Integer.parseInt(lengthString);
00580                 workString=workString.substring(0,colonIndex);
00581                 sequenceInteger=Integer.parseInt(workString);
00582                 res[i][j] = sequenceInteger;
00583                 sequenceLength--;
00584             }
00585         }
00586         return res;
00587     }
00588     private int yy_advance ()
00589         throws java.io.IOException {
00590         int next_read;
00591         int i;
00592         int j;
00593 
00594         if (yy_buffer_index < yy_buffer_read) {
00595             return yy_buffer[yy_buffer_index++];
00596         }
00597 
00598         if (0 != yy_buffer_start) {
00599             i = yy_buffer_start;
00600             j = 0;
00601             while (i < yy_buffer_read) {
00602                 yy_buffer[j] = yy_buffer[i];
00603                 ++i;
00604                 ++j;
00605             }
00606             yy_buffer_end = yy_buffer_end - yy_buffer_start;
00607             yy_buffer_start = 0;
00608             yy_buffer_read = j;
00609             yy_buffer_index = j;
00610             next_read = yy_reader.read(yy_buffer,
00611                     yy_buffer_read,
00612                     yy_buffer.length - yy_buffer_read);
00613             if (-1 == next_read) {
00614                 return YY_EOF;
00615             }
00616             yy_buffer_read = yy_buffer_read + next_read;
00617         }
00618 
00619         while (yy_buffer_index >= yy_buffer_read) {
00620             if (yy_buffer_index >= yy_buffer.length) {
00621                 yy_buffer = yy_double(yy_buffer);
00622             }
00623             next_read = yy_reader.read(yy_buffer,
00624                     yy_buffer_read,
00625                     yy_buffer.length - yy_buffer_read);
00626             if (-1 == next_read) {
00627                 return YY_EOF;
00628             }
00629             yy_buffer_read = yy_buffer_read + next_read;
00630         }
00631         return yy_buffer[yy_buffer_index++];
00632     }
00633     private char[] yy_double (char buf[]) {
00634         int i;
00635         char newbuf[];
00636         newbuf = new char[2*buf.length];
00637         for (i = 0; i < buf.length; ++i) {
00638             newbuf[i] = buf[i];
00639         }
00640         return newbuf;
00641     }
00642     private void yy_error (int code,boolean fatal) {
00643         java.lang.System.out.print(yy_error_string[code]);
00644         java.lang.System.out.flush();
00645         if (fatal) {
00646             throw new Error("Fatal Error.\n");
00647         }
00648     }
00649     private void yy_mark_end () {
00650         yy_buffer_end = yy_buffer_index;
00651     }
00652     private void yy_mark_start () {
00653         int i;
00654         for (i = yy_buffer_start; i < yy_buffer_index; ++i) {
00655             if ('\n' == yy_buffer[i] && !yy_last_was_cr) {
00656                 ++yyline;
00657             }
00658             if ('\r' == yy_buffer[i]) {
00659                 ++yyline;
00660                 yy_last_was_cr=true;
00661             } else yy_last_was_cr=false;
00662         }
00663         yy_buffer_start = yy_buffer_index;
00664     }
00665     private void yy_move_end () {
00666         if (yy_buffer_end > yy_buffer_start &&
00667             '\n' == yy_buffer[yy_buffer_end-1])
00668             yy_buffer_end--;
00669         if (yy_buffer_end > yy_buffer_start &&
00670             '\r' == yy_buffer[yy_buffer_end-1])
00671             yy_buffer_end--;
00672     }
00673     private void yy_to_mark () {
00674         yy_buffer_index = yy_buffer_end;
00675         yy_at_bol = (yy_buffer_end > yy_buffer_start) &&
00676                     ('\r' == yy_buffer[yy_buffer_end-1] ||
00677                      '\n' == yy_buffer[yy_buffer_end-1] ||
00678                      2028/*LS*/ == yy_buffer[yy_buffer_end-1] ||
00679                      2029/*PS*/ == yy_buffer[yy_buffer_end-1]);
00680     }
00681     private void yybegin (int state) {
00682         yy_lexical_state = state;
00683     }
00684     private int yylength () {
00685         return yy_buffer_end - yy_buffer_start;
00686     }
00687     private java.lang.String yytext () {
00688         return (new java.lang.String(yy_buffer,
00689             yy_buffer_start,
00690             yy_buffer_end - yy_buffer_start));
00691     }
00692 }