home *** CD-ROM | disk | FTP | other *** search
/ Tutto per Internet / Internet.iso / soft95 / Java / espints / espinst.exe / classes / espresso / Scanner.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-02-28  |  12.0 KB  |  931 lines
  1. package espresso;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5.  
  6. class Scanner implements Constants {
  7.    private static Name[] symName = new Name[112];
  8.    private static Name slashEqualsS = Name.fromString("/=");
  9.    private static Name slashS = Name.fromString("/");
  10.    private int litlen;
  11.    private byte[] lit = new byte[64];
  12.    private int ccol;
  13.    private int cline;
  14.    // $FF: renamed from: ch byte
  15.    private byte field_0;
  16.    // $FF: renamed from: bp int
  17.    private int field_1;
  18.    private byte[] buf;
  19.    int errPos = -1;
  20.    double floatVal;
  21.    long intVal;
  22.    Name name;
  23.    int lastpos = 0;
  24.    int pos = 0;
  25.    int sym;
  26.    private static int extendedMaxKey;
  27.    private static int standardMaxKey;
  28.    private static byte[] key;
  29.    private static int maxKey = 0;
  30.    static final byte SUB = 26;
  31.    // $FF: renamed from: CR byte
  32.    static final byte field_2 = 13;
  33.    // $FF: renamed from: FF byte
  34.    static final byte field_3 = 12;
  35.    // $FF: renamed from: LF byte
  36.    static final byte field_4 = 10;
  37.    static final int tabinc = 8;
  38.  
  39.    static {
  40.       for(int var0 = 0; var0 <= 111; ++var0) {
  41.          symName[var0] = null;
  42.       }
  43.  
  44.       enterKeyword("+", 20);
  45.       enterKeyword("-", 21);
  46.       enterKeyword("!", 22);
  47.       enterKeyword("%", 23);
  48.       enterKeyword("^", 24);
  49.       enterKeyword("&", 25);
  50.       enterKeyword("*", 26);
  51.       enterKeyword("|", 27);
  52.       enterKeyword("~", 28);
  53.       enterKeyword("/", 29);
  54.       enterKeyword(">", 30);
  55.       enterKeyword("<", 31);
  56.       enterKeyword("?", 32);
  57.       enterKeyword(":", 33);
  58.       enterKeyword("=", 34);
  59.       enterKeyword("++", 35);
  60.       enterKeyword("--", 36);
  61.       enterKeyword("==", 37);
  62.       enterKeyword("<=", 38);
  63.       enterKeyword(">=", 39);
  64.       enterKeyword("!=", 40);
  65.       enterKeyword("<<", 41);
  66.       enterKeyword(">>", 42);
  67.       enterKeyword(">>>", 43);
  68.       enterKeyword("+=", 44);
  69.       enterKeyword("-=", 45);
  70.       enterKeyword("*=", 46);
  71.       enterKeyword("/=", 47);
  72.       enterKeyword("&=", 48);
  73.       enterKeyword("|=", 49);
  74.       enterKeyword("^=", 50);
  75.       enterKeyword("%=", 51);
  76.       enterKeyword("<<=", 52);
  77.       enterKeyword(">>=", 53);
  78.       enterKeyword(">>>=", 54);
  79.       enterKeyword("||", 55);
  80.       enterKeyword("&&", 56);
  81.       enterKeyword("abstract", 60);
  82.       enterKeyword("break", 61);
  83.       enterKeyword("case", 62);
  84.       enterKeyword("catch", 63);
  85.       enterKeyword("class", 64);
  86.       enterKeyword("const", 65);
  87.       enterKeyword("continue", 66);
  88.       enterKeyword("default", 67);
  89.       enterKeyword("do", 68);
  90.       enterKeyword("else", 69);
  91.       enterKeyword("extends", 70);
  92.       enterKeyword("final", 71);
  93.       enterKeyword("finally", 72);
  94.       enterKeyword("for", 73);
  95.       enterKeyword("if", 74);
  96.       enterKeyword("implements", 75);
  97.       enterKeyword("import", 76);
  98.       enterKeyword("interface", 77);
  99.       enterKeyword("native", 78);
  100.       enterKeyword("new", 79);
  101.       enterKeyword("package", 80);
  102.       enterKeyword("private", 81);
  103.       enterKeyword("protected", 82);
  104.       enterKeyword("public", 83);
  105.       enterKeyword("return", 84);
  106.       enterKeyword("static", 85);
  107.       enterKeyword("super", 86);
  108.       enterKeyword("switch", 87);
  109.       enterKeyword("synchronized", 88);
  110.       enterKeyword("this", 89);
  111.       enterKeyword("threadsafe", 90);
  112.       enterKeyword("throw", 91);
  113.       enterKeyword("throws", 92);
  114.       enterKeyword("transient", 93);
  115.       enterKeyword("try", 94);
  116.       enterKeyword("while", 95);
  117.       enterKeyword("instanceof", 96);
  118.       enterKeyword("boolean", 97);
  119.       enterKeyword("byte", 98);
  120.       enterKeyword("char", 99);
  121.       enterKeyword("double", 100);
  122.       enterKeyword("float", 101);
  123.       enterKeyword("int", 102);
  124.       enterKeyword("long", 103);
  125.       enterKeyword("short", 104);
  126.       enterKeyword("void", 105);
  127.       enterKeyword("null", 106);
  128.       standardMaxKey = maxKey;
  129.       enterKeyword("fun", 107);
  130.       enterKeyword("seq", 108);
  131.       enterKeyword("->", 109);
  132.       extendedMaxKey = maxKey;
  133.       key = new byte[maxKey + 1];
  134.  
  135.       for(int var1 = 0; var1 <= maxKey; ++var1) {
  136.          key[var1] = 1;
  137.       }
  138.  
  139.       for(int var2 = 0; var2 <= 111; ++var2) {
  140.          if (symName[var2] != null) {
  141.             key[symName[var2].index] = (byte)var2;
  142.          }
  143.       }
  144.  
  145.    }
  146.  
  147.    private static void enterKeyword(String var0, int var1) {
  148.       Name var2 = Name.fromString(var0);
  149.       symName[var1] = var2;
  150.       if (var2.index > maxKey) {
  151.          maxKey = var2.index;
  152.       }
  153.  
  154.    }
  155.  
  156.    String sym2string(int var1) {
  157.       switch (var1) {
  158.          case 1:
  159.             return "<identifier>";
  160.          case 2:
  161.             return "<character>";
  162.          case 3:
  163.             return "<string>";
  164.          case 4:
  165.             return "<integer>";
  166.          case 5:
  167.             return "<long integer>";
  168.          case 6:
  169.             return "<float>";
  170.          case 7:
  171.             return "<double>";
  172.          case 10:
  173.             return "'.'";
  174.          case 11:
  175.             return "','";
  176.          case 12:
  177.             return "';'";
  178.          case 13:
  179.             return "'('";
  180.          case 14:
  181.             return "')'";
  182.          case 15:
  183.             return "'['";
  184.          case 16:
  185.             return "']'";
  186.          case 17:
  187.             return "'{'";
  188.          case 18:
  189.             return "'}'";
  190.          case 110:
  191.             return "<bad symbol>";
  192.          case 111:
  193.             return "<end of input>";
  194.          default:
  195.             return symName[var1].toString();
  196.       }
  197.    }
  198.  
  199.    void nextsym() {
  200.       this.lastpos = (this.cline << 10) + this.ccol;
  201.  
  202.       label171:
  203.       while(true) {
  204.          boolean var1 = false;
  205.          this.pos = (this.cline << 10) + this.ccol;
  206.          int var2 = this.field_1;
  207.          switch (this.field_0) {
  208.             case 9:
  209.                this.ccol = (this.ccol - 1) / 8 * 8 + 8;
  210.                this.field_0 = this.buf[++this.field_1];
  211.                ++this.ccol;
  212.                break;
  213.             case 10:
  214.             case 12:
  215.                ++this.cline;
  216.                this.ccol = 0;
  217.                this.field_0 = this.buf[++this.field_1];
  218.                ++this.ccol;
  219.                break;
  220.             case 11:
  221.             case 14:
  222.             case 15:
  223.             case 16:
  224.             case 17:
  225.             case 18:
  226.             case 19:
  227.             case 20:
  228.             case 21:
  229.             case 22:
  230.             case 23:
  231.             case 24:
  232.             case 25:
  233.             case 27:
  234.             case 28:
  235.             case 29:
  236.             case 30:
  237.             case 31:
  238.             case 33:
  239.             case 35:
  240.             case 37:
  241.             case 38:
  242.             case 42:
  243.             case 43:
  244.             case 45:
  245.             case 58:
  246.             case 60:
  247.             case 61:
  248.             case 62:
  249.             case 63:
  250.             case 64:
  251.             case 94:
  252.             case 96:
  253.             case 124:
  254.             default:
  255.                if (this.isspecial(this.field_0)) {
  256.                   this.getspecials();
  257.                } else {
  258.                   this.field_0 = this.buf[++this.field_1];
  259.                   ++this.ccol;
  260.                   this.lexError("illegal character");
  261.                }
  262.  
  263.                return;
  264.             case 13:
  265.                ++this.cline;
  266.                this.ccol = 0;
  267.                this.field_0 = this.buf[++this.field_1];
  268.                ++this.ccol;
  269.                if (this.field_0 == 10) {
  270.                   this.ccol = 0;
  271.                   this.field_0 = this.buf[++this.field_1];
  272.                   ++this.ccol;
  273.                }
  274.                break;
  275.             case 26:
  276.                this.sym = 111;
  277.                return;
  278.             case 32:
  279.                this.field_0 = this.buf[++this.field_1];
  280.                ++this.ccol;
  281.                break;
  282.             case 34:
  283.                this.field_0 = this.buf[++this.field_1];
  284.                ++this.ccol;
  285.                this.litlen = 0;
  286.  
  287.                while(this.field_0 != 34 && (char)this.field_0 >= ' ') {
  288.                   this.getlitch();
  289.                }
  290.  
  291.                if (this.field_0 == 34) {
  292.                   this.sym = 3;
  293.                   this.name = Name.fromSource(this.lit, 0, this.litlen);
  294.                   this.field_0 = this.buf[++this.field_1];
  295.                   ++this.ccol;
  296.                } else {
  297.                   this.lexError("unclosed character literal");
  298.                }
  299.  
  300.                return;
  301.             case 39:
  302.                this.field_0 = this.buf[++this.field_1];
  303.                ++this.ccol;
  304.                this.litlen = 0;
  305.                this.getlitch();
  306.                if (this.field_0 == 39) {
  307.                   this.field_0 = this.buf[++this.field_1];
  308.                   ++this.ccol;
  309.                   this.sym = 2;
  310.                   byte[] var3 = new byte[this.litlen];
  311.                   int var4 = Convert.source2ascii(this.lit, 0, this.litlen, var3);
  312.                   this.intVal = (long)Convert.ascii2string(var3, 0, var4).charAt(0);
  313.                } else {
  314.                   this.lexError("unclosed character literal");
  315.                }
  316.  
  317.                return;
  318.             case 40:
  319.                this.field_0 = this.buf[++this.field_1];
  320.                ++this.ccol;
  321.                this.sym = 13;
  322.                return;
  323.             case 41:
  324.                this.field_0 = this.buf[++this.field_1];
  325.                ++this.ccol;
  326.                this.sym = 14;
  327.                return;
  328.             case 44:
  329.                this.field_0 = this.buf[++this.field_1];
  330.                ++this.ccol;
  331.                this.sym = 11;
  332.                return;
  333.             case 46:
  334.                this.field_0 = this.buf[++this.field_1];
  335.                ++this.ccol;
  336.                if (48 <= this.field_0 && this.field_0 <= 57) {
  337.                   this.getfraction(var2);
  338.                } else {
  339.                   this.sym = 10;
  340.                }
  341.  
  342.                return;
  343.             case 47:
  344.                this.field_0 = this.buf[++this.field_1];
  345.                ++this.ccol;
  346.                if (this.field_0 == 47) {
  347.                   while(true) {
  348.                      this.field_0 = this.buf[++this.field_1];
  349.                      ++this.ccol;
  350.                      if (this.field_0 == 13 || this.field_0 == 10 || this.field_0 == 26) {
  351.                         continue label171;
  352.                      }
  353.                   }
  354.                } else {
  355.                   if (this.field_0 != 42) {
  356.                      if (this.field_0 == 61) {
  357.                         this.name = slashEqualsS;
  358.                         this.sym = 47;
  359.                         this.field_0 = this.buf[++this.field_1];
  360.                         ++this.ccol;
  361.                      } else {
  362.                         this.name = slashS;
  363.                         this.sym = 29;
  364.                      }
  365.  
  366.                      return;
  367.                   }
  368.  
  369.                   while(true) {
  370.                      if (this.field_0 == 13) {
  371.                         ++this.cline;
  372.                         this.ccol = 0;
  373.                         this.field_0 = this.buf[++this.field_1];
  374.                         ++this.ccol;
  375.                         if (this.field_0 == 10) {
  376.                            this.ccol = 0;
  377.                            this.field_0 = this.buf[++this.field_1];
  378.                            ++this.ccol;
  379.                         }
  380.                      } else if (this.field_0 == 10) {
  381.                         ++this.cline;
  382.                         this.ccol = 0;
  383.                         this.field_0 = this.buf[++this.field_1];
  384.                         ++this.ccol;
  385.                      } else if (this.field_0 == 9) {
  386.                         this.ccol = (this.ccol - 1) / 8 * 8 + 8;
  387.                         this.field_0 = this.buf[++this.field_1];
  388.                         ++this.ccol;
  389.                      } else {
  390.                         this.field_0 = this.buf[++this.field_1];
  391.                         ++this.ccol;
  392.                      }
  393.  
  394.                      if (this.field_0 == 42 || this.field_0 == 26) {
  395.                         while(this.field_0 == 42) {
  396.                            this.field_0 = this.buf[++this.field_1];
  397.                            ++this.ccol;
  398.                         }
  399.  
  400.                         if (this.field_0 == 47 || this.field_0 == 26) {
  401.                            if (this.field_0 != 47) {
  402.                               this.lexError("unclosed comment");
  403.                               return;
  404.                            }
  405.  
  406.                            this.field_0 = this.buf[++this.field_1];
  407.                            ++this.ccol;
  408.                            continue label171;
  409.                         }
  410.                      }
  411.                   }
  412.                }
  413.             case 48:
  414.                this.field_0 = this.buf[++this.field_1];
  415.                ++this.ccol;
  416.                if (this.field_0 == 120) {
  417.                   this.field_0 = this.buf[++this.field_1];
  418.                   ++this.ccol;
  419.                   this.getnumber(var2 + 2, 16);
  420.                } else {
  421.                   this.getnumber(var2, 8);
  422.                }
  423.  
  424.                return;
  425.             case 49:
  426.             case 50:
  427.             case 51:
  428.             case 52:
  429.             case 53:
  430.             case 54:
  431.             case 55:
  432.             case 56:
  433.             case 57:
  434.                this.getnumber(var2, 10);
  435.                return;
  436.             case 59:
  437.                this.field_0 = this.buf[++this.field_1];
  438.                ++this.ccol;
  439.                this.sym = 12;
  440.                return;
  441.             case 91:
  442.                this.field_0 = this.buf[++this.field_1];
  443.                ++this.ccol;
  444.                this.sym = 15;
  445.                return;
  446.             case 92:
  447.                if (!this.isUnicode()) {
  448.                   this.field_0 = this.buf[++this.field_1];
  449.                   ++this.ccol;
  450.                   this.lexError("illegal character");
  451.                   return;
  452.                }
  453.  
  454.                var1 = true;
  455.                this.field_0 = this.buf[++this.field_1];
  456.                ++this.ccol;
  457.                this.field_0 = this.buf[++this.field_1];
  458.                ++this.ccol;
  459.                this.field_0 = this.buf[++this.field_1];
  460.                ++this.ccol;
  461.                this.field_0 = this.buf[++this.field_1];
  462.                ++this.ccol;
  463.                this.field_0 = this.buf[++this.field_1];
  464.                ++this.ccol;
  465.                this.field_0 = 65;
  466.             case 36:
  467.             case 65:
  468.             case 66:
  469.             case 67:
  470.             case 68:
  471.             case 69:
  472.             case 70:
  473.             case 71:
  474.             case 72:
  475.             case 73:
  476.             case 74:
  477.             case 75:
  478.             case 76:
  479.             case 77:
  480.             case 78:
  481.             case 79:
  482.             case 80:
  483.             case 81:
  484.             case 82:
  485.             case 83:
  486.             case 84:
  487.             case 85:
  488.             case 86:
  489.             case 87:
  490.             case 88:
  491.             case 89:
  492.             case 90:
  493.             case 95:
  494.             case 97:
  495.             case 98:
  496.             case 99:
  497.             case 100:
  498.             case 101:
  499.             case 102:
  500.             case 103:
  501.             case 104:
  502.             case 105:
  503.             case 106:
  504.             case 107:
  505.             case 108:
  506.             case 109:
  507.             case 110:
  508.             case 111:
  509.             case 112:
  510.             case 113:
  511.             case 114:
  512.             case 115:
  513.             case 116:
  514.             case 117:
  515.             case 118:
  516.             case 119:
  517.             case 120:
  518.             case 121:
  519.             case 122:
  520.                while(true) {
  521.                   this.field_0 = this.buf[++this.field_1];
  522.                   ++this.ccol;
  523.                   switch (this.field_0) {
  524.                      case 36:
  525.                      case 48:
  526.                      case 49:
  527.                      case 50:
  528.                      case 51:
  529.                      case 52:
  530.                      case 53:
  531.                      case 54:
  532.                      case 55:
  533.                      case 56:
  534.                      case 57:
  535.                      case 65:
  536.                      case 66:
  537.                      case 67:
  538.                      case 68:
  539.                      case 69:
  540.                      case 70:
  541.                      case 71:
  542.                      case 72:
  543.                      case 73:
  544.                      case 74:
  545.                      case 75:
  546.                      case 76:
  547.                      case 77:
  548.                      case 78:
  549.                      case 79:
  550.                      case 80:
  551.                      case 81:
  552.                      case 82:
  553.                      case 83:
  554.                      case 84:
  555.                      case 85:
  556.                      case 86:
  557.                      case 87:
  558.                      case 88:
  559.                      case 89:
  560.                      case 90:
  561.                      case 95:
  562.                      case 97:
  563.                      case 98:
  564.                      case 99:
  565.                      case 100:
  566.                      case 101:
  567.                      case 102:
  568.                      case 103:
  569.                      case 104:
  570.                      case 105:
  571.                      case 106:
  572.                      case 107:
  573.                      case 108:
  574.                      case 109:
  575.                      case 110:
  576.                      case 111:
  577.                      case 112:
  578.                      case 113:
  579.                      case 114:
  580.                      case 115:
  581.                      case 116:
  582.                      case 117:
  583.                      case 118:
  584.                      case 119:
  585.                      case 120:
  586.                      case 121:
  587.                      case 122:
  588.                         continue;
  589.                      case 37:
  590.                      case 38:
  591.                      case 39:
  592.                      case 40:
  593.                      case 41:
  594.                      case 42:
  595.                      case 43:
  596.                      case 44:
  597.                      case 45:
  598.                      case 46:
  599.                      case 47:
  600.                      case 58:
  601.                      case 59:
  602.                      case 60:
  603.                      case 61:
  604.                      case 62:
  605.                      case 63:
  606.                      case 64:
  607.                      case 91:
  608.                      case 93:
  609.                      case 94:
  610.                      case 96:
  611.                      default:
  612.                         if (this.field_0 >= 0) {
  613.                            if (var1) {
  614.                               this.name = Name.fromSource(this.buf, var2, this.field_1 - var2);
  615.                            } else {
  616.                               this.name = Name.fromAscii(this.buf, var2, this.field_1 - var2);
  617.                            }
  618.  
  619.                            if (this.name.index <= maxKey) {
  620.                               this.sym = key[this.name.index];
  621.                            } else {
  622.                               this.sym = 1;
  623.                            }
  624.  
  625.                            return;
  626.                         }
  627.                         continue;
  628.                      case 92:
  629.                   }
  630.  
  631.                   if (!this.isUnicode()) {
  632.                      this.field_0 = this.buf[++this.field_1];
  633.                      ++this.ccol;
  634.                      this.lexError("illegal character");
  635.                      return;
  636.                   }
  637.  
  638.                   var1 = true;
  639.                   this.field_0 = this.buf[++this.field_1];
  640.                   ++this.ccol;
  641.                   this.field_0 = this.buf[++this.field_1];
  642.                   ++this.ccol;
  643.                   this.field_0 = this.buf[++this.field_1];
  644.                   ++this.ccol;
  645.                   this.field_0 = this.buf[++this.field_1];
  646.                   ++this.ccol;
  647.                   this.field_0 = this.buf[++this.field_1];
  648.                   ++this.ccol;
  649.                }
  650.             case 93:
  651.                this.field_0 = this.buf[++this.field_1];
  652.                ++this.ccol;
  653.                this.sym = 16;
  654.                return;
  655.             case 123:
  656.                this.field_0 = this.buf[++this.field_1];
  657.                ++this.ccol;
  658.                this.sym = 17;
  659.                return;
  660.             case 125:
  661.                this.field_0 = this.buf[++this.field_1];
  662.                ++this.ccol;
  663.                this.sym = 18;
  664.                return;
  665.          }
  666.       }
  667.    }
  668.  
  669.    private void getspecials() {
  670.       int var1 = this.field_1;
  671.       this.name = Name.fromAscii(this.buf, var1, 1);
  672.  
  673.       while(true) {
  674.          this.sym = key[this.name.index];
  675.          this.field_0 = this.buf[++this.field_1];
  676.          ++this.ccol;
  677.          if (!this.isspecial(this.field_0)) {
  678.             break;
  679.          }
  680.  
  681.          Name var2 = Name.fromAscii(this.buf, var1, this.field_1 + 1 - var1);
  682.          if (var2.index > maxKey || key[var2.index] == 1) {
  683.             break;
  684.          }
  685.  
  686.          this.name = var2;
  687.       }
  688.  
  689.    }
  690.  
  691.    private boolean isspecial(byte var1) {
  692.       switch (var1) {
  693.          case 33:
  694.          case 37:
  695.          case 38:
  696.          case 42:
  697.          case 63:
  698.          case 43:
  699.          case 45:
  700.          case 58:
  701.          case 60:
  702.          case 61:
  703.          case 62:
  704.          case 94:
  705.          case 124:
  706.          case 126:
  707.             return true;
  708.          default:
  709.             return false;
  710.       }
  711.    }
  712.  
  713.    private void getnumber(int var1, int var2) {
  714.       while(Convert.digit2int(this.field_0, var2 == 8 ? 10 : var2) >= 0) {
  715.          this.field_0 = this.buf[++this.field_1];
  716.          ++this.ccol;
  717.       }
  718.  
  719.       if (var2 <= 10 && this.field_0 == 46) {
  720.          this.field_0 = this.buf[++this.field_1];
  721.          ++this.ccol;
  722.          this.getfraction(var1);
  723.       } else if (var2 > 10 || this.field_0 != 101 && this.field_0 != 69) {
  724.          if (this.field_0 != 108 && this.field_0 != 76) {
  725.             this.makeint(var1, this.field_1 - var1, var2, 2147483647L);
  726.             this.intVal = (long)((int)this.intVal);
  727.             this.sym = 4;
  728.          } else {
  729.             this.makeint(var1, this.field_1 - var1, var2, Long.MAX_VALUE);
  730.             this.field_0 = this.buf[++this.field_1];
  731.             ++this.ccol;
  732.             this.sym = 5;
  733.          }
  734.       } else {
  735.          this.getfraction(var1);
  736.       }
  737.  
  738.    }
  739.  
  740.    private void makeint(int var1, int var2, int var3, long var4) {
  741.       this.intVal = 0L;
  742.       int var6 = var3 == 10 ? 1 : 2;
  743.  
  744.       for(int var7 = 0; var7 < var2; ++var7) {
  745.          int var8 = Convert.digit2int(this.buf[var1 + var7], var3);
  746.          if (var8 < 0) {
  747.             this.lexError("malformed integer number");
  748.             return;
  749.          }
  750.  
  751.          if (this.intVal < (long)0 || var4 / (long)(var3 / var6) < this.intVal || var4 - (long)(var8 / var6) < this.intVal * (long)(var3 / var6)) {
  752.             this.lexError("integer number too large");
  753.             return;
  754.          }
  755.  
  756.          this.intVal = this.intVal * (long)var3 + (long)var8;
  757.       }
  758.  
  759.    }
  760.  
  761.    private void getfraction(int var1) {
  762.       while(Convert.digit2int(this.field_0, 10) >= 0) {
  763.          this.field_0 = this.buf[++this.field_1];
  764.          ++this.ccol;
  765.       }
  766.  
  767.       this.sym = 7;
  768.       if (this.field_0 == 101 || this.field_0 == 69) {
  769.          this.field_0 = this.buf[++this.field_1];
  770.          ++this.ccol;
  771.          if (this.field_0 == 43 || this.field_0 == 45) {
  772.             byte var2 = this.field_0;
  773.             this.field_0 = this.buf[++this.field_1];
  774.             ++this.ccol;
  775.             if (48 > this.field_0 || this.field_0 > 57) {
  776.                this.field_0 = var2;
  777.                --this.field_1;
  778.                --this.ccol;
  779.             }
  780.          }
  781.  
  782.          while(Convert.digit2int(this.field_0, 10) >= 0) {
  783.             this.field_0 = this.buf[++this.field_1];
  784.             ++this.ccol;
  785.          }
  786.       }
  787.  
  788.       if (this.field_0 != 100 && this.field_0 != 68) {
  789.          if (this.field_0 == 102 || this.field_0 == 70) {
  790.             this.sym = 6;
  791.             this.field_0 = this.buf[++this.field_1];
  792.             ++this.ccol;
  793.          }
  794.       } else {
  795.          this.field_0 = this.buf[++this.field_1];
  796.          ++this.ccol;
  797.       }
  798.  
  799.       try {
  800.          this.floatVal = Double.valueOf(new String(this.buf, 0, var1, this.field_1 - var1));
  801.       } catch (NumberFormatException var4) {
  802.          this.lexError("malformed floating point number");
  803.       }
  804.  
  805.    }
  806.  
  807.    private void getlitch() {
  808.       if (this.field_0 == 92) {
  809.          if (this.isUnicode()) {
  810.             this.putch(this.field_0);
  811.             this.field_0 = this.buf[++this.field_1];
  812.             ++this.ccol;
  813.             this.putch(this.field_0);
  814.             this.field_0 = this.buf[++this.field_1];
  815.             ++this.ccol;
  816.             this.putch(this.field_0);
  817.             this.field_0 = this.buf[++this.field_1];
  818.             ++this.ccol;
  819.             this.putch(this.field_0);
  820.             this.field_0 = this.buf[++this.field_1];
  821.             ++this.ccol;
  822.             this.putch(this.field_0);
  823.             this.field_0 = this.buf[++this.field_1];
  824.             ++this.ccol;
  825.             this.putch(this.field_0);
  826.             this.field_0 = this.buf[++this.field_1];
  827.             ++this.ccol;
  828.          } else {
  829.             this.field_0 = this.buf[++this.field_1];
  830.             ++this.ccol;
  831.             if (48 <= this.field_0 && this.field_0 <= 55) {
  832.                byte var1 = this.field_0;
  833.                int var2 = Convert.digit2int(this.field_0, 8);
  834.                this.field_0 = this.buf[++this.field_1];
  835.                ++this.ccol;
  836.                if (48 <= this.field_0 && this.field_0 <= 55) {
  837.                   var2 = var2 * 8 + Convert.digit2int(this.field_0, 8);
  838.                   this.field_0 = this.buf[++this.field_1];
  839.                   ++this.ccol;
  840.                   if (var1 <= 51 && 48 <= this.field_0 && this.field_0 <= 55) {
  841.                      var2 = var2 * 8 + Convert.digit2int(this.field_0, 8);
  842.                      this.field_0 = this.buf[++this.field_1];
  843.                      ++this.ccol;
  844.                   }
  845.                }
  846.  
  847.                this.putch((byte)var2);
  848.             } else if ((char)this.field_0 >= ' ') {
  849.                switch (this.field_0) {
  850.                   case 98:
  851.                   case 116:
  852.                   case 110:
  853.                   case 102:
  854.                   case 114:
  855.                   case 34:
  856.                   case 39:
  857.                   case 92:
  858.                      this.putch((byte)92);
  859.                      this.putch(this.field_0);
  860.                      break;
  861.                   default:
  862.                      this.lexError("invalid escape character", (this.cline << 10) + this.ccol - 1);
  863.                }
  864.  
  865.                this.field_0 = this.buf[++this.field_1];
  866.                ++this.ccol;
  867.             }
  868.          }
  869.       } else if ((char)this.field_0 >= ' ') {
  870.          this.putch(this.field_0);
  871.          this.field_0 = this.buf[++this.field_1];
  872.          ++this.ccol;
  873.       }
  874.  
  875.    }
  876.  
  877.    private boolean isUnicode() {
  878.       return this.field_1 + 6 < this.buf.length && this.buf[this.field_1] == 92 && this.buf[this.field_1 + 1] == 117 && Convert.digit2int(this.buf[this.field_1 + 2], 16) >= 0 && Convert.digit2int(this.buf[this.field_1 + 3], 16) >= 0 && Convert.digit2int(this.buf[this.field_1 + 4], 16) >= 0 && Convert.digit2int(this.buf[this.field_1 + 5], 16) >= 0;
  879.    }
  880.  
  881.    private void putch(byte var1) {
  882.       if (this.litlen == this.lit.length) {
  883.          byte[] var2 = new byte[this.lit.length * 2];
  884.          System.arraycopy(this.lit, 0, var2, 0, this.lit.length);
  885.          this.lit = var2;
  886.       }
  887.  
  888.       this.lit[this.litlen++] = var1;
  889.    }
  890.  
  891.    private void lexError(String var1) {
  892.       this.lexError(var1, this.pos);
  893.    }
  894.  
  895.    private void lexError(String var1, int var2) {
  896.       Report.error(var2, var1);
  897.       this.sym = 110;
  898.       this.errPos = var2;
  899.    }
  900.  
  901.    private void dch() {
  902.       System.out.print((char)this.field_0);
  903.       System.out.flush();
  904.    }
  905.  
  906.    Scanner(FileInputStream var1) {
  907.       try {
  908.          this.buf = new byte[var1.available() + 1];
  909.          if (var1.read(this.buf) != this.buf.length - 1) {
  910.             throw new IOException("read error");
  911.          }
  912.       } catch (IOException var3) {
  913.          this.lexError(((Throwable)var3).toString());
  914.          this.buf = new byte[1];
  915.       }
  916.  
  917.       this.buf[this.buf.length - 1] = 26;
  918.       this.field_1 = 0;
  919.       this.cline = 1;
  920.       this.ccol = 1;
  921.       this.field_0 = this.buf[0];
  922.       this.nextsym();
  923.       if (Switches.extended) {
  924.          maxKey = extendedMaxKey;
  925.       } else {
  926.          maxKey = standardMaxKey;
  927.       }
  928.  
  929.    }
  930. }
  931.