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 / debug / Agent.class (.txt) next >
Encoding:
Java Class File  |  1997-07-08  |  26.5 KB  |  1,512 lines
  1. package sun.tools.debug;
  2.  
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.DataInputStream;
  6. import java.io.DataOutputStream;
  7. import java.io.FilterInputStream;
  8. import java.io.FilterOutputStream;
  9. import java.io.IOException;
  10. import java.io.PipedInputStream;
  11. import java.io.PipedOutputStream;
  12. import java.io.PrintStream;
  13. import java.net.ServerSocket;
  14. import java.net.Socket;
  15. import java.util.Enumeration;
  16. import java.util.Hashtable;
  17. import java.util.Vector;
  18. import sun.tools.java.ClassPath;
  19. import sun.tools.java.Identifier;
  20. import sun.tools.java.Package;
  21.  
  22. class Agent implements Runnable, AgentConstants {
  23.    static Agent the_Agent = null;
  24.    ServerSocket socket;
  25.    boolean useSockets;
  26.    DataOutputStream asyncOutputStream;
  27.    PipedInputStream cmdInputPipe;
  28.    PipedOutputStream cmdOutputPipe;
  29.    PipedOutputStream asyncOutputPipe;
  30.    Hashtable objects;
  31.    private BreakpointHandler bkptHandler;
  32.    static boolean runBegun;
  33.    static Object runBegunLock = new Object();
  34.    private DataOutputStream out;
  35.    private ResponseStream outBuffer;
  36.    private ClassPath sourcePath;
  37.    private Object pipeLock = new Object();
  38.    static boolean verbose;
  39.    private ThreadList lastSuspended;
  40.  
  41.    static String toHex(int var0) {
  42.       char[] var1 = new char[10];
  43.  
  44.       for(int var2 = 0; var2 < 10; ++var2) {
  45.          var1[var2] = '0';
  46.       }
  47.  
  48.       var1[1] = 'x';
  49.  
  50.       for(int var3 = 9; var0 != 0; --var3) {
  51.          int var4 = var0 & 15;
  52.          var1[var3] = (char)(var4 < 10 ? 48 + var4 : 97 + var4 - 10);
  53.          var0 >>>= 4;
  54.       }
  55.  
  56.       return new String(var1);
  57.    }
  58.  
  59.    private void dumpClasses() throws IOException {
  60.       message("dumpClasses()");
  61.       Enumeration var1 = this.objects.elements();
  62.       Vector var2 = new Vector();
  63.       int var3 = 0;
  64.  
  65.       while(var1.hasMoreElements()) {
  66.          try {
  67.             Object var4 = var1.nextElement();
  68.             if (var4 != null && var4 instanceof Class) {
  69.                var2.addElement(var4);
  70.                ++var3;
  71.             }
  72.          } catch (Exception var5) {
  73.             error("dumpClasses() failed: " + ((Throwable)var5).toString());
  74.          }
  75.       }
  76.  
  77.       this.out.writeInt(var3);
  78.       var1 = var2.elements();
  79.  
  80.       while(var1.hasMoreElements()) {
  81.          this.writeObject(var1.nextElement());
  82.       }
  83.  
  84.    }
  85.  
  86.    private String cookieToString(int var1) {
  87.       int var2 = "23456789abcdefghijkmnpqrstuvwxyz".length();
  88.       int var3 = 0;
  89.  
  90.       StringBuffer var4;
  91.       for(var4 = new StringBuffer(32); var1 > 0; ++var3) {
  92.          if (var1 < var2) {
  93.             var4.append("23456789abcdefghijkmnpqrstuvwxyz".charAt(var1));
  94.             var1 = 0;
  95.          } else {
  96.             int var5 = var1 % var2;
  97.             var1 /= var2;
  98.             var4.append("23456789abcdefghijkmnpqrstuvwxyz".charAt(var5));
  99.          }
  100.       }
  101.  
  102.       if (var3 <= 0) {
  103.          return "0";
  104.       } else {
  105.          int var8 = var4.length();
  106.          char[] var6 = new char[var8];
  107.  
  108.          for(int var7 = 0; var8-- > 0; var6[var8] = var4.charAt(var7++)) {
  109.          }
  110.  
  111.          return String.valueOf(var6);
  112.       }
  113.    }
  114.  
  115.    private String makePassword(int var1) {
  116.       if (var1 > 65535) {
  117.          System.err.println("Invalid port number (" + var1 + ")???");
  118.          System.exit(1);
  119.       }
  120.  
  121.       int var2 = (int)(Math.round(Math.random() * (double)2048.0F) % 2048L);
  122.       int var3 = 0;
  123.       int var4 = 3;
  124.  
  125.       for(int var5 = 0; var5 < 8; ++var5) {
  126.          int var6 = (var1 & var4) << var5 + 1;
  127.          int var7 = (var2 & 1 << var5) << var5 * 2;
  128.          var3 |= var6 | var7;
  129.          var4 <<= 2;
  130.       }
  131.  
  132.       var3 |= (var2 & 1792) << 16;
  133.       return this.cookieToString(var3);
  134.    }
  135.  
  136.    Agent() {
  137.       this.useSockets = false;
  138.       the_Agent = this;
  139.    }
  140.  
  141.    Agent(int var1) {
  142.       this.useSockets = true;
  143.       the_Agent = this;
  144.       int var2 = 0;
  145.  
  146.       while(true) {
  147.          try {
  148.             this.socket = new ServerSocket(var1, 10);
  149.             System.out.println("Agent password=" + this.makePassword(this.socket.getLocalPort()));
  150.             return;
  151.          } catch (Exception var4) {
  152.             message("[Waiting to create port]\n");
  153.  
  154.             try {
  155.                Thread.sleep(5000L);
  156.             } catch (InterruptedException var3) {
  157.                Thread.currentThread().interrupt();
  158.             }
  159.  
  160.             if (var2 >= 10) {
  161.                error("**Failed to create port\n");
  162.                return;
  163.             }
  164.  
  165.             ++var2;
  166.          }
  167.       }
  168.    }
  169.  
  170.    static void beginRun() {
  171.       Object var0 = runBegunLock;
  172.       synchronized(var0){}
  173.  
  174.       try {
  175.          runBegun = true;
  176.          runBegunLock.notifyAll();
  177.       } catch (Throwable var2) {
  178.          throw var2;
  179.       }
  180.  
  181.    }
  182.  
  183.    static synchronized void connectToAgent(PipedOutputStream var0, PipedInputStream var1, PipedInputStream var2) throws IOException {
  184.       if (the_Agent != null && !the_Agent.useSockets) {
  185.          the_Agent.cmdInputPipe = new PipedInputStream(var0);
  186.          the_Agent.cmdOutputPipe = new PipedOutputStream(var1);
  187.          the_Agent.asyncOutputPipe = new PipedOutputStream(var2);
  188.          Object var3 = the_Agent.pipeLock;
  189.          synchronized(var3){}
  190.  
  191.          try {
  192.             the_Agent.pipeLock.notifyAll();
  193.          } catch (Throwable var5) {
  194.             throw var5;
  195.          }
  196.  
  197.       } else {
  198.          throw new IllegalAccessError();
  199.       }
  200.    }
  201.  
  202.    static boolean isDebuggable() {
  203.       return the_Agent != null && !the_Agent.useSockets;
  204.    }
  205.  
  206.    public void run() {
  207.       Object var1 = null;
  208.       Object var2 = null;
  209.       Socket var3 = null;
  210.       Socket var4 = null;
  211.       String var5 = System.getProperty("java.class.path");
  212.       if (var5 == null) {
  213.          var5 = ".";
  214.       }
  215.  
  216.       this.sourcePath = new ClassPath(var5);
  217.  
  218.       try {
  219.          this.objects = new Hashtable();
  220.          this.bkptHandler = new BreakpointHandler(this);
  221.          this.bkptHandler.setPriority(9);
  222.          this.bkptHandler.start();
  223.          this.initAgent();
  224.          Class var6 = this.getClass();
  225.          synchronized(var6){}
  226.  
  227.          try {
  228.             var6.notifyAll();
  229.          } catch (Throwable var36) {
  230.             throw var36;
  231.          }
  232.  
  233.          initSystemThreadList();
  234.  
  235.          while(true) {
  236.             DataInputStream var7;
  237.             while(true) {
  238.                var41 = System.out;
  239.                var42 = System.err;
  240.                if (this.useSockets) {
  241.                   var3 = this.socket.accept();
  242.                   message("cmd socket: " + var3.toString());
  243.                   var7 = new DataInputStream(new BufferedInputStream(var3.getInputStream()));
  244.                   this.outBuffer = new ResponseStream(var3.getOutputStream(), 8192);
  245.                   this.out = new DataOutputStream(this.outBuffer);
  246.                   var4 = this.socket.accept();
  247.                   this.asyncOutputStream = new DataOutputStream(new BufferedOutputStream(var4.getOutputStream()));
  248.                   AgentOutputStream var46 = new AgentOutputStream(this.asyncOutputStream);
  249.                   BufferedOutputStream var48 = new BufferedOutputStream(var46, 128);
  250.                   PrintStream var10 = new PrintStream(var48, true);
  251.                   System.setOut(var10);
  252.                   System.setErr(var10);
  253.                   break;
  254.                }
  255.  
  256.                try {
  257.                   Object var8 = the_Agent.pipeLock;
  258.                   synchronized(var8){}
  259.  
  260.                   try {
  261.                      the_Agent.pipeLock.wait();
  262.                   } catch (Throwable var35) {
  263.                      throw var35;
  264.                   }
  265.                } catch (InterruptedException var37) {
  266.                   continue;
  267.                }
  268.  
  269.                var7 = new DataInputStream(this.cmdInputPipe);
  270.                this.outBuffer = new ResponseStream(this.cmdOutputPipe, 8192);
  271.                this.out = new DataOutputStream(this.outBuffer);
  272.                this.asyncOutputStream = new DataOutputStream(this.asyncOutputPipe);
  273.                AgentOutputStream var45 = new AgentOutputStream(this.asyncOutputPipe);
  274.                PrintStream var9 = new PrintStream(var45, true);
  275.                System.setOut(var9);
  276.                System.setErr(var9);
  277.                break;
  278.             }
  279.  
  280.             message("connection accepted");
  281.             this.out.writeInt(3);
  282.  
  283.             try {
  284.                this.writeObject(Class.forName("java.lang.Object"));
  285.                this.writeObject(Class.forName("java.lang.Class"));
  286.                this.writeObject(Class.forName("java.lang.String"));
  287.             } catch (ClassNotFoundException var34) {
  288.                System.exit(1);
  289.             }
  290.  
  291.             this.dumpClasses();
  292.             this.writeObject(Thread.currentThread().getThreadGroup());
  293.             this.out.flush();
  294.  
  295.             try {
  296.                for(int var47 = ((FilterInputStream)var7).read(); var47 != -1; var47 = ((FilterInputStream)var7).read()) {
  297.                   try {
  298.                      this.handle(var47, var7, this.out);
  299.                   } catch (Throwable var33) {
  300.                      error(this.exceptionStackTrace(var33));
  301.                      this.outBuffer.reset();
  302.                      this.out.writeInt(-2);
  303.                      this.out.writeUTF(var33.toString());
  304.                   }
  305.  
  306.                   this.out.flush();
  307.                }
  308.             } catch (Exception var38) {
  309.                System.setOut(var41);
  310.                System.setErr(var42);
  311.                error(this.exceptionStackTrace(var38));
  312.             }
  313.  
  314.             System.setOut(var41);
  315.             System.setErr(var42);
  316.             message("connection closed");
  317.          }
  318.       } catch (ThreadDeath var39) {
  319.          System.setOut((PrintStream)var1);
  320.          System.setErr((PrintStream)var2);
  321.          message("ThreadDeath caught.");
  322.       } catch (IOException var40) {
  323.          System.setOut((PrintStream)var1);
  324.          System.setErr((PrintStream)var2);
  325.          message("IOException caught.");
  326.       }
  327.  
  328.       if (var4 != null) {
  329.          try {
  330.             var4.close();
  331.          } catch (Exception var32) {
  332.          }
  333.       }
  334.  
  335.       if (var3 != null) {
  336.          try {
  337.             var3.close();
  338.          } catch (Exception var31) {
  339.          }
  340.       }
  341.    }
  342.  
  343.    public static synchronized native boolean systemThread(Thread var0);
  344.  
  345.    private static void initSystemThread(String var0) {
  346.       ThreadGroup var1 = Thread.currentThread().getThreadGroup();
  347.       if (!var1.getName().equals("system")) {
  348.          error("findThread called from wrong threadgroup");
  349.       } else {
  350.          Thread[] var2 = new Thread[40];
  351.          int var3 = var1.enumerate(var2, false);
  352.  
  353.          for(int var4 = 0; var4 < var3; ++var4) {
  354.             if (var2[var4].getName().equals(var0)) {
  355.                message("adding " + var0 + " to system thread list");
  356.                addSystemThread(var2[var4]);
  357.                return;
  358.             }
  359.          }
  360.  
  361.          message(var0 + " not found in system threadgroup");
  362.       }
  363.    }
  364.  
  365.    private static void initSystemThreadList() {
  366.       initSystemThread("Idle thread");
  367.       initSystemThread("Clock");
  368.       initSystemThread("Debugger agent");
  369.       initSystemThread("Breakpoint handler");
  370.    }
  371.  
  372.    public static synchronized native void addSystemThread(Thread var0);
  373.  
  374.    public static synchronized native void removeSystemThread(Thread var0);
  375.  
  376.    private void suspendThread(Thread var1) {
  377.       if (!systemThread(var1)) {
  378.          message("suspending " + var1.getName());
  379.  
  380.          try {
  381.             var1.suspend();
  382.          } catch (IllegalThreadStateException var3) {
  383.             error("suspend failed: " + ((Throwable)var3).getMessage());
  384.          }
  385.       }
  386.    }
  387.  
  388.    private void stepThread(Thread var1, boolean var2) {
  389.       if (!systemThread(var1)) {
  390.          message("stepping " + var1.getName());
  391.  
  392.          try {
  393.             if (var2) {
  394.                StackFrame var3 = this.getStackFrame(var1, 0);
  395.                LineNumber var4 = this.lineno2pc(var3.clazz, var3.lineno);
  396.                if (var4 != null) {
  397.                   var4.thread = var1;
  398.                   this.bkptHandler.addSkipLine(var4);
  399.                }
  400.             }
  401.  
  402.             this.setSingleStep(var1, true);
  403.             this.resumeLastSuspendedThreads();
  404.          } catch (IllegalThreadStateException var5) {
  405.             error("step failed: " + ((Throwable)var5).getMessage());
  406.          }
  407.       }
  408.    }
  409.  
  410.    private void stepNextThread(Thread var1) {
  411.       if (!systemThread(var1)) {
  412.          message("next stepping " + var1.getName());
  413.  
  414.          try {
  415.             int var2 = 0;
  416.  
  417.             StackFrame var3;
  418.             LineNumber var4;
  419.             try {
  420.                do {
  421.                   var3 = this.getStackFrame(var1, var2);
  422.                   var4 = this.lineno2pc(var3.clazz, var3.lineno);
  423.                   ++var2;
  424.                } while(var4 == null);
  425.             } catch (NullPointerException var18) {
  426.                message("no line information available, single-stepping.");
  427.                this.stepThread(var1, false);
  428.                return;
  429.             }
  430.  
  431.             FlowTracer var5 = new FlowTracer(var3.pcAbsolute, this, var3.clazz, var3.lineno);
  432.             int[] var6 = var5.exitPoints();
  433.             if (verbose) {
  434.                message("------------------");
  435.                message("Exit points for class: " + var3.clazz + ", line: " + var3.lineno + ", pc: " + var3.pcAbsolute);
  436.  
  437.                for(int var7 = 0; var7 < var6.length; ++var7) {
  438.                   int var8 = var6[var7];
  439.                   message("  " + this.pc2lineno(var3.clazz, var8) + ": " + var8);
  440.                }
  441.             }
  442.  
  443.             int[] var20 = var5.returnPoints();
  444.             if (var20.length > 0) {
  445.                StackFrame var21 = this.getStackFrame(var1, var2);
  446.                FlowTracer var9 = new FlowTracer(var21.pcAbsolute, this);
  447.                int[] var10 = var9.exitPoints();
  448.                int[] var11 = new int[var6.length + var10.length];
  449.                int var12 = 0;
  450.  
  451.                for(int var13 = 0; var13 < var6.length; ++var13) {
  452.                   var11[var12++] = var6[var13];
  453.                }
  454.  
  455.                for(int var14 = 0; var14 < var10.length; ++var14) {
  456.                   var11[var12++] = var10[var14];
  457.                }
  458.  
  459.                var6 = var11;
  460.                if (verbose) {
  461.                   message("Caller in class: " + var21.clazz);
  462.                   message("  " + this.pc2lineno(var21.clazz, var21.pcAbsolute) + ": " + var21.pcAbsolute);
  463.                   message("Return point:");
  464.  
  465.                   for(int var15 = 0; var15 < var10.length; ++var15) {
  466.                      int var16 = var10[var15];
  467.                      message("  " + this.pc2lineno(var21.clazz, var16) + ": " + var16);
  468.                   }
  469.                }
  470.             }
  471.  
  472.             try {
  473.                this.bkptHandler.addScattershotBreakpoints(var3.clazz, var6, var1);
  474.             } catch (Exception var17) {
  475.                message("next-step failed: " + ((Throwable)var17).toString() + ", single-stepping.");
  476.                this.stepThread(var1, false);
  477.                return;
  478.             }
  479.  
  480.             this.resumeLastSuspendedThreads();
  481.          } catch (IllegalThreadStateException var19) {
  482.             error("next step failed: " + ((Throwable)var19).getMessage());
  483.          }
  484.       }
  485.    }
  486.  
  487.    void suspendAllThreads() {
  488.       message("suspendAllThreads()");
  489.       ThreadList var1 = new ThreadList();
  490.  
  491.       for(int var2 = 0; var2 < var1.count; ++var2) {
  492.          this.suspendThread(var1.threads[var2]);
  493.       }
  494.  
  495.       this.lastSuspended = var1;
  496.    }
  497.  
  498.    void resumeLastSuspendedThreads() {
  499.       ThreadList var1 = this.lastSuspended;
  500.       this.lastSuspended = null;
  501.       if (var1 == null) {
  502.          message("no last suspended to resume");
  503.       } else {
  504.          message("resumeLastSuspendedThreads()");
  505.  
  506.          for(int var2 = 0; var2 < var1.count; ++var2) {
  507.             this.resumeThread(var1.threads[var2]);
  508.          }
  509.  
  510.       }
  511.    }
  512.  
  513.    private void resumeThread(Thread var1) {
  514.       if (!systemThread(var1)) {
  515.          message("resuming " + var1.getName());
  516.  
  517.          try {
  518.             var1.resume();
  519.          } catch (IllegalThreadStateException var3) {
  520.             error("resume failed: " + ((Throwable)var3).getMessage());
  521.          }
  522.       }
  523.    }
  524.  
  525.    int peekSafely(int var1) {
  526.       int var2 = this.peek(var1);
  527.       if (var2 == 202) {
  528.          var2 = BreakpointHandler.getOpcode(var1);
  529.       }
  530.  
  531.       return var2;
  532.    }
  533.  
  534.    private native int peek(int var1);
  535.  
  536.    native int getThreadStatus(Thread var1);
  537.  
  538.    native StackFrame getStackFrame(Thread var1, int var2);
  539.  
  540.    native Field[] getMethods(Class var1);
  541.  
  542.    native Field[] getFields(Class var1);
  543.  
  544.    native Class[] getClasses();
  545.  
  546.    native Object getSlotObject(Object var1, int var2);
  547.  
  548.    native int[] getSlotSignature(Class var1, int var2);
  549.  
  550.    native boolean getSlotBoolean(Object var1, int var2);
  551.  
  552.    native int getSlotInt(Object var1, int var2);
  553.  
  554.    native long getSlotLong(Object var1, int var2);
  555.  
  556.    native double getSlotDouble(Object var1, int var2);
  557.  
  558.    native Object[] getSlotArray(Object var1, int var2);
  559.  
  560.    native Object getStackObject(Thread var1, int var2, int var3);
  561.  
  562.    native boolean getStackBoolean(Thread var1, int var2, int var3);
  563.  
  564.    native int getStackInt(Thread var1, int var2, int var3);
  565.  
  566.    native long getStackLong(Thread var1, int var2, int var3);
  567.  
  568.    native float getStackFloat(Thread var1, int var2, int var3);
  569.  
  570.    native double getStackDouble(Thread var1, int var2, int var3);
  571.  
  572.    native Object[] getStackArray(Thread var1, int var2, int var3);
  573.  
  574.    native LineNumber lineno2pc(Class var1, int var2);
  575.  
  576.    native int pc2lineno(Class var1, int var2);
  577.  
  578.    native int method2pc(Class var1, int var2);
  579.  
  580.    native String exceptionStackTrace(Throwable var1);
  581.  
  582.    native void setSingleStep(Thread var1, boolean var2);
  583.  
  584.    native void initAgent();
  585.  
  586.    native String getClassSourceName(Class var1);
  587.  
  588.    native int[] getLinenumbers(Class var1);
  589.  
  590.    native int getMethodLinenumber(Class var1, int var2);
  591.  
  592.    native void setSlotBoolean(Object var1, int var2, boolean var3);
  593.  
  594.    native void setSlotInt(Object var1, int var2, int var3);
  595.  
  596.    native void setSlotLong(Object var1, int var2, long var3);
  597.  
  598.    native void setSlotDouble(Object var1, int var2, double var3);
  599.  
  600.    native void setStackBoolean(Thread var1, int var2, int var3, boolean var4);
  601.  
  602.    native void setStackInt(Thread var1, int var2, int var3, int var4);
  603.  
  604.    native void setStackLong(Thread var1, int var2, int var3, long var4);
  605.  
  606.    native void setStackDouble(Thread var1, int var2, int var3, double var4);
  607.  
  608.    synchronized void handle(int var1, DataInputStream var2, DataOutputStream var3) throws IOException {
  609.       var3.writeInt(var1);
  610.       switch (var1) {
  611.          case 20:
  612.             Class var63 = (Class)this.objects.get(new Integer(var2.readInt()));
  613.             var3.writeUTF(var63.getName());
  614.             var3.writeUTF(this.getClassSourceName(var63));
  615.             var3.writeInt(var63.isInterface() ? 1 : 0);
  616.             this.writeObject(var63.getSuperclass());
  617.             this.writeObject(var63.getClassLoader());
  618.             Class[] var89 = var63.getInterfaces();
  619.             var3.writeInt(var89.length);
  620.  
  621.             for(int var110 = 0; var110 < var89.length; ++var110) {
  622.                this.writeObject(var89[var110]);
  623.             }
  624.  
  625.             return;
  626.          case 21:
  627.             var3.writeUTF(((Thread)this.objects.get(new Integer(var2.readInt()))).getName());
  628.             return;
  629.          case 22:
  630.             String var62 = var2.readUTF();
  631.  
  632.             try {
  633.                this.writeObject(Class.forName(var62));
  634.                return;
  635.             } catch (ClassNotFoundException var26) {
  636.                message("no such class: " + var62);
  637.                this.writeObject((Object)null);
  638.                return;
  639.             } catch (NoClassDefFoundError var27) {
  640.                message("no such class: " + var62);
  641.                this.writeObject((Object)null);
  642.                return;
  643.             }
  644.          case 23:
  645.             int var61 = var2.readInt();
  646.             Hashtable var88 = new Hashtable();
  647.  
  648.             for(int var109 = 0; var109 < var61; ++var109) {
  649.                Object var126 = this.objects.get(new Integer(var2.readInt()));
  650.                if (var126 != null) {
  651.                   var88.put(new Integer(this.objectId(var126)), var126);
  652.                }
  653.             }
  654.  
  655.             var3.flush();
  656.             var1 = ((FilterInputStream)var2).read();
  657.             var3.writeInt(var1);
  658.             switch (var1) {
  659.                case 24:
  660.                   try {
  661.                      Hashtable var127 = new Hashtable();
  662.                      Enumeration var146 = this.objects.elements();
  663.  
  664.                      while(var146.hasMoreElements()) {
  665.                         Object var161 = var146.nextElement();
  666.                         var127.put(new Integer(this.objectId(var161)), var161);
  667.                      }
  668.  
  669.                      var146 = this.objects.elements();
  670.  
  671.                      while(var146.hasMoreElements()) {
  672.                         Object var162 = var146.nextElement();
  673.                         if (!(var162 instanceof Class)) {
  674.                            Integer var165 = new Integer(this.objectId(var162));
  675.                            if (var88.get(var165) == null) {
  676.                               message("gc: freeing " + var162);
  677.                               var127.remove(var165);
  678.                            }
  679.                         }
  680.                      }
  681.  
  682.                      this.objects = var127;
  683.                      System.gc();
  684.                      var146 = this.objects.elements();
  685.  
  686.                      while(var146.hasMoreElements()) {
  687.                         Object var163 = var146.nextElement();
  688.                         if (var163 != null) {
  689.                            this.writeObject(var163);
  690.                         }
  691.                      }
  692.  
  693.                      this.writeObject((Object)null);
  694.                   } catch (Exception var30) {
  695.                      error("CMD_MARK_OBJECTS failed: " + ((Throwable)var30).toString());
  696.                   }
  697.                   break;
  698.                default:
  699.                   error("mark objects command failed");
  700.             }
  701.  
  702.             var3.flush();
  703.             return;
  704.          case 25:
  705.             Thread[] var60 = new Thread[40];
  706.             ThreadGroup var87 = (ThreadGroup)this.objects.get(new Integer(var2.readInt()));
  707.             boolean var108 = var2.readBoolean();
  708.             message("Getting threads for " + var87.getName());
  709.             int var125 = var87.enumerate(var60, var108);
  710.             var3.writeInt(var125);
  711.  
  712.             for(int var145 = 0; var145 < var125; ++var145) {
  713.                this.writeObject(var60[var145]);
  714.             }
  715.  
  716.             return;
  717.          case 26:
  718.             String[] var59 = new String[((FilterInputStream)var2).read() - 1];
  719.             String var86 = var2.readUTF();
  720.             new String("");
  721.  
  722.             for(int var107 = 0; var107 < var59.length; ++var107) {
  723.                var59[var107] = var2.readUTF();
  724.             }
  725.  
  726.             try {
  727.                Class var124 = Class.forName(var86);
  728.                ThreadGroup var144 = new ThreadGroup(var124.getName() + ".main");
  729.                MainThread var160 = new MainThread(this, var144, var124, var59);
  730.                this.writeObject(((Thread)var160).getThreadGroup());
  731.                beginRun();
  732.                return;
  733.             } catch (Exception var25) {
  734.                message(this.exceptionStackTrace(var25));
  735.                this.writeObject((Object)null);
  736.                return;
  737.             }
  738.          case 27:
  739.             this.suspendThread((Thread)this.objects.get(new Integer(var2.readInt())));
  740.             return;
  741.          case 28:
  742.             this.resumeThread((Thread)this.objects.get(new Integer(var2.readInt())));
  743.             return;
  744.          case 29:
  745.             this.resumeLastSuspendedThreads();
  746.             return;
  747.          case 31:
  748.             var3.writeInt(this.getThreadStatus((Thread)this.objects.get(new Integer(var2.readInt()))));
  749.             return;
  750.          case 32:
  751.             Thread var58 = (Thread)this.objects.get(new Integer(var2.readInt()));
  752.             int var85 = var58.countStackFrames();
  753.             var3.writeInt(var85);
  754.  
  755.             for(int var106 = 0; var106 < var85; ++var106) {
  756.                StackFrame var123 = this.getStackFrame(var58, var106);
  757.                this.writeObject(var123);
  758.                var3.writeUTF(var123.className);
  759.                var3.writeUTF(var123.methodName);
  760.                var3.writeInt(var123.lineno);
  761.                var3.writeInt(var123.pc);
  762.                this.writeObject(var123.clazz);
  763.                var3.writeInt(var123.localVariables.length);
  764.  
  765.                for(int var143 = 0; var143 < var123.localVariables.length; ++var143) {
  766.                   message("lvar " + var143 + ": slot=" + var123.localVariables[var143].slot + ", name=" + var123.localVariables[var143].name + ", sig=" + var123.localVariables[var143].signature + ", argument=" + var123.localVariables[var143].methodArgument);
  767.                   var3.writeInt(var123.localVariables[var143].slot);
  768.                   var3.writeUTF(var123.localVariables[var143].name);
  769.                   var3.writeUTF(var123.localVariables[var143].signature);
  770.                   var3.writeBoolean(var123.localVariables[var143].methodArgument);
  771.                }
  772.             }
  773.  
  774.             return;
  775.          case 34:
  776.             switch (var2.readInt()) {
  777.                case 1:
  778.                   var3.writeInt((int)Runtime.getRuntime().totalMemory());
  779.                   return;
  780.                case 2:
  781.                   var3.writeInt((int)Runtime.getRuntime().freeMemory());
  782.                   return;
  783.                case 3:
  784.                   Runtime.getRuntime().traceMethodCalls(var2.readInt() != 0);
  785.                   return;
  786.                case 4:
  787.                   Runtime.getRuntime().traceInstructions(var2.readInt() != 0);
  788.                   return;
  789.                default:
  790.                   return;
  791.             }
  792.          case 35:
  793.             Class var57 = (Class)this.objects.get(new Integer(var2.readInt()));
  794.             Field[] var84 = this.getFields(var57);
  795.             var3.writeInt(var84.length);
  796.  
  797.             for(int var105 = 0; var105 < var84.length; ++var105) {
  798.                var3.writeInt(var84[var105].slot);
  799.                var3.writeUTF(var84[var105].name);
  800.                var3.writeUTF(var84[var105].signature);
  801.                var3.writeShort(var84[var105].access);
  802.                this.writeObject(var84[var105].clazz);
  803.             }
  804.  
  805.             return;
  806.          case 36:
  807.             Class var56 = (Class)this.objects.get(new Integer(var2.readInt()));
  808.             Field[] var83 = this.getMethods(var56);
  809.             var3.writeInt(var83.length);
  810.  
  811.             for(int var104 = 0; var104 < var83.length; ++var104) {
  812.                var3.writeInt(var83[var104].slot);
  813.                var3.writeUTF(var83[var104].name);
  814.                var3.writeUTF(var83[var104].signature);
  815.                var3.writeShort(var83[var104].access);
  816.                this.writeObject(var83[var104].clazz);
  817.             }
  818.  
  819.             return;
  820.          case 38:
  821.             Class var55 = (Class)this.objects.get(new Integer(var2.readInt()));
  822.             int var82 = var2.readInt();
  823.             int[] var103 = this.getSlotSignature(var55, var82);
  824.             if (var103 == null) {
  825.                var3.writeInt(0);
  826.                return;
  827.             }
  828.  
  829.             var3.writeInt(var103.length);
  830.  
  831.             for(int var122 = 0; var122 < var103.length; ++var122) {
  832.                var3.writeInt(var103[var122]);
  833.             }
  834.  
  835.             return;
  836.          case 39:
  837.             Object var53 = this.objects.get(new Integer(var2.readInt()));
  838.             int var80 = var2.readInt();
  839.             int[] var101 = this.getSlotSignature(var53 instanceof Class ? (Class)var53 : var53.getClass(), var80);
  840.             if (var101 == null) {
  841.                this.writeObject(new ArrayIndexOutOfBoundsException("invalid slot index " + var80));
  842.                return;
  843.             } else {
  844.                String var141;
  845.                int var159;
  846.                switch (var101[0]) {
  847.                   case 0:
  848.                      this.write(this.getSlotBoolean(var53, var80));
  849.                      return;
  850.                   case 1:
  851.                      this.write((byte)this.getSlotInt(var53, var80));
  852.                      return;
  853.                   case 2:
  854.                      this.write((char)this.getSlotInt(var53, var80));
  855.                      return;
  856.                   case 3:
  857.                      this.write((short)this.getSlotInt(var53, var80));
  858.                      return;
  859.                   case 4:
  860.                      this.write(this.getSlotInt(var53, var80));
  861.                      return;
  862.                   case 5:
  863.                      this.write(this.getSlotLong(var53, var80));
  864.                      return;
  865.                   case 6:
  866.                      this.write((float)this.getSlotDouble(var53, var80));
  867.                      return;
  868.                   case 7:
  869.                      this.write(this.getSlotDouble(var53, var80));
  870.                      return;
  871.                   case 9:
  872.                      Object[] var121 = this.getSlotArray(var53, var80);
  873.                      this.writeArray(var121);
  874.                      return;
  875.                   case 11:
  876.                      this.writeObject((Object)null);
  877.                      return;
  878.                   case 16:
  879.                   case 17:
  880.                      Object var120 = this.getSlotObject(var53, var80);
  881.                      this.writeObject(var120);
  882.                      return;
  883.                   default:
  884.                      var141 = new String("bogus signature(");
  885.                      var159 = 0;
  886.                }
  887.  
  888.                while(var159 < var101.length) {
  889.                   var141 = var141.concat(" " + (new Integer(var101[var159])).toString());
  890.                   ++var159;
  891.                }
  892.  
  893.                var141 = var141.concat(" )");
  894.                error(var141);
  895.                this.writeObject(var141);
  896.             }
  897.          case 68:
  898.             Object var54 = this.objects.get(new Integer(var2.readInt()));
  899.             int var81 = var2.readInt();
  900.             int var102 = var2.readInt();
  901.             switch (var102) {
  902.                case 0:
  903.                   this.setSlotBoolean(var54, var81, var2.readBoolean());
  904.                   return;
  905.                case 4:
  906.                   this.setSlotInt(var54, var81, var2.readInt());
  907.                   return;
  908.                case 5:
  909.                   this.setSlotLong(var54, var81, var2.readLong());
  910.                   return;
  911.                case 7:
  912.                   this.setSlotDouble(var54, var81, var2.readDouble());
  913.                   return;
  914.                default:
  915.                   error("bogus type(" + var102 + ")");
  916.                   return;
  917.             }
  918.          case 40:
  919.             Object var52 = this.objects.get(new Integer(var2.readInt()));
  920.             int var79 = var2.readInt();
  921.             int var100 = var2.readInt();
  922.             int var119 = var2.readInt();
  923.             var3.writeInt(var119 - var100 + 1);
  924.             switch (var79) {
  925.                case 0:
  926.                   boolean[] var139 = (boolean[])var52;
  927.  
  928.                   for(int var158 = var100; var158 <= var119; ++var158) {
  929.                      this.write(var139[var158]);
  930.                   }
  931.  
  932.                   return;
  933.                case 1:
  934.                   byte[] var138 = (byte[])var52;
  935.  
  936.                   for(int var157 = var100; var157 <= var119; ++var157) {
  937.                      this.write(var138[var157]);
  938.                   }
  939.  
  940.                   return;
  941.                case 2:
  942.                   char[] var137 = (char[])var52;
  943.  
  944.                   for(int var156 = var100; var156 <= var119; ++var156) {
  945.                      this.write(var137[var156]);
  946.                   }
  947.  
  948.                   return;
  949.                case 3:
  950.                   short[] var136 = (short[])var52;
  951.  
  952.                   for(int var155 = var100; var155 <= var119; ++var155) {
  953.                      this.write(var136[var155]);
  954.                   }
  955.  
  956.                   return;
  957.                case 4:
  958.                   int[] var135 = (int[])var52;
  959.  
  960.                   for(int var154 = var100; var154 <= var119; ++var154) {
  961.                      this.write(var135[var154]);
  962.                   }
  963.  
  964.                   return;
  965.                case 5:
  966.                   long[] var134 = (long[])var52;
  967.  
  968.                   for(int var153 = var100; var153 <= var119; ++var153) {
  969.                      this.write(var134[var153]);
  970.                   }
  971.  
  972.                   return;
  973.                case 6:
  974.                   float[] var133 = (float[])var52;
  975.  
  976.                   for(int var152 = var100; var152 <= var119; ++var152) {
  977.                      this.write(var133[var152]);
  978.                   }
  979.  
  980.                   return;
  981.                case 7:
  982.                   double[] var132 = (double[])var52;
  983.  
  984.                   for(int var151 = var100; var151 <= var119; ++var151) {
  985.                      this.write(var132[var151]);
  986.                   }
  987.  
  988.                   return;
  989.                case 10:
  990.                case 17:
  991.                   Object[] var131 = var52;
  992.  
  993.                   for(int var150 = var100; var150 <= var119; ++var150) {
  994.                      this.writeObject(var131[var150]);
  995.                   }
  996.  
  997.                   return;
  998.                case 11:
  999.                default:
  1000.                   for(int var140 = var100; var140 <= var119; ++var140) {
  1001.                      this.writeObject((Object)null);
  1002.                   }
  1003.  
  1004.                   return;
  1005.             }
  1006.          case 41:
  1007.             Class var51 = (Class)this.objects.get(new Integer(var2.readInt()));
  1008.             int var78 = var2.readInt();
  1009.             LineNumber var99 = this.lineno2pc(var51, var78);
  1010.             String var118 = "";
  1011.             if (var99 == null) {
  1012.                var118 = "No code at line " + var78 + ", or class is optimized.";
  1013.             } else {
  1014.                try {
  1015.                   this.bkptHandler.addBreakpoint(var51, var99.startPC, 1, (byte[])null);
  1016.                } catch (Exception var24) {
  1017.                   message(this.exceptionStackTrace(var24));
  1018.                   var118 = ((Throwable)var24).toString();
  1019.                }
  1020.             }
  1021.  
  1022.             var3.writeUTF(var118);
  1023.             return;
  1024.          case 42:
  1025.             Class var50 = (Class)this.objects.get(new Integer(var2.readInt()));
  1026.             int var77 = var2.readInt();
  1027.             int var98 = this.method2pc(var50, var77);
  1028.             message("method2pc(" + var50.getName() + "," + var77 + ") = " + var98);
  1029.             String var117 = "";
  1030.             if (var98 == -1) {
  1031.                var117 = "Not a Java method";
  1032.             } else {
  1033.                try {
  1034.                   this.bkptHandler.addBreakpoint(var50, var98, 1, (byte[])null);
  1035.                } catch (Exception var23) {
  1036.                   message(this.exceptionStackTrace(var23));
  1037.                   var117 = ((Throwable)var23).toString();
  1038.                }
  1039.             }
  1040.  
  1041.             var3.writeUTF(var117);
  1042.             return;
  1043.          case 43:
  1044.             Class var49 = (Class)this.objects.get(new Integer(var2.readInt()));
  1045.             int var76 = var2.readInt();
  1046.             message("clearing bkpt at " + var49.getName() + ":" + var76);
  1047.             String var97 = "";
  1048.             if (var76 == -1) {
  1049.                var97 = "No code at pc " + var76;
  1050.             } else {
  1051.                try {
  1052.                   this.bkptHandler.deleteBreakpoint(var49, var76);
  1053.                } catch (Exception var22) {
  1054.                   message(this.exceptionStackTrace(var22));
  1055.                   var97 = ((Throwable)var22).toString();
  1056.                }
  1057.             }
  1058.  
  1059.             var3.writeUTF(var97);
  1060.             return;
  1061.          case 44:
  1062.             Class var48 = (Class)this.objects.get(new Integer(var2.readInt()));
  1063.             int var75 = var2.readInt();
  1064.             message("clearing bkpt at " + var48.getName() + ":" + var75);
  1065.             LineNumber var96 = this.lineno2pc(var48, var75);
  1066.             String var116 = "";
  1067.             if (var96 == null) {
  1068.                var116 = "No code at line " + var75 + ", or class is optimized.";
  1069.             } else {
  1070.                try {
  1071.                   this.bkptHandler.deleteBreakpoint(var48, var96.startPC);
  1072.                } catch (Exception var21) {
  1073.                   message(this.exceptionStackTrace(var21));
  1074.                   var116 = ((Throwable)var21).toString();
  1075.                }
  1076.             }
  1077.  
  1078.             var3.writeUTF(var116);
  1079.             return;
  1080.          case 45:
  1081.             Class var47 = (Class)this.objects.get(new Integer(var2.readInt()));
  1082.             int var74 = var2.readInt();
  1083.             message("clearing bkpt at " + var47.getName());
  1084.             int var95 = this.method2pc(var47, var74);
  1085.             String var115 = "";
  1086.             if (var95 == -1) {
  1087.                var115 = "Not a Java method";
  1088.             } else {
  1089.                try {
  1090.                   this.bkptHandler.deleteBreakpoint(var47, var95);
  1091.                } catch (Exception var20) {
  1092.                   message(this.exceptionStackTrace(var20));
  1093.                   var115 = ((Throwable)var20).toString();
  1094.                }
  1095.             }
  1096.  
  1097.             var3.writeUTF(var115);
  1098.             return;
  1099.          case 47:
  1100.             ThreadGroup[] var46 = new ThreadGroup[20];
  1101.             ThreadGroup var72 = (ThreadGroup)this.objects.get(new Integer(var2.readInt()));
  1102.             int var93 = 0;
  1103.             if (var72 == null) {
  1104.                message("Getting all threadgroups");
  1105.                var72 = Thread.currentThread().getThreadGroup();
  1106.                var93 = var72.enumerate(var46);
  1107.                var3.writeInt(var93 + 1);
  1108.                this.writeObject(var72);
  1109.             } else {
  1110.                message("Getting threadgroups for " + var72.getName());
  1111.                var93 = var72.enumerate(var46);
  1112.                var3.writeInt(var93);
  1113.             }
  1114.  
  1115.             for(int var114 = 0; var114 < var93; ++var114) {
  1116.                this.writeObject(var46[var114]);
  1117.             }
  1118.  
  1119.             return;
  1120.          case 48:
  1121.             ThreadGroup var45 = (ThreadGroup)this.objects.get(new Integer(var2.readInt()));
  1122.             this.writeObject(var45.getParent());
  1123.             var3.writeUTF(var45.getName());
  1124.             var3.writeInt(var45.getMaxPriority());
  1125.             var3.writeBoolean(var45.isDaemon());
  1126.             return;
  1127.          case 49:
  1128.             Class[] var44 = this.getClasses();
  1129.             var3.writeInt(var44.length);
  1130.  
  1131.             for(int var71 = 0; var71 < var44.length; ++var71) {
  1132.                this.writeObject(var44[var71]);
  1133.             }
  1134.  
  1135.             return;
  1136.          case 50:
  1137.             Thread var43 = (Thread)this.objects.get(new Integer(var2.readInt()));
  1138.             int var70 = var2.readInt();
  1139.             int var92 = var2.readInt();
  1140.             char var113 = var2.readChar();
  1141.             switch (var113) {
  1142.                case 'B':
  1143.                   this.write((byte)this.getStackInt(var43, var70, var92));
  1144.                   return;
  1145.                case 'C':
  1146.                   this.write((char)this.getStackInt(var43, var70, var92));
  1147.                   return;
  1148.                case 'D':
  1149.                   this.write(this.getStackDouble(var43, var70, var92));
  1150.                   return;
  1151.                case 'F':
  1152.                   this.write(this.getStackFloat(var43, var70, var92));
  1153.                   return;
  1154.                case 'I':
  1155.                   this.write(this.getStackInt(var43, var70, var92));
  1156.                   return;
  1157.                case 'J':
  1158.                   this.write(this.getStackLong(var43, var70, var92));
  1159.                   return;
  1160.                case 'L':
  1161.                   this.writeObject(this.getStackObject(var43, var70, var92));
  1162.                   return;
  1163.                case 'S':
  1164.                   this.write((short)this.getStackInt(var43, var70, var92));
  1165.                   return;
  1166.                case 'V':
  1167.                   this.writeObject((Object)null);
  1168.                   return;
  1169.                case 'Z':
  1170.                   this.write(this.getStackBoolean(var43, var70, var92));
  1171.                   return;
  1172.                case '[':
  1173.                   Object[] var129 = this.getStackArray(var43, var70, var92);
  1174.                   this.writeArray(var129);
  1175.                   return;
  1176.                default:
  1177.                   String var130 = new String("bogus signature(" + var113 + ")");
  1178.                   error(var130);
  1179.                   this.writeObject(var130);
  1180.                   return;
  1181.             }
  1182.          case 51:
  1183.             verbose = var2.readBoolean();
  1184.             return;
  1185.          case 53:
  1186.             try {
  1187.                Class var42 = (Class)this.objects.get(new Integer(var2.readInt()));
  1188.                this.bkptHandler.catchExceptionClass(var42);
  1189.                return;
  1190.             } catch (Exception var19) {
  1191.                error("catchExceptionClass failed: " + var19);
  1192.                return;
  1193.             }
  1194.          case 54:
  1195.             try {
  1196.                Class var41 = (Class)this.objects.get(new Integer(var2.readInt()));
  1197.                this.bkptHandler.ignoreExceptionClass(var41);
  1198.                return;
  1199.             } catch (Exception var18) {
  1200.                error("ignoreExceptionClass failed: " + var18);
  1201.                return;
  1202.             }
  1203.          case 55:
  1204.             Class[] var40 = this.bkptHandler.getCatchList();
  1205.             var3.writeInt(var40.length);
  1206.  
  1207.             for(int var69 = 0; var69 < var40.length; ++var69) {
  1208.                this.writeObject(var40[var69]);
  1209.             }
  1210.  
  1211.             return;
  1212.          case 56:
  1213.             Thread var39 = (Thread)this.objects.get(new Integer(var2.readInt()));
  1214.             var39.stop();
  1215.             message(var39.getName() + " stopped.");
  1216.             return;
  1217.          case 57:
  1218.             ThreadGroup var38 = (ThreadGroup)this.objects.get(new Integer(var2.readInt()));
  1219.             var38.stop();
  1220.             message(var38.getName() + " stopped.");
  1221.             return;
  1222.          case 58:
  1223.             System.exit(0);
  1224.          case 24:
  1225.          case 30:
  1226.          case 33:
  1227.          case 37:
  1228.          case 46:
  1229.          case 52:
  1230.          case 66:
  1231.          case 67:
  1232.          default:
  1233.             error("command not understood: " + var1);
  1234.             return;
  1235.          case 59:
  1236.             String var37 = var2.readUTF();
  1237.             String var68 = var2.readUTF();
  1238.             int var91 = var68.lastIndexOf(46);
  1239.             String var112 = var91 >= 0 ? var68.substring(0, var91) : "";
  1240.             Object var8 = null;
  1241.  
  1242.             try {
  1243.                var128 = new Package(this.sourcePath, Identifier.lookup(var112));
  1244.             } catch (Exception var17) {
  1245.                message("cannot create a Package for " + var112);
  1246.                var3.writeInt(-1);
  1247.                return;
  1248.             }
  1249.  
  1250.             Object var9 = null;
  1251.             Object var10 = null;
  1252.  
  1253.             try {
  1254.                var149 = var128.getSourceFile(var37);
  1255.                if (var149 == null) {
  1256.                   message("no source " + var37);
  1257.                   var3.writeInt(-1);
  1258.                   return;
  1259.                }
  1260.  
  1261.                var164 = var149.getInputStream();
  1262.             } catch (Exception var29) {
  1263.                message("cannot find " + var37);
  1264.                var3.writeInt(-1);
  1265.                return;
  1266.             }
  1267.  
  1268.             int var11 = (int)var149.length();
  1269.             var3.writeInt(var11);
  1270.             byte[] var12 = new byte[var11];
  1271.  
  1272.             try {
  1273.                int var13 = 0;
  1274.  
  1275.                int var15;
  1276.                for(int var14 = var12.length; var14 > 0; var14 -= var15) {
  1277.                   var15 = var164.read(var12, var13, var14);
  1278.                   if (var15 == -1) {
  1279.                      throw new IOException();
  1280.                   }
  1281.  
  1282.                   var13 += var15;
  1283.                }
  1284.  
  1285.                ((FilterOutputStream)var3).write(var12);
  1286.             } catch (IOException var28) {
  1287.                error("unable to read " + var37);
  1288.                return;
  1289.             }
  1290.  
  1291.             var164.close();
  1292.             return;
  1293.          case 60:
  1294.             Object var36 = this.objects.get(new Integer(var2.readInt()));
  1295.             String var67 = "";
  1296.  
  1297.             try {
  1298.                var67 = var36.toString();
  1299.             } catch (Exception var16) {
  1300.             }
  1301.  
  1302.             var3.writeUTF(var67);
  1303.             return;
  1304.          case 61:
  1305.             var3.writeUTF(this.sourcePath.toString());
  1306.             return;
  1307.          case 62:
  1308.             String var35 = var2.readUTF();
  1309.             if (var35 == null) {
  1310.                var35 = ".";
  1311.             }
  1312.  
  1313.             this.sourcePath = new ClassPath(var35);
  1314.             return;
  1315.          case 63:
  1316.             this.stepThread((Thread)this.objects.get(new Integer(var2.readInt())), var2.readBoolean());
  1317.             return;
  1318.          case 64:
  1319.             this.stepNextThread((Thread)this.objects.get(new Integer(var2.readInt())));
  1320.             return;
  1321.          case 65:
  1322.             BreakpointSet[] var34 = this.bkptHandler.listBreakpoints();
  1323.             var3.writeInt(var34.length);
  1324.  
  1325.             for(int var66 = 0; var66 < var34.length; ++var66) {
  1326.                var3.writeUTF(var34[var66].clazz.getName() + ":" + this.pc2lineno(var34[var66].clazz, var34[var66].pc));
  1327.             }
  1328.  
  1329.             return;
  1330.          case 69:
  1331.             Thread var33 = (Thread)this.objects.get(new Integer(var2.readInt()));
  1332.             int var65 = var2.readInt();
  1333.             int var90 = var2.readInt();
  1334.             int var111 = var2.readInt();
  1335.             switch (var111) {
  1336.                case 0:
  1337.                   this.setStackBoolean(var33, var65, var90, var2.readBoolean());
  1338.                   return;
  1339.                case 4:
  1340.                   this.setStackInt(var33, var65, var90, var2.readInt());
  1341.                   return;
  1342.                case 5:
  1343.                   this.setStackLong(var33, var65, var90, var2.readLong());
  1344.                   return;
  1345.                case 7:
  1346.                   this.setStackDouble(var33, var65, var90, var2.readDouble());
  1347.                   return;
  1348.                default:
  1349.                   error("bogus type(" + var111 + ")");
  1350.                   return;
  1351.             }
  1352.          case 70:
  1353.             this.objects.remove(new Integer(var2.readInt()));
  1354.             return;
  1355.          case 71:
  1356.             Class var32 = (Class)this.objects.get(new Integer(var2.readInt()));
  1357.             int[] var64 = this.getLinenumbers(var32);
  1358.             int var6 = var64.length;
  1359.             var3.writeInt(var6);
  1360.  
  1361.             for(int var7 = 0; var7 < var6; ++var7) {
  1362.                var3.writeInt(var64[var7]);
  1363.             }
  1364.  
  1365.             return;
  1366.          case 72:
  1367.             Class var4 = (Class)this.objects.get(new Integer(var2.readInt()));
  1368.             int var5 = var2.readInt();
  1369.             var3.writeInt(this.getMethodLinenumber(var4, var5));
  1370.       }
  1371.    }
  1372.  
  1373.    native int objectId(Object var1);
  1374.  
  1375.    native void runMain(Class var1, String[] var2);
  1376.  
  1377.    void writeObject(Object var1, DataOutputStream var2) throws IOException {
  1378.       int var3 = 0;
  1379.       if (var1 == null) {
  1380.          var2.writeInt(17);
  1381.       } else if (var1 instanceof Class) {
  1382.          var2.writeInt(16);
  1383.          this.objects.put(new Integer(var3 = this.objectId(var1)), var1);
  1384.       } else if (var1 instanceof String) {
  1385.          var2.writeInt(18);
  1386.          this.objects.put(new Integer(var3 = this.objectId(var1)), var1);
  1387.       } else {
  1388.          if (var1 instanceof Thread) {
  1389.             var2.writeInt(19);
  1390.          } else if (var1 instanceof ThreadGroup) {
  1391.             var2.writeInt(15);
  1392.          } else {
  1393.             var2.writeInt(17);
  1394.          }
  1395.  
  1396.          Class var4 = var1.getClass();
  1397.          int var5;
  1398.          this.objects.put(new Integer(var5 = this.objectId(var4)), var4);
  1399.          var2.writeInt(var5);
  1400.          this.objects.put(new Integer(var3 = this.objectId(var1)), var1);
  1401.       }
  1402.  
  1403.       var2.writeInt(var3);
  1404.    }
  1405.  
  1406.    void writeObject(Object var1) throws IOException {
  1407.       this.writeObject(var1, this.out);
  1408.    }
  1409.  
  1410.    void writeArray(Object[] var1) throws IOException {
  1411.       int var2 = 0;
  1412.       this.out.writeInt(9);
  1413.       if (var1 == null) {
  1414.          this.out.writeInt(0);
  1415.       } else {
  1416.          Class var3 = var1.getClass();
  1417.          this.objects.put(new Integer(var2 = this.objectId(var3)), var3);
  1418.          this.out.writeInt(var2);
  1419.          this.objects.put(new Integer(var2 = this.objectId(var1)), var1);
  1420.          this.out.writeInt(var2);
  1421.          this.out.writeInt(var1.length);
  1422.       }
  1423.    }
  1424.  
  1425.    void write(boolean var1) throws IOException {
  1426.       this.out.writeInt(0);
  1427.       this.out.writeBoolean(var1);
  1428.    }
  1429.  
  1430.    void write(byte var1) throws IOException {
  1431.       this.out.writeInt(1);
  1432.       this.out.writeByte(var1);
  1433.    }
  1434.  
  1435.    void write(char var1) throws IOException {
  1436.       this.out.writeInt(2);
  1437.       this.out.writeChar(var1);
  1438.    }
  1439.  
  1440.    void write(short var1) throws IOException {
  1441.       this.out.writeInt(3);
  1442.       this.out.writeShort(var1);
  1443.    }
  1444.  
  1445.    void write(int var1) throws IOException {
  1446.       this.out.writeInt(4);
  1447.       this.out.writeInt(var1);
  1448.    }
  1449.  
  1450.    void write(long var1) throws IOException {
  1451.       this.out.writeInt(5);
  1452.       this.out.writeLong(var1);
  1453.    }
  1454.  
  1455.    void write(float var1) throws IOException {
  1456.       this.out.writeInt(6);
  1457.       this.out.writeFloat(var1);
  1458.    }
  1459.  
  1460.    void write(double var1) throws IOException {
  1461.       this.out.writeInt(7);
  1462.       this.out.writeDouble(var1);
  1463.    }
  1464.  
  1465.    void reportAppExit() throws IOException {
  1466.       message("report application exit");
  1467.       DataOutputStream var1 = this.asyncOutputStream;
  1468.       synchronized(var1){}
  1469.  
  1470.       try {
  1471.          this.asyncOutputStream.write(67);
  1472.          this.asyncOutputStream.flush();
  1473.       } catch (Throwable var3) {
  1474.          throw var3;
  1475.       }
  1476.  
  1477.    }
  1478.  
  1479.    static void error(String var0) {
  1480.       System.out.println("[Internal debug-agent error: " + var0 + "]");
  1481.    }
  1482.  
  1483.    static void message(String var0) {
  1484.       if (verbose) {
  1485.          System.out.println("[debug agent: " + var0 + "]");
  1486.       }
  1487.  
  1488.    }
  1489.  
  1490.    public static void boot(int var0) {
  1491.       Agent var1 = new Agent(var0);
  1492.       Thread var2 = new Thread(var1);
  1493.       var2.setDaemon(true);
  1494.       var2.setName("Debugger agent");
  1495.       var2.setPriority(10);
  1496.       var2.start();
  1497.    }
  1498.  
  1499.    public static void debuggable_boot() {
  1500.       Agent var0 = new Agent();
  1501.       Thread var1 = new Thread(var0);
  1502.       var1.setDaemon(true);
  1503.       var1.setName("Debugger agent");
  1504.       var1.setPriority(10);
  1505.       var1.start();
  1506.    }
  1507.  
  1508.    static {
  1509.       System.loadLibrary("agent");
  1510.    }
  1511. }
  1512.