home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / sun / tools / asm / Assembler.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  13.4 KB  |  830 lines
  1. package sun.tools.asm;
  2.  
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.FileOutputStream;
  9. import java.io.FilterInputStream;
  10. import java.io.IOException;
  11. import java.io.PrintStream;
  12. import java.util.Enumeration;
  13. import java.util.Vector;
  14. import sun.tools.java.ClassDefinition;
  15. import sun.tools.java.CompilerError;
  16. import sun.tools.java.Constants;
  17. import sun.tools.java.Environment;
  18. import sun.tools.java.FieldDefinition;
  19. import sun.tools.javac.SourceClass;
  20.  
  21. public final class Assembler implements Constants {
  22.    static final int NOTREACHED = 0;
  23.    static final int REACHED = 1;
  24.    static final int NEEDED = 2;
  25.    Label first = new Label();
  26.    Instruction last;
  27.    int maxdepth;
  28.    int maxvar;
  29.    int maxpc;
  30.    static Vector TableLot = new Vector();
  31.    static Vector SourceClassList = new Vector();
  32.    static int count;
  33.    static int countclass;
  34.    static int countmeth;
  35.    static Vector TmpCovTable = new Vector();
  36.  
  37.    public void add(Instruction var1) {
  38.       if (var1 != null) {
  39.          this.last.next = var1;
  40.          this.last = var1;
  41.       }
  42.  
  43.    }
  44.  
  45.    public void add(int var1, int var2) {
  46.       this.add(new Instruction(var1, var2, (Object)null));
  47.    }
  48.  
  49.    public void add(int var1, int var2, Object var3) {
  50.       this.add(new Instruction(var1, var2, var3));
  51.    }
  52.  
  53.    public void add(int var1, int var2, Object var3, boolean var4) {
  54.       this.add(new Instruction(var1, var2, var3, var4));
  55.    }
  56.  
  57.    public void add(boolean var1, int var2, int var3, Object var4) {
  58.       this.add(new Instruction(var1, var2, var3, var4));
  59.    }
  60.  
  61.    public void add(int var1, int var2, boolean var3) {
  62.       this.add(new Instruction(var1, var2, var3));
  63.    }
  64.  
  65.    void optimize(Environment var1, Label var2) {
  66.       var2.pc = 1;
  67.  
  68.       for(Instruction var3 = var2.next; var3 != null; var3 = var3.next) {
  69.          switch (var3.pc) {
  70.             case 0:
  71.                var3.optimize(var1);
  72.                var3.pc = 1;
  73.                break;
  74.             case 1:
  75.                return;
  76.             case 2:
  77.          }
  78.  
  79.          switch (var3.opc) {
  80.             case -3:
  81.                TryData var7 = (TryData)var3.value;
  82.                var7.getEndLabel().pc = 2;
  83.                Enumeration var8 = var7.catches.elements();
  84.  
  85.                while(var8.hasMoreElements()) {
  86.                   CatchData var6 = (CatchData)var8.nextElement();
  87.                   this.optimize(var1, var6.getLabel());
  88.                }
  89.                break;
  90.             case -2:
  91.             case -1:
  92.                if (var3.pc == 1) {
  93.                   var3.pc = 0;
  94.                }
  95.                break;
  96.             case 153:
  97.             case 154:
  98.             case 155:
  99.             case 156:
  100.             case 157:
  101.             case 158:
  102.             case 159:
  103.             case 160:
  104.             case 161:
  105.             case 162:
  106.             case 163:
  107.             case 164:
  108.             case 165:
  109.             case 166:
  110.             case 198:
  111.             case 199:
  112.                this.optimize(var1, (Label)var3.value);
  113.                break;
  114.             case 167:
  115.                this.optimize(var1, (Label)var3.value);
  116.                return;
  117.             case 168:
  118.                this.optimize(var1, (Label)var3.value);
  119.                break;
  120.             case 169:
  121.             case 172:
  122.             case 173:
  123.             case 174:
  124.             case 175:
  125.             case 176:
  126.             case 177:
  127.             case 191:
  128.                return;
  129.             case 170:
  130.             case 171:
  131.                SwitchData var4 = (SwitchData)var3.value;
  132.                this.optimize(var1, var4.defaultLabel);
  133.                Enumeration var5 = var4.tab.elements();
  134.  
  135.                while(var5.hasMoreElements()) {
  136.                   this.optimize(var1, (Label)var5.nextElement());
  137.                }
  138.  
  139.                return;
  140.          }
  141.       }
  142.  
  143.    }
  144.  
  145.    boolean eliminate() {
  146.       boolean var1 = false;
  147.       Object var2 = this.first;
  148.  
  149.       for(Instruction var3 = this.first.next; var3 != null; var3 = var3.next) {
  150.          if (var3.pc != 0) {
  151.             ((Instruction)var2).next = var3;
  152.             var2 = var3;
  153.             var3.pc = 0;
  154.          } else {
  155.             var1 = true;
  156.          }
  157.       }
  158.  
  159.       this.first.pc = 0;
  160.       ((Instruction)var2).next = null;
  161.       return var1;
  162.    }
  163.  
  164.    public void optimize(Environment var1) {
  165.       do {
  166.          this.optimize(var1, this.first);
  167.       } while(this.eliminate() && var1.optimize());
  168.  
  169.    }
  170.  
  171.    public void collect(Environment var1, FieldDefinition var2, ConstantPool var3) {
  172.       if (var2 != null && var1.debug() && var2.getArguments() != null) {
  173.          Enumeration var4 = var2.getArguments().elements();
  174.  
  175.          while(var4.hasMoreElements()) {
  176.             FieldDefinition var5 = (FieldDefinition)var4.nextElement();
  177.             var3.put(var5.getName().toString());
  178.             var3.put(var5.getType().getTypeSignature());
  179.          }
  180.       }
  181.  
  182.       for(Object var6 = this.first; var6 != null; var6 = ((Instruction)var6).next) {
  183.          ((Instruction)var6).collect(var3);
  184.       }
  185.  
  186.    }
  187.  
  188.    void balance(Label var1, int var2) {
  189.       for(Object var3 = var1; var3 != null; var3 = ((Instruction)var3).next) {
  190.          var2 += ((Instruction)var3).balance();
  191.          if (var2 < 0) {
  192.             throw new CompilerError("stack under flow: " + ((Instruction)var3).toString() + " = " + var2);
  193.          }
  194.  
  195.          if (var2 > this.maxdepth) {
  196.             this.maxdepth = var2;
  197.          }
  198.  
  199.          switch (((Instruction)var3).opc) {
  200.             case -3:
  201.                TryData var11 = (TryData)((Instruction)var3).value;
  202.                Enumeration var12 = var11.catches.elements();
  203.  
  204.                while(var12.hasMoreElements()) {
  205.                   CatchData var6 = (CatchData)var12.nextElement();
  206.                   this.balance(var6.getLabel(), var2 + 1);
  207.                }
  208.                break;
  209.             case -1:
  210.                var1 = (Label)var3;
  211.                if (((Instruction)var3).pc == 1) {
  212.                   if (var1.depth != var2) {
  213.                      throw new CompilerError("stack depth error " + var2 + "/" + var1.depth + ": " + ((Instruction)var3).toString());
  214.                   }
  215.  
  216.                   return;
  217.                }
  218.  
  219.                var1.pc = 1;
  220.                var1.depth = var2;
  221.                break;
  222.             case 21:
  223.             case 23:
  224.             case 25:
  225.             case 54:
  226.             case 56:
  227.             case 58:
  228.                int var10 = (((Instruction)var3).value instanceof Number ? ((Number)((Instruction)var3).value).intValue() : ((LocalVariable)((Instruction)var3).value).slot) + 1;
  229.                if (var10 > this.maxvar) {
  230.                   this.maxvar = var10;
  231.                }
  232.                break;
  233.             case 22:
  234.             case 24:
  235.             case 55:
  236.             case 57:
  237.                int var9 = (((Instruction)var3).value instanceof Number ? ((Number)((Instruction)var3).value).intValue() : ((LocalVariable)((Instruction)var3).value).slot) + 2;
  238.                if (var9 > this.maxvar) {
  239.                   this.maxvar = var9;
  240.                }
  241.                break;
  242.             case 132:
  243.                int var8 = ((int[])((Instruction)var3).value)[0] + 1;
  244.                if (var8 > this.maxvar) {
  245.                   this.maxvar = var8 + 1;
  246.                }
  247.                break;
  248.             case 153:
  249.             case 154:
  250.             case 155:
  251.             case 156:
  252.             case 157:
  253.             case 158:
  254.             case 159:
  255.             case 160:
  256.             case 161:
  257.             case 162:
  258.             case 163:
  259.             case 164:
  260.             case 165:
  261.             case 166:
  262.             case 198:
  263.             case 199:
  264.                this.balance((Label)((Instruction)var3).value, var2);
  265.                break;
  266.             case 167:
  267.                this.balance((Label)((Instruction)var3).value, var2);
  268.                return;
  269.             case 168:
  270.                this.balance((Label)((Instruction)var3).value, var2 + 1);
  271.                break;
  272.             case 169:
  273.             case 172:
  274.             case 173:
  275.             case 174:
  276.             case 175:
  277.             case 176:
  278.             case 177:
  279.             case 191:
  280.                return;
  281.             case 170:
  282.             case 171:
  283.                SwitchData var4 = (SwitchData)((Instruction)var3).value;
  284.                this.balance(var4.defaultLabel, var2);
  285.                Enumeration var5 = var4.tab.elements();
  286.  
  287.                while(var5.hasMoreElements()) {
  288.                   this.balance((Label)var5.nextElement(), var2);
  289.                }
  290.  
  291.                return;
  292.          }
  293.       }
  294.  
  295.    }
  296.  
  297.    public void write(Environment var1, DataOutputStream var2, FieldDefinition var3, ConstantPool var4) throws IOException {
  298.       if (var3 != null && var3.getArguments() != null) {
  299.          int var5 = 0;
  300.          Vector var6 = var3.getArguments();
  301.  
  302.          FieldDefinition var8;
  303.          for(Enumeration var7 = var6.elements(); var7.hasMoreElements(); var5 += var8.getType().stackSize()) {
  304.             var8 = (FieldDefinition)var7.nextElement();
  305.          }
  306.  
  307.          this.maxvar = var5;
  308.       }
  309.  
  310.       try {
  311.          this.balance(this.first, 0);
  312.       } catch (CompilerError var9) {
  313.          System.out.println("ERROR: " + var9);
  314.          this.listing(System.out);
  315.          throw var9;
  316.       }
  317.  
  318.       int var10 = 0;
  319.       int var11 = 0;
  320.  
  321.       for(Object var12 = this.first; var12 != null; var12 = ((Instruction)var12).next) {
  322.          ((Instruction)var12).pc = var10;
  323.          var10 += ((Instruction)var12).size(var4);
  324.          if (((Instruction)var12).opc == -3) {
  325.             var11 += ((TryData)((Instruction)var12).value).catches.size();
  326.          }
  327.       }
  328.  
  329.       var2.writeShort(this.maxdepth);
  330.       var2.writeShort(this.maxvar);
  331.       var2.writeInt(this.maxpc = var10);
  332.  
  333.       for(Instruction var13 = this.first.next; var13 != null; var13 = var13.next) {
  334.          var13.write(var2, var4);
  335.       }
  336.  
  337.       var2.writeShort(var11);
  338.       if (var11 > 0) {
  339.          this.writeExceptions(var1, var2, var4, this.first, this.last);
  340.       }
  341.  
  342.    }
  343.  
  344.    void writeExceptions(Environment var1, DataOutputStream var2, ConstantPool var3, Instruction var4, Instruction var5) throws IOException {
  345.       for(Object var6 = var4; var6 != var5.next; var6 = ((Instruction)var6).next) {
  346.          if (((Instruction)var6).opc == -3) {
  347.             TryData var7 = (TryData)((Instruction)var6).value;
  348.             this.writeExceptions(var1, var2, var3, ((Instruction)var6).next, var7.getEndLabel());
  349.             Enumeration var8 = var7.catches.elements();
  350.  
  351.             while(var8.hasMoreElements()) {
  352.                CatchData var9 = (CatchData)var8.nextElement();
  353.                var2.writeShort(((Instruction)var6).pc);
  354.                var2.writeShort(var7.getEndLabel().pc);
  355.                var2.writeShort(var9.getLabel().pc);
  356.                if (var9.getType() != null) {
  357.                   var2.writeShort(var3.index(var9.getType()));
  358.                } else {
  359.                   var2.writeShort(0);
  360.                }
  361.             }
  362.  
  363.             var6 = var7.getEndLabel();
  364.          }
  365.       }
  366.  
  367.    }
  368.  
  369.    public void writeCoverageTable(Environment var1, ClassDefinition var2, DataOutputStream var3, ConstantPool var4, int var5) throws IOException {
  370.       boolean var6 = false;
  371.       boolean var7 = false;
  372.       int var8 = ((SourceClass)var2).getWhere();
  373.       int[] var9 = new int[20];
  374.       int var10 = 0;
  375.       countmeth = count;
  376.  
  377.       for(Object var11 = this.first; var11 != null; var11 = ((Instruction)var11).next) {
  378.          int var12 = ((Instruction)var11).where >> 18;
  379.          if (var12 > 0 && ((Instruction)var11).opc != -1) {
  380.             if (!var7) {
  381.                if (var8 == ((Instruction)var11).where) {
  382.                   TableLot.addElement(new Cover(2, var5, ((Instruction)var11).pc));
  383.                } else {
  384.                   TableLot.addElement(new Cover(1, var5, ((Instruction)var11).pc));
  385.                }
  386.  
  387.                ++count;
  388.                var7 = true;
  389.             }
  390.  
  391.             if (!var6 && !((Instruction)var11).flagNoCovered) {
  392.                boolean var13 = false;
  393.  
  394.                for(int var14 = 0; var14 < var10; ++var14) {
  395.                   if (var9[var14] == ((Instruction)var11).where) {
  396.                      var13 = true;
  397.                      break;
  398.                   }
  399.                }
  400.  
  401.                if (!var13) {
  402.                   TableLot.addElement(new Cover(3, ((Instruction)var11).where, ((Instruction)var11).pc));
  403.                   ++count;
  404.                   var6 = true;
  405.                }
  406.             }
  407.          }
  408.  
  409.          switch (((Instruction)var11).opc) {
  410.             case -3:
  411.                var9[var10++] = ((Instruction)var11).where;
  412.                var6 = false;
  413.                break;
  414.             case -1:
  415.                var6 = false;
  416.                break;
  417.             case 153:
  418.             case 154:
  419.             case 155:
  420.             case 156:
  421.             case 157:
  422.             case 158:
  423.             case 159:
  424.             case 160:
  425.             case 161:
  426.             case 162:
  427.             case 163:
  428.             case 164:
  429.             case 165:
  430.             case 166:
  431.             case 198:
  432.             case 199:
  433.                if (((Instruction)var11).flagCondInverted) {
  434.                   TableLot.addElement(new Cover(7, ((Instruction)var11).where, ((Instruction)var11).pc));
  435.                   TableLot.addElement(new Cover(8, ((Instruction)var11).where, ((Instruction)var11).pc));
  436.                } else {
  437.                   TableLot.addElement(new Cover(8, ((Instruction)var11).where, ((Instruction)var11).pc));
  438.                   TableLot.addElement(new Cover(7, ((Instruction)var11).where, ((Instruction)var11).pc));
  439.                }
  440.  
  441.                count += 2;
  442.                var6 = false;
  443.                break;
  444.             case 167:
  445.                var6 = false;
  446.             case 169:
  447.             case 172:
  448.             case 173:
  449.             case 174:
  450.             case 175:
  451.             case 176:
  452.             case 177:
  453.             case 191:
  454.             default:
  455.                break;
  456.             case 170:
  457.                SwitchData var18 = (SwitchData)((Instruction)var11).value;
  458.  
  459.                for(int var21 = var18.minValue; var21 <= var18.maxValue; ++var21) {
  460.                   TableLot.addElement(new Cover(5, var18.whereCase(var21), ((Instruction)var11).pc));
  461.                   ++count;
  462.                }
  463.  
  464.                if (!var18.getDefault()) {
  465.                   TableLot.addElement(new Cover(6, ((Instruction)var11).where, ((Instruction)var11).pc));
  466.                   ++count;
  467.                }
  468.  
  469.                var6 = false;
  470.                break;
  471.             case 171:
  472.                SwitchData var17 = (SwitchData)((Instruction)var11).value;
  473.  
  474.                for(Enumeration var20 = var17.sortedKeys(); var20.hasMoreElements(); ++count) {
  475.                   Integer var15 = (Integer)var20.nextElement();
  476.                   TableLot.addElement(new Cover(5, var17.whereCase(var15), ((Instruction)var11).pc));
  477.                }
  478.  
  479.                if (!var17.getDefault()) {
  480.                   TableLot.addElement(new Cover(6, ((Instruction)var11).where, ((Instruction)var11).pc));
  481.                   ++count;
  482.                }
  483.  
  484.                var6 = false;
  485.          }
  486.       }
  487.  
  488.       var3.writeShort(count - countmeth);
  489.  
  490.       for(int var23 = countmeth; var23 < count; ++var23) {
  491.          Cover var16 = (Cover)TableLot.elementAt(var23);
  492.          int var19 = var16.Addr >> 18;
  493.          int var22 = var16.Addr << 14 >> 14;
  494.          var3.writeShort(var16.NumCommand);
  495.          var3.writeShort(var16.Type);
  496.          var3.writeInt(var16.Addr);
  497.       }
  498.  
  499.    }
  500.  
  501.    public void GenVecJCov(Environment var1, ClassDefinition var2, long var3) {
  502.       String var5 = ((SourceClass)var2).getAbsoluteName();
  503.       String var6 = ((SourceClass)var2).getName().toString();
  504.       TmpCovTable.addElement("CLASS: " + var6);
  505.       SourceClassList.addElement(var6);
  506.       TmpCovTable.addElement("SRCFILE: " + var5);
  507.       TmpCovTable.addElement("TIMESTAMP: " + var3);
  508.       TmpCovTable.addElement("#flag\tline\tposition");
  509.  
  510.       for(int var10 = countclass; var10 < count; ++var10) {
  511.          Cover var7 = (Cover)TableLot.elementAt(var10);
  512.          if (var7.Type != 5 || var7.Addr != 0) {
  513.             int var8 = var7.Addr >> 18;
  514.             int var9 = var7.Addr << 14 >> 14;
  515.             TmpCovTable.addElement(new String(var7.Type + "\t" + var8 + "\t" + var9));
  516.          }
  517.       }
  518.  
  519.       countclass = 0;
  520.       count = 0;
  521.       TableLot.removeAllElements();
  522.    }
  523.  
  524.    public void GenJCov(Environment var1) {
  525.       try {
  526.          File var2 = var1.getcovFile();
  527.          if (var2.exists()) {
  528.             DataInputStream var3 = new DataInputStream(new FileInputStream(var2));
  529.             Object var4 = null;
  530.             boolean var5 = true;
  531.             var3.readLine();
  532.  
  533.             while((var11 = var3.readLine()) != null) {
  534.                if (var11.indexOf("CLASS: ") != -1) {
  535.                   var5 = true;
  536.                   Enumeration var7 = SourceClassList.elements();
  537.  
  538.                   while(var7.hasMoreElements()) {
  539.                      String var6 = (String)var7.nextElement();
  540.                      if (var6.compareTo(var11.substring(7)) == 0) {
  541.                         var5 = false;
  542.                         break;
  543.                      }
  544.                   }
  545.                }
  546.  
  547.                if (var5) {
  548.                   TmpCovTable.addElement(var11);
  549.                }
  550.             }
  551.  
  552.             ((FilterInputStream)var3).close();
  553.          }
  554.  
  555.          PrintStream var10 = new PrintStream(new DataOutputStream(new FileOutputStream(var2)));
  556.          var10.println("JCOV-DATA-FILE-VERSION: 1.0");
  557.          Enumeration var12 = TmpCovTable.elements();
  558.  
  559.          while(var12.hasMoreElements()) {
  560.             var10.println(var12.nextElement());
  561.          }
  562.  
  563.          var10.close();
  564.       } catch (FileNotFoundException var8) {
  565.          System.out.println("ERROR: " + var8);
  566.       } catch (IOException var9) {
  567.          System.out.println("ERROR: " + var9);
  568.       }
  569.    }
  570.  
  571.    public void writeLineNumberTable(Environment var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  572.       int var4 = -1;
  573.       int var5 = 0;
  574.  
  575.       for(Object var6 = this.first; var6 != null; var6 = ((Instruction)var6).next) {
  576.          int var7 = ((Instruction)var6).where >> 18;
  577.          if (var7 > 0 && var4 != var7) {
  578.             var4 = var7;
  579.             ++var5;
  580.          }
  581.       }
  582.  
  583.       var4 = -1;
  584.       var2.writeShort(var5);
  585.  
  586.       for(Object var10 = this.first; var10 != null; var10 = ((Instruction)var10).next) {
  587.          int var8 = ((Instruction)var10).where >> 18;
  588.          if (var8 > 0 && var4 != var8) {
  589.             var4 = var8;
  590.             var2.writeShort(((Instruction)var10).pc);
  591.             var2.writeShort(var8);
  592.          }
  593.       }
  594.  
  595.    }
  596.  
  597.    void flowFields(Environment var1, Label var2, FieldDefinition[] var3) {
  598.       if (var2.locals != null) {
  599.          FieldDefinition[] var10 = var2.locals;
  600.  
  601.          for(int var11 = 0; var11 < this.maxvar; ++var11) {
  602.             if (var10[var11] != var3[var11]) {
  603.                var10[var11] = null;
  604.             }
  605.          }
  606.  
  607.       } else {
  608.          var2.locals = new FieldDefinition[this.maxvar];
  609.          System.arraycopy(var3, 0, var2.locals, 0, this.maxvar);
  610.          FieldDefinition[] var4 = new FieldDefinition[this.maxvar];
  611.          System.arraycopy(var3, 0, var4, 0, this.maxvar);
  612.          var3 = var4;
  613.  
  614.          for(Instruction var5 = var2.next; var5 != null; var5 = var5.next) {
  615.             switch (var5.opc) {
  616.                case -3:
  617.                   Vector var13 = ((TryData)var5.value).catches;
  618.                   Enumeration var14 = var13.elements();
  619.  
  620.                   while(var14.hasMoreElements()) {
  621.                      CatchData var8 = (CatchData)var14.nextElement();
  622.                      this.flowFields(var1, var8.getLabel(), var3);
  623.                   }
  624.                   break;
  625.                case -1:
  626.                   this.flowFields(var1, (Label)var5, var3);
  627.                   return;
  628.                case 54:
  629.                case 55:
  630.                case 56:
  631.                case 57:
  632.                case 58:
  633.                case 59:
  634.                case 60:
  635.                case 61:
  636.                case 62:
  637.                case 63:
  638.                case 64:
  639.                case 65:
  640.                case 66:
  641.                case 67:
  642.                case 68:
  643.                case 69:
  644.                case 70:
  645.                case 71:
  646.                case 72:
  647.                case 73:
  648.                case 74:
  649.                case 75:
  650.                case 76:
  651.                case 77:
  652.                case 78:
  653.                   if (var5.value instanceof LocalVariable) {
  654.                      LocalVariable var12 = (LocalVariable)var5.value;
  655.                      var3[var12.slot] = var12.field;
  656.                   }
  657.                   break;
  658.                case 153:
  659.                case 154:
  660.                case 155:
  661.                case 156:
  662.                case 157:
  663.                case 158:
  664.                case 159:
  665.                case 160:
  666.                case 161:
  667.                case 162:
  668.                case 163:
  669.                case 164:
  670.                case 165:
  671.                case 166:
  672.                case 168:
  673.                case 198:
  674.                case 199:
  675.                   this.flowFields(var1, (Label)var5.value, var3);
  676.                   break;
  677.                case 167:
  678.                   this.flowFields(var1, (Label)var5.value, var3);
  679.                   return;
  680.                case 169:
  681.                case 172:
  682.                case 173:
  683.                case 174:
  684.                case 175:
  685.                case 176:
  686.                case 177:
  687.                case 191:
  688.                   return;
  689.                case 170:
  690.                case 171:
  691.                   SwitchData var6 = (SwitchData)var5.value;
  692.                   this.flowFields(var1, var6.defaultLabel, var3);
  693.                   Enumeration var7 = var6.tab.elements();
  694.  
  695.                   while(var7.hasMoreElements()) {
  696.                      this.flowFields(var1, (Label)var7.nextElement(), var3);
  697.                   }
  698.  
  699.                   return;
  700.             }
  701.          }
  702.  
  703.       }
  704.    }
  705.  
  706.    public void writeLocalVariableTable(Environment var1, FieldDefinition var2, DataOutputStream var3, ConstantPool var4) throws IOException {
  707.       FieldDefinition[] var5 = new FieldDefinition[this.maxvar];
  708.       int var6 = 0;
  709.       if (var2 != null && var2.getArguments() != null) {
  710.          int var7 = 0;
  711.          Vector var8 = var2.getArguments();
  712.  
  713.          FieldDefinition var10;
  714.          for(Enumeration var9 = var8.elements(); var9.hasMoreElements(); var7 += var10.getType().stackSize()) {
  715.             var10 = (FieldDefinition)var9.nextElement();
  716.             var5[var7] = var10;
  717.          }
  718.       }
  719.  
  720.       this.flowFields(var1, this.first, var5);
  721.       LocalVariableTable var17 = new LocalVariableTable();
  722.  
  723.       for(int var12 = 0; var12 < this.maxvar; ++var12) {
  724.          var5[var12] = null;
  725.       }
  726.  
  727.       if (var2 != null && var2.getArguments() != null) {
  728.          int var18 = 0;
  729.          Vector var20 = var2.getArguments();
  730.  
  731.          FieldDefinition var11;
  732.          for(Enumeration var22 = var20.elements(); var22.hasMoreElements(); var18 += var11.getType().stackSize()) {
  733.             var11 = (FieldDefinition)var22.nextElement();
  734.             var5[var18] = var11;
  735.             var17.define(var11, var18, 0, this.maxpc);
  736.          }
  737.       }
  738.  
  739.       int[] var19 = new int[this.maxvar];
  740.  
  741.       for(Object var21 = this.first; var21 != null; var21 = ((Instruction)var21).next) {
  742.          switch (((Instruction)var21).opc) {
  743.             case -1:
  744.                var6 = 0;
  745.  
  746.                for(; var6 < this.maxvar; ++var6) {
  747.                   if (var5[var6] != null) {
  748.                      var17.define(var5[var6], var6, var19[var6], ((Instruction)var21).pc);
  749.                   }
  750.                }
  751.  
  752.                int var24 = ((Instruction)var21).pc;
  753.                FieldDefinition[] var26 = ((Label)var21).locals;
  754.                if (var26 == null) {
  755.                   for(int var14 = 0; var14 < this.maxvar; ++var14) {
  756.                      var5[var14] = null;
  757.                   }
  758.                } else {
  759.                   System.arraycopy(var26, 0, var5, 0, this.maxvar);
  760.                }
  761.  
  762.                for(int var15 = 0; var15 < this.maxvar; ++var15) {
  763.                   var19[var15] = var24;
  764.                }
  765.                break;
  766.             case 54:
  767.             case 55:
  768.             case 56:
  769.             case 57:
  770.             case 58:
  771.             case 59:
  772.             case 60:
  773.             case 61:
  774.             case 62:
  775.             case 63:
  776.             case 64:
  777.             case 65:
  778.             case 66:
  779.             case 67:
  780.             case 68:
  781.             case 69:
  782.             case 70:
  783.             case 71:
  784.             case 72:
  785.             case 73:
  786.             case 74:
  787.             case 75:
  788.             case 76:
  789.             case 77:
  790.             case 78:
  791.                if (((Instruction)var21).value instanceof LocalVariable) {
  792.                   LocalVariable var23 = (LocalVariable)((Instruction)var21).value;
  793.                   int var25 = ((Instruction)var21).next != null ? ((Instruction)var21).next.pc : ((Instruction)var21).pc;
  794.                   if (var5[var23.slot] != null) {
  795.                      var17.define(var5[var23.slot], var23.slot, var19[var23.slot], var25);
  796.                   }
  797.  
  798.                   var19[var23.slot] = var25;
  799.                   var5[var23.slot] = var23.field;
  800.                }
  801.          }
  802.       }
  803.  
  804.       for(int var16 = 0; var16 < this.maxvar; ++var16) {
  805.          if (var5[var16] != null) {
  806.             var17.define(var5[var16], var16, var19[var16], this.maxpc);
  807.          }
  808.       }
  809.  
  810.       var17.write(var1, var3, var4);
  811.    }
  812.  
  813.    public boolean empty() {
  814.       return this.first == this.last;
  815.    }
  816.  
  817.    public void listing(PrintStream var1) {
  818.       var1.println("-- listing --");
  819.  
  820.       for(Object var2 = this.first; var2 != null; var2 = ((Instruction)var2).next) {
  821.          var1.println(((Instruction)var2).toString());
  822.       }
  823.  
  824.    }
  825.  
  826.    public Assembler() {
  827.       this.last = this.first;
  828.    }
  829. }
  830.