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 / BreakpointHandler.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  6.2 KB  |  300 lines
  1. package sun.tools.debug;
  2.  
  3. import java.io.DataOutputStream;
  4. import java.io.IOException;
  5. import java.util.Enumeration;
  6. import java.util.Hashtable;
  7. import java.util.NoSuchElementException;
  8. import java.util.Vector;
  9.  
  10. class BreakpointHandler extends Thread implements AgentConstants {
  11.    static BreakpointQueue the_bkptQ;
  12.    static Hashtable the_bkptHash;
  13.    private Agent agent;
  14.    private Hashtable catchHash;
  15.    private Vector skipLines;
  16.    static final boolean debug = false;
  17.  
  18.    native int setBreakpoint(int var1) throws InvalidPCException;
  19.  
  20.    native void clrBreakpoint(int var1, int var2) throws InvalidPCException;
  21.  
  22.    public static synchronized int getOpcode(int var0) {
  23.       BreakpointSet var1 = (BreakpointSet)the_bkptHash.get(new Integer(var0));
  24.       return var1 == null ? -1 : var1.opcode;
  25.    }
  26.  
  27.    private synchronized int internalAddBreakpoint(Class var1, int var2) throws IOException {
  28.       BreakpointSet var3 = (BreakpointSet)the_bkptHash.get(new Integer(var2));
  29.       if (var3 == null) {
  30.          if (var1 == null) {
  31.             throw new IOException("Invalid classObj in addBreakpoint");
  32.          } else {
  33.             try {
  34.                int var4 = this.setBreakpoint(var2) & 255;
  35.                return var4;
  36.             } catch (InvalidPCException var5) {
  37.                throw new IOException("invalid PC");
  38.             }
  39.          }
  40.       } else {
  41.          return -1;
  42.       }
  43.    }
  44.  
  45.    synchronized void addBreakpoint(Class var1, int var2, int var3, byte[] var4) throws IOException {
  46.       int var5 = this.internalAddBreakpoint(var1, var2);
  47.       if (var5 != -1) {
  48.          BreakpointSet var6 = new BreakpointSet(var2, var5, var1, var3, var4);
  49.          the_bkptHash.put(new Integer(var2), var6);
  50.          if (var4 != null && var4.length > 0) {
  51.             var6.addCondition(var4);
  52.          }
  53.       }
  54.  
  55.    }
  56.  
  57.    synchronized void addScattershotBreakpoints(Class var1, int[] var2, Thread var3) throws IOException {
  58.       for(int var4 = 0; var4 < var2.length; ++var4) {
  59.          int var5 = var2[var4];
  60.          int var6 = this.internalAddBreakpoint(var1, var5);
  61.          if (var6 != -1) {
  62.             BreakpointSet var7 = new BreakpointSet(var5, var6, var1, 4, (byte[])null);
  63.             var7.setCohorts(var2);
  64.             var7.setThread(var3);
  65.             the_bkptHash.put(new Integer(var5), var7);
  66.          }
  67.       }
  68.  
  69.    }
  70.  
  71.    synchronized void deleteBreakpoint(Class var1, int var2) throws IOException {
  72.       BreakpointSet var3 = (BreakpointSet)the_bkptHash.get(new Integer(var2));
  73.       if (var3 != null) {
  74.          try {
  75.             this.clrBreakpoint(var2, var3.opcode);
  76.          } catch (InvalidPCException var4) {
  77.             throw new IOException("invalid PC");
  78.          }
  79.  
  80.          the_bkptHash.remove(new Integer(var2));
  81.       }
  82.    }
  83.  
  84.    synchronized BreakpointSet[] listBreakpoints() {
  85.       BreakpointSet[] var1 = new BreakpointSet[the_bkptHash.size()];
  86.       Enumeration var2 = the_bkptHash.elements();
  87.  
  88.       for(int var3 = 0; var3 < var1.length; ++var3) {
  89.          try {
  90.             var1[var3] = (BreakpointSet)var2.nextElement();
  91.          } catch (NoSuchElementException var5) {
  92.             Agent.error("Internal error" + this.agent.exceptionStackTrace(var5));
  93.             return null;
  94.          }
  95.       }
  96.  
  97.       return var1;
  98.    }
  99.  
  100.    synchronized void catchExceptionClass(Class var1) {
  101.       if (this.catchHash.get(var1) == null) {
  102.          this.catchHash.put(var1, var1);
  103.       }
  104.  
  105.    }
  106.  
  107.    synchronized void ignoreExceptionClass(Class var1) {
  108.       this.catchHash.remove(var1);
  109.    }
  110.  
  111.    Class[] getCatchList() {
  112.       Class[] var1 = new Class[this.catchHash.size()];
  113.       Enumeration var2 = this.catchHash.elements();
  114.  
  115.       for(int var3 = 0; var3 < var1.length; ++var3) {
  116.          var1[var3] = (Class)var2.nextElement();
  117.       }
  118.  
  119.       return var1;
  120.    }
  121.  
  122.    void addSkipLine(LineNumber var1) {
  123.       this.skipLines.addElement(var1);
  124.    }
  125.  
  126.    void removeSkipLine(LineNumber var1) {
  127.       this.skipLines.removeElement(var1);
  128.    }
  129.  
  130.    boolean ignoreSingleStep(Thread var1, int var2) {
  131.       Enumeration var3 = this.skipLines.elements();
  132.  
  133.       while(var3.hasMoreElements()) {
  134.          LineNumber var4 = (LineNumber)var3.nextElement();
  135.          if (var4.thread == var1) {
  136.             if (var2 >= var4.startPC && var2 <= var4.endPC) {
  137.                return true;
  138.             }
  139.  
  140.             this.removeSkipLine(var4);
  141.          }
  142.       }
  143.  
  144.       return false;
  145.    }
  146.  
  147.    BreakpointHandler(Agent var1) {
  148.       super("Breakpoint handler");
  149.       the_bkptQ = new BreakpointQueue();
  150.       the_bkptHash = new Hashtable();
  151.       this.catchHash = new Hashtable();
  152.       this.skipLines = new Vector();
  153.       this.agent = var1;
  154.    }
  155.  
  156.    public void run() {
  157.       Class var1 = this.getClass();
  158.  
  159.       try {
  160.          while(true) {
  161.             the_bkptQ.updated = true;
  162.             synchronized(var1){}
  163.  
  164.             try {
  165.                var1.notifyAll();
  166.             } catch (Throwable var72) {
  167.                throw var72;
  168.             }
  169.  
  170.             if (!the_bkptQ.nextEvent()) {
  171.                return;
  172.             }
  173.  
  174.             if (this.agent.asyncOutputStream != null && !Agent.systemThread(the_bkptQ.thread)) {
  175.                if (the_bkptQ.exception != null) {
  176.                   this.agent.setSingleStep(the_bkptQ.thread, false);
  177.                   if (the_bkptQ.exception instanceof ThreadDeath) {
  178.                      DataOutputStream var81 = this.agent.asyncOutputStream;
  179.                      synchronized(var81){}
  180.  
  181.                      try {
  182.                         this.agent.asyncOutputStream.write(66);
  183.                         this.agent.writeObject(the_bkptQ.thread, this.agent.asyncOutputStream);
  184.                         this.agent.asyncOutputStream.flush();
  185.                      } catch (Throwable var71) {
  186.                         throw var71;
  187.                      }
  188.                   } else {
  189.                      Class var80 = the_bkptQ.exception.getClass();
  190.                      if (this.catchHash.containsKey(var80) || the_bkptQ.catch_pc == 0) {
  191.                         this.agent.suspendAllThreads();
  192.                         String var84 = the_bkptQ.catch_pc == 0 ? "Uncaught exception: " : "Exception: ";
  193.                         String var86 = this.agent.exceptionStackTrace(the_bkptQ.exception);
  194.                         var84 = var84.concat(var86);
  195.                         DataOutputStream var6 = this.agent.asyncOutputStream;
  196.                         synchronized(var6){}
  197.  
  198.                         try {
  199.                            this.agent.asyncOutputStream.write(52);
  200.                            this.agent.writeObject(the_bkptQ.thread, this.agent.asyncOutputStream);
  201.                            this.agent.asyncOutputStream.writeUTF(var84);
  202.                            this.agent.asyncOutputStream.flush();
  203.                         } catch (Throwable var74) {
  204.                            throw var74;
  205.                         }
  206.                      }
  207.                   }
  208.                } else if (the_bkptQ.opcode != -1) {
  209.                   this.addBreakpoint((Class)null, the_bkptQ.pc, 1, (byte[])null);
  210.                } else {
  211.                   BreakpointSet var2 = (BreakpointSet)the_bkptHash.get(new Integer(the_bkptQ.pc));
  212.                   if (var2 == null) {
  213.                      if (this.ignoreSingleStep(the_bkptQ.thread, the_bkptQ.pc)) {
  214.                         continue;
  215.                      }
  216.  
  217.                      this.agent.setSingleStep(the_bkptQ.thread, false);
  218.                      the_bkptQ.opcode = -1;
  219.                   } else {
  220.                      if (var2.thread != null && var2.thread != the_bkptQ.thread) {
  221.                         continue;
  222.                      }
  223.  
  224.                      the_bkptQ.opcode = var2.opcode;
  225.                   }
  226.  
  227.                   this.agent.suspendAllThreads();
  228.                   if (var2 != null) {
  229.                      if (var2.type == 2) {
  230.                         this.deleteBreakpoint(var2.clazz, var2.pc);
  231.                      } else if (var2.type == 4) {
  232.                         int[] var78 = var2.cohorts;
  233.  
  234.                         for(int var83 = 0; var83 < var78.length; ++var83) {
  235.                            BreakpointSet var5 = (BreakpointSet)the_bkptHash.get(new Integer(var78[var83]));
  236.                            this.deleteBreakpoint(var5.clazz, var5.pc);
  237.                         }
  238.                      }
  239.                   }
  240.  
  241.                   DataOutputStream var79 = this.agent.asyncOutputStream;
  242.                   synchronized(var79){}
  243.  
  244.                   try {
  245.                      this.agent.asyncOutputStream.write(46);
  246.                      this.agent.writeObject(the_bkptQ.thread, this.agent.asyncOutputStream);
  247.                      this.agent.asyncOutputStream.flush();
  248.                   } catch (Throwable var73) {
  249.                      throw var73;
  250.                   }
  251.                }
  252.             }
  253.          }
  254.       } catch (ThreadDeath var75) {
  255.          BreakpointSet var82;
  256.          for(Enumeration var77 = the_bkptHash.elements(); var77.hasMoreElements(); the_bkptHash.remove(new Integer(var82.pc))) {
  257.             var82 = (BreakpointSet)var77.nextElement();
  258.  
  259.             try {
  260.                this.clrBreakpoint(var82.pc, var82.opcode);
  261.             } catch (Exception var70) {
  262.             }
  263.          }
  264.  
  265.          the_bkptQ.updated = true;
  266.          synchronized(var1){}
  267.  
  268.          try {
  269.             var1.notifyAll();
  270.          } catch (Throwable var69) {
  271.             throw var69;
  272.          }
  273.  
  274.          throw var75;
  275.       } catch (Exception var76) {
  276.          Agent.error(this.agent.exceptionStackTrace(var76));
  277.  
  278.          BreakpointSet var4;
  279.          for(Enumeration var3 = the_bkptHash.elements(); var3.hasMoreElements(); the_bkptHash.remove(new Integer(var4.pc))) {
  280.             var4 = (BreakpointSet)var3.nextElement();
  281.  
  282.             try {
  283.                this.clrBreakpoint(var4.pc, var4.opcode);
  284.             } catch (Exception var68) {
  285.             }
  286.          }
  287.  
  288.          the_bkptQ.updated = true;
  289.          synchronized(var1){}
  290.  
  291.          try {
  292.             var1.notifyAll();
  293.          } catch (Throwable var67) {
  294.             throw var67;
  295.          }
  296.  
  297.       }
  298.    }
  299. }
  300.