Main Page   Packages   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

ParserTokenManager.java

Go to the documentation of this file.
00001 /* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */
00002 package io;
00003 import obj.Polymesh;
00004 import obj.SceneGraphNode;
00005 import obj.Transform;
00006 import java.awt.Color;
00007 import java.io.FileInputStream;
00008 import java.io.File;
00009 import io.ParserInterface;
00010 import io.SpectreFileError;
00011 
00012 public class ParserTokenManager implements ParserConstants
00013 {
00014   public static  java.io.PrintStream debugStream = System.out;
00015   public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
00016 private static final int jjStopStringLiteralDfa_0(int pos, long active0)
00017 {
00018    switch (pos)
00019    {
00020       default :
00021          return -1;
00022    }
00023 }
00024 private static final int jjStartNfa_0(int pos, long active0)
00025 {
00026    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
00027 }
00028 static private final int jjStopAtPos(int pos, int kind)
00029 {
00030    jjmatchedKind = kind;
00031    jjmatchedPos = pos;
00032    return pos + 1;
00033 }
00034 static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
00035 {
00036    jjmatchedKind = kind;
00037    jjmatchedPos = pos;
00038    try { curChar = input_stream.readChar(); }
00039    catch(java.io.IOException e) { return pos + 1; }
00040    return jjMoveNfa_0(state, pos + 1);
00041 }
00042 static private final int jjMoveStringLiteralDfa0_0()
00043 {
00044    switch(curChar)
00045    {
00046       case 40:
00047          return jjStopAtPos(0, 23);
00048       case 41:
00049          return jjStopAtPos(0, 24);
00050       case 44:
00051          return jjStopAtPos(0, 22);
00052       case 67:
00053          return jjMoveStringLiteralDfa1_0(0x100L);
00054       case 78:
00055          return jjMoveStringLiteralDfa1_0(0x40L);
00056       case 80:
00057          return jjMoveStringLiteralDfa1_0(0x200L);
00058       case 83:
00059          return jjMoveStringLiteralDfa1_0(0x20L);
00060       case 84:
00061          return jjMoveStringLiteralDfa1_0(0x80L);
00062       case 101:
00063          return jjMoveStringLiteralDfa1_0(0x1000L);
00064       case 102:
00065          return jjMoveStringLiteralDfa1_0(0x800L);
00066       case 110:
00067          return jjMoveStringLiteralDfa1_0(0x200000L);
00068       case 118:
00069          return jjMoveStringLiteralDfa1_0(0x400L);
00070       case 123:
00071          return jjStopAtPos(0, 19);
00072       case 125:
00073          return jjStopAtPos(0, 20);
00074       default :
00075          return jjMoveNfa_0(0, 0);
00076    }
00077 }
00078 static private final int jjMoveStringLiteralDfa1_0(long active0)
00079 {
00080    try { curChar = input_stream.readChar(); }
00081    catch(java.io.IOException e) {
00082       jjStopStringLiteralDfa_0(0, active0);
00083       return 1;
00084    }
00085    switch(curChar)
00086    {
00087       case 80:
00088          return jjMoveStringLiteralDfa2_0(active0, 0x20L);
00089       case 97:
00090          return jjMoveStringLiteralDfa2_0(active0, 0x800L);
00091       case 100:
00092          return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
00093       case 101:
00094          return jjMoveStringLiteralDfa2_0(active0, 0x400L);
00095       case 111:
00096          return jjMoveStringLiteralDfa2_0(active0, 0x340L);
00097       case 114:
00098          return jjMoveStringLiteralDfa2_0(active0, 0x80L);
00099       case 117:
00100          return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
00101       default :
00102          break;
00103    }
00104    return jjStartNfa_0(0, active0);
00105 }
00106 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
00107 {
00108    if (((active0 &= old0)) == 0L)
00109       return jjStartNfa_0(0, old0); 
00110    try { curChar = input_stream.readChar(); }
00111    catch(java.io.IOException e) {
00112       jjStopStringLiteralDfa_0(1, active0);
00113       return 2;
00114    }
00115    switch(curChar)
00116    {
00117       case 69:
00118          return jjMoveStringLiteralDfa3_0(active0, 0x20L);
00119       case 97:
00120          return jjMoveStringLiteralDfa3_0(active0, 0x80L);
00121       case 99:
00122          return jjMoveStringLiteralDfa3_0(active0, 0x800L);
00123       case 100:
00124          return jjMoveStringLiteralDfa3_0(active0, 0x40L);
00125       case 103:
00126          return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
00127       case 108:
00128          return jjMoveStringLiteralDfa3_0(active0, 0x200300L);
00129       case 114:
00130          return jjMoveStringLiteralDfa3_0(active0, 0x400L);
00131       default :
00132          break;
00133    }
00134    return jjStartNfa_0(1, active0);
00135 }
00136 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
00137 {
00138    if (((active0 &= old0)) == 0L)
00139       return jjStartNfa_0(1, old0); 
00140    try { curChar = input_stream.readChar(); }
00141    catch(java.io.IOException e) {
00142       jjStopStringLiteralDfa_0(2, active0);
00143       return 3;
00144    }
00145    switch(curChar)
00146    {
00147       case 67:
00148          return jjMoveStringLiteralDfa4_0(active0, 0x20L);
00149       case 101:
00150          return jjMoveStringLiteralDfa4_0(active0, 0x1840L);
00151       case 108:
00152          if ((active0 & 0x200000L) != 0L)
00153             return jjStopAtPos(3, 21);
00154          break;
00155       case 110:
00156          return jjMoveStringLiteralDfa4_0(active0, 0x80L);
00157       case 111:
00158          return jjMoveStringLiteralDfa4_0(active0, 0x100L);
00159       case 116:
00160          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
00161       case 121:
00162          return jjMoveStringLiteralDfa4_0(active0, 0x200L);
00163       default :
00164          break;
00165    }
00166    return jjStartNfa_0(2, active0);
00167 }
00168 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
00169 {
00170    if (((active0 &= old0)) == 0L)
00171       return jjStartNfa_0(2, old0); 
00172    try { curChar = input_stream.readChar(); }
00173    catch(java.io.IOException e) {
00174       jjStopStringLiteralDfa_0(3, active0);
00175       return 4;
00176    }
00177    switch(curChar)
00178    {
00179       case 58:
00180          if ((active0 & 0x40L) != 0L)
00181             return jjStopAtPos(4, 6);
00182          break;
00183       case 76:
00184          return jjMoveStringLiteralDfa5_0(active0, 0x1800L);
00185       case 84:
00186          return jjMoveStringLiteralDfa5_0(active0, 0x20L);
00187       case 101:
00188          return jjMoveStringLiteralDfa5_0(active0, 0x400L);
00189       case 109:
00190          return jjMoveStringLiteralDfa5_0(active0, 0x200L);
00191       case 114:
00192          return jjMoveStringLiteralDfa5_0(active0, 0x100L);
00193       case 115:
00194          return jjMoveStringLiteralDfa5_0(active0, 0x80L);
00195       default :
00196          break;
00197    }
00198    return jjStartNfa_0(3, active0);
00199 }
00200 static private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
00201 {
00202    if (((active0 &= old0)) == 0L)
00203       return jjStartNfa_0(3, old0); 
00204    try { curChar = input_stream.readChar(); }
00205    catch(java.io.IOException e) {
00206       jjStopStringLiteralDfa_0(4, active0);
00207       return 5;
00208    }
00209    switch(curChar)
00210    {
00211       case 58:
00212          if ((active0 & 0x100L) != 0L)
00213             return jjStopAtPos(5, 8);
00214          break;
00215       case 82:
00216          return jjMoveStringLiteralDfa6_0(active0, 0x20L);
00217       case 101:
00218          return jjMoveStringLiteralDfa6_0(active0, 0x200L);
00219       case 102:
00220          return jjMoveStringLiteralDfa6_0(active0, 0x80L);
00221       case 105:
00222          return jjMoveStringLiteralDfa6_0(active0, 0x1800L);
00223       case 120:
00224          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
00225       default :
00226          break;
00227    }
00228    return jjStartNfa_0(4, active0);
00229 }
00230 static private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
00231 {
00232    if (((active0 &= old0)) == 0L)
00233       return jjStartNfa_0(4, old0); 
00234    try { curChar = input_stream.readChar(); }
00235    catch(java.io.IOException e) {
00236       jjStopStringLiteralDfa_0(5, active0);
00237       return 6;
00238    }
00239    switch(curChar)
00240    {
00241       case 69:
00242          if ((active0 & 0x20L) != 0L)
00243             return jjStopAtPos(6, 5);
00244          break;
00245       case 76:
00246          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
00247       case 111:
00248          return jjMoveStringLiteralDfa7_0(active0, 0x80L);
00249       case 115:
00250          return jjMoveStringLiteralDfa7_0(active0, 0x1a00L);
00251       default :
00252          break;
00253    }
00254    return jjStartNfa_0(5, active0);
00255 }
00256 static private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
00257 {
00258    if (((active0 &= old0)) == 0L)
00259       return jjStartNfa_0(5, old0); 
00260    try { curChar = input_stream.readChar(); }
00261    catch(java.io.IOException e) {
00262       jjStopStringLiteralDfa_0(6, active0);
00263       return 7;
00264    }
00265    switch(curChar)
00266    {
00267       case 104:
00268          return jjMoveStringLiteralDfa8_0(active0, 0x200L);
00269       case 105:
00270          return jjMoveStringLiteralDfa8_0(active0, 0x400L);
00271       case 114:
00272          return jjMoveStringLiteralDfa8_0(active0, 0x80L);
00273       case 116:
00274          return jjMoveStringLiteralDfa8_0(active0, 0x1800L);
00275       default :
00276          break;
00277    }
00278    return jjStartNfa_0(6, active0);
00279 }
00280 static private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
00281 {
00282    if (((active0 &= old0)) == 0L)
00283       return jjStartNfa_0(6, old0); 
00284    try { curChar = input_stream.readChar(); }
00285    catch(java.io.IOException e) {
00286       jjStopStringLiteralDfa_0(7, active0);
00287       return 8;
00288    }
00289    switch(curChar)
00290    {
00291       case 58:
00292          if ((active0 & 0x200L) != 0L)
00293             return jjStopAtPos(8, 9);
00294          else if ((active0 & 0x800L) != 0L)
00295             return jjStopAtPos(8, 11);
00296          else if ((active0 & 0x1000L) != 0L)
00297             return jjStopAtPos(8, 12);
00298          break;
00299       case 109:
00300          return jjMoveStringLiteralDfa9_0(active0, 0x80L);
00301       case 115:
00302          return jjMoveStringLiteralDfa9_0(active0, 0x400L);
00303       default :
00304          break;
00305    }
00306    return jjStartNfa_0(7, active0);
00307 }
00308 static private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
00309 {
00310    if (((active0 &= old0)) == 0L)
00311       return jjStartNfa_0(7, old0); 
00312    try { curChar = input_stream.readChar(); }
00313    catch(java.io.IOException e) {
00314       jjStopStringLiteralDfa_0(8, active0);
00315       return 9;
00316    }
00317    switch(curChar)
00318    {
00319       case 58:
00320          if ((active0 & 0x80L) != 0L)
00321             return jjStopAtPos(9, 7);
00322          break;
00323       case 116:
00324          return jjMoveStringLiteralDfa10_0(active0, 0x400L);
00325       default :
00326          break;
00327    }
00328    return jjStartNfa_0(8, active0);
00329 }
00330 static private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
00331 {
00332    if (((active0 &= old0)) == 0L)
00333       return jjStartNfa_0(8, old0); 
00334    try { curChar = input_stream.readChar(); }
00335    catch(java.io.IOException e) {
00336       jjStopStringLiteralDfa_0(9, active0);
00337       return 10;
00338    }
00339    switch(curChar)
00340    {
00341       case 58:
00342          if ((active0 & 0x400L) != 0L)
00343             return jjStopAtPos(10, 10);
00344          break;
00345       default :
00346          break;
00347    }
00348    return jjStartNfa_0(9, active0);
00349 }
00350 static private final void jjCheckNAdd(int state)
00351 {
00352    if (jjrounds[state] != jjround)
00353    {
00354       jjstateSet[jjnewStateCnt++] = state;
00355       jjrounds[state] = jjround;
00356    }
00357 }
00358 static private final void jjAddStates(int start, int end)
00359 {
00360    do {
00361       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
00362    } while (start++ != end);
00363 }
00364 static private final void jjCheckNAddTwoStates(int state1, int state2)
00365 {
00366    jjCheckNAdd(state1);
00367    jjCheckNAdd(state2);
00368 }
00369 static private final void jjCheckNAddStates(int start, int end)
00370 {
00371    do {
00372       jjCheckNAdd(jjnextStates[start]);
00373    } while (start++ != end);
00374 }
00375 static private final void jjCheckNAddStates(int start)
00376 {
00377    jjCheckNAdd(jjnextStates[start]);
00378    jjCheckNAdd(jjnextStates[start + 1]);
00379 }
00380 static private final int jjMoveNfa_0(int startState, int curPos)
00381 {
00382    int[] nextStates;
00383    int startsAt = 0;
00384    jjnewStateCnt = 18;
00385    int i = 1;
00386    jjstateSet[0] = startState;
00387    int j, kind = 0x7fffffff;
00388    for (;;)
00389    {
00390       if (++jjround == 0x7fffffff)
00391          ReInitRounds();
00392       if (curChar < 64)
00393       {
00394          long l = 1L << curChar;
00395          MatchLoop: do
00396          {
00397             switch(jjstateSet[--i])
00398             {
00399                case 0:
00400                   if ((0x3ff000000000000L & l) != 0L)
00401                   {
00402                      if (kind > 13)
00403                         kind = 13;
00404                      jjCheckNAddStates(0, 6);
00405                   }
00406                   else if ((0x280000000000L & l) != 0L)
00407                      jjCheckNAddStates(7, 12);
00408                   else if (curChar == 46)
00409                      jjCheckNAddTwoStates(1, 5);
00410                   break;
00411                case 1:
00412                   if ((0x3ff000000000000L & l) != 0L)
00413                      jjCheckNAddTwoStates(1, 2);
00414                   break;
00415                case 3:
00416                   if ((0x280000000000L & l) != 0L)
00417                      jjCheckNAdd(4);
00418                   break;
00419                case 4:
00420                   if ((0x3ff000000000000L & l) == 0L)
00421                      break;
00422                   if (kind > 13)
00423                      kind = 13;
00424                   jjCheckNAdd(4);
00425                   break;
00426                case 5:
00427                   if ((0x3ff000000000000L & l) == 0L)
00428                      break;
00429                   if (kind > 13)
00430                      kind = 13;
00431                   jjCheckNAdd(5);
00432                   break;
00433                case 6:
00434                   if ((0x280000000000L & l) != 0L)
00435                      jjCheckNAddStates(7, 12);
00436                   break;
00437                case 7:
00438                   if ((0x3ff000000000000L & l) != 0L)
00439                      jjCheckNAddTwoStates(7, 2);
00440                   break;
00441                case 8:
00442                   if ((0x3ff000000000000L & l) != 0L)
00443                      jjCheckNAddStates(13, 15);
00444                   break;
00445                case 9:
00446                   if (curChar == 46)
00447                      jjCheckNAdd(10);
00448                   break;
00449                case 10:
00450                   if ((0x3ff000000000000L & l) != 0L)
00451                      jjCheckNAddTwoStates(10, 2);
00452                   break;
00453                case 11:
00454                   if (curChar == 46)
00455                      jjCheckNAdd(1);
00456                   break;
00457                case 12:
00458                   if (curChar == 46)
00459                      jjCheckNAdd(5);
00460                   break;
00461                case 13:
00462                   if ((0x3ff000000000000L & l) == 0L)
00463                      break;
00464                   if (kind > 13)
00465                      kind = 13;
00466                   jjCheckNAddTwoStates(13, 14);
00467                   break;
00468                case 14:
00469                   if (curChar == 46)
00470                      jjCheckNAdd(15);
00471                   break;
00472                case 15:
00473                   if ((0x3ff000000000000L & l) == 0L)
00474                      break;
00475                   if (kind > 13)
00476                      kind = 13;
00477                   jjCheckNAdd(15);
00478                   break;
00479                case 16:
00480                   if ((0x3ff000000000000L & l) == 0L)
00481                      break;
00482                   if (kind > 13)
00483                      kind = 13;
00484                   jjCheckNAdd(16);
00485                   break;
00486                case 17:
00487                   if ((0x3ff000000000000L & l) == 0L)
00488                      break;
00489                   if (kind > 13)
00490                      kind = 13;
00491                   jjCheckNAddStates(0, 6);
00492                   break;
00493                default : break;
00494             }
00495          } while(i != startsAt);
00496       }
00497       else if (curChar < 128)
00498       {
00499          long l = 1L << (curChar & 077);
00500          MatchLoop: do
00501          {
00502             switch(jjstateSet[--i])
00503             {
00504                case 2:
00505                   if ((0x2000000020L & l) != 0L)
00506                      jjAddStates(16, 17);
00507                   break;
00508                default : break;
00509             }
00510          } while(i != startsAt);
00511       }
00512       else
00513       {
00514          int i2 = (curChar & 0xff) >> 6;
00515          long l2 = 1L << (curChar & 077);
00516          MatchLoop: do
00517          {
00518             switch(jjstateSet[--i])
00519             {
00520                default : break;
00521             }
00522          } while(i != startsAt);
00523       }
00524       if (kind != 0x7fffffff)
00525       {
00526          jjmatchedKind = kind;
00527          jjmatchedPos = curPos;
00528          kind = 0x7fffffff;
00529       }
00530       ++curPos;
00531       if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
00532          return curPos;
00533       try { curChar = input_stream.readChar(); }
00534       catch(java.io.IOException e) { return curPos; }
00535    }
00536 }
00537 static final int[] jjnextStates = {
00538    7, 8, 9, 2, 13, 14, 16, 7, 8, 11, 12, 13, 16, 8, 9, 2, 
00539    3, 4, 
00540 };
00541 public static final String[] jjstrLiteralImages = {
00542 "", null, null, null, null, "\123\120\105\103\124\122\105", 
00543 "\116\157\144\145\72", "\124\162\141\156\163\146\157\162\155\72", "\103\157\154\157\162\72", 
00544 "\120\157\154\171\155\145\163\150\72", "\166\145\162\164\145\170\114\151\163\164\72", 
00545 "\146\141\143\145\114\151\163\164\72", "\145\144\147\145\114\151\163\164\72", null, null, null, null, null, null, 
00546 "\173", "\175", "\156\165\154\154", "\54", "\50", "\51", };
00547 public static final String[] lexStateNames = {
00548    "DEFAULT", 
00549 };
00550 static final long[] jjtoToken = {
00551    0x1f83fe1L, 
00552 };
00553 static final long[] jjtoSkip = {
00554    0x1eL, 
00555 };
00556 static private SimpleCharStream input_stream;
00557 static private final int[] jjrounds = new int[18];
00558 static private final int[] jjstateSet = new int[36];
00559 static protected char curChar;
00560 public ParserTokenManager(SimpleCharStream stream)
00561 {
00562    if (input_stream != null)
00563       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
00564    input_stream = stream;
00565 }
00566 public ParserTokenManager(SimpleCharStream stream, int lexState)
00567 {
00568    this(stream);
00569    SwitchTo(lexState);
00570 }
00571 static public void ReInit(SimpleCharStream stream)
00572 {
00573    jjmatchedPos = jjnewStateCnt = 0;
00574    curLexState = defaultLexState;
00575    input_stream = stream;
00576    ReInitRounds();
00577 }
00578 static private final void ReInitRounds()
00579 {
00580    int i;
00581    jjround = 0x80000001;
00582    for (i = 18; i-- > 0;)
00583       jjrounds[i] = 0x80000000;
00584 }
00585 static public void ReInit(SimpleCharStream stream, int lexState)
00586 {
00587    ReInit(stream);
00588    SwitchTo(lexState);
00589 }
00590 static public void SwitchTo(int lexState)
00591 {
00592    if (lexState >= 1 || lexState < 0)
00593       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
00594    else
00595       curLexState = lexState;
00596 }
00597 
00598 static private final Token jjFillToken()
00599 {
00600    Token t = Token.newToken(jjmatchedKind);
00601    t.kind = jjmatchedKind;
00602    String im = jjstrLiteralImages[jjmatchedKind];
00603    t.image = (im == null) ? input_stream.GetImage() : im;
00604    t.beginLine = input_stream.getBeginLine();
00605    t.beginColumn = input_stream.getBeginColumn();
00606    t.endLine = input_stream.getEndLine();
00607    t.endColumn = input_stream.getEndColumn();
00608    return t;
00609 }
00610 
00611 static int curLexState = 0;
00612 static int defaultLexState = 0;
00613 static int jjnewStateCnt;
00614 static int jjround;
00615 static int jjmatchedPos;
00616 static int jjmatchedKind;
00617 
00618 public static final Token getNextToken() 
00619 {
00620   int kind;
00621   Token specialToken = null;
00622   Token matchedToken;
00623   int curPos = 0;
00624 
00625   EOFLoop :
00626   for (;;)
00627   {   
00628    try   
00629    {     
00630       curChar = input_stream.BeginToken();
00631    }     
00632    catch(java.io.IOException e)
00633    {        
00634       jjmatchedKind = 0;
00635       matchedToken = jjFillToken();
00636       return matchedToken;
00637    }
00638 
00639    try { input_stream.backup(0);
00640       while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
00641          curChar = input_stream.BeginToken();
00642    }
00643    catch (java.io.IOException e1) { continue EOFLoop; }
00644    jjmatchedKind = 0x7fffffff;
00645    jjmatchedPos = 0;
00646    curPos = jjMoveStringLiteralDfa0_0();
00647    if (jjmatchedKind != 0x7fffffff)
00648    {
00649       if (jjmatchedPos + 1 < curPos)
00650          input_stream.backup(curPos - jjmatchedPos - 1);
00651       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00652       {
00653          matchedToken = jjFillToken();
00654          return matchedToken;
00655       }
00656       else
00657       {
00658          continue EOFLoop;
00659       }
00660    }
00661    int error_line = input_stream.getEndLine();
00662    int error_column = input_stream.getEndColumn();
00663    String error_after = null;
00664    boolean EOFSeen = false;
00665    try { input_stream.readChar(); input_stream.backup(1); }
00666    catch (java.io.IOException e1) {
00667       EOFSeen = true;
00668       error_after = curPos <= 1 ? "" : input_stream.GetImage();
00669       if (curChar == '\n' || curChar == '\r') {
00670          error_line++;
00671          error_column = 0;
00672       }
00673       else
00674          error_column++;
00675    }
00676    if (!EOFSeen) {
00677       input_stream.backup(1);
00678       error_after = curPos <= 1 ? "" : input_stream.GetImage();
00679    }
00680    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
00681   }
00682 }
00683 
00684 }

Generated on Mon May 5 20:54:36 2003 for SPECTRE by doxygen1.2.17