sa-jdi

00(this$1).getText());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.29.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JTextField;
import sun.jvm.hotspot.utilities.WorkerThread;

final class HSDB$29
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$29(HSDB paramHSDB, JInternalFrame paramJInternalFrame, JTextField paramJTextField1, JTextField paramJTextField2) {}
  
  public void actionPerformed(ActionEvent e)
  {
    val$dialog.setVisible(false);
    HSDB.access$1600(this$0).remove(val$dialog);
    HSDB.access$2000(this$0).invokeLater(new Runnable()
    {
      public void run()
      {
        HSDB.access$2600(this$0, val$execPathField.getText(), val$corePathField.getText());
      }
    });
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.29
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$3
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$3(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    HSDB.access$200(this$0);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.3
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;

final class HSDB$30
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$30(HSDB paramHSDB, JInternalFrame paramJInternalFrame) {}
  
  public void actionPerformed(ActionEvent e)
  {
    val$dialog.setVisible(false);
    HSDB.access$1600(this$0).remove(val$dialog);
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.30
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JTextField;

final class HSDB$31$1
  implements Runnable
{
  private final HSDB.31 this$1;
  
  HSDB$31$1(HSDB.31 param31) {}
  
  public void run()
  {
    HSDB.access$2900(HSDB.31.access$2800(this$1), HSDB.31.access$2700(this$1).getText());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.31.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JTextField;
import sun.jvm.hotspot.utilities.WorkerThread;

final class HSDB$31
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$31(HSDB paramHSDB, JInternalFrame paramJInternalFrame, JTextField paramJTextField) {}
  
  public void actionPerformed(ActionEvent e)
  {
    val$dialog.setVisible(false);
    HSDB.access$1600(this$0).remove(val$dialog);
    HSDB.access$2000(this$0).invokeLater(new Runnable()
    {
      public void run()
      {
        HSDB.access$2900(this$0, val$pidTextField.getText());
      }
    });
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.31
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;

final class HSDB$32
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$32(HSDB paramHSDB, JInternalFrame paramJInternalFrame) {}
  
  public void actionPerformed(ActionEvent e)
  {
    val$dialog.setVisible(false);
    HSDB.access$1600(this$0).remove(val$dialog);
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.32
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JOptionPane;

final class HSDB$33$1
  implements Runnable
{
  private final HSDB.33 this$1;
  
  HSDB$33$1(HSDB.33 param33, String paramString) {}
  
  public void run()
  {
    JOptionPane.showInternalMessageDialog(HSDB.access$1600(HSDB.33.access$3200(this$1)), "Error computing reverse pointers:" + val$errMsg, "Error", 2);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.33.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
import sun.jvm.hotspot.utilities.ReversePtrsAnalysis;

final class HSDB$33
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$33(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.HeapProgress progress = new HSDB.HeapProgress(this$0, "Reverse Pointers Analysis");
    try
    {
      ReversePtrsAnalysis analysis = new ReversePtrsAnalysis();
      analysis.setHeapProgressThunk(progress);
      analysis.run();
      HSDB.access$3000(this$0).setEnabled(false);
    }
    catch (OutOfMemoryError e)
    {
      final String errMsg = HSDB.access$3100(this$0, e.toString(), 80);
      SwingUtilities.invokeLater(new Runnable()
      {
        public void run()
        {
          JOptionPane.showInternalMessageDialog(HSDB.access$1600(this$0), "Error computing reverse pointers:" + errMsg, "Error", 2);
        }
      });
    }
    finally
    {
      progress.heapIterationComplete();
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.33
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.debugger.AddressException;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSOldGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSPermGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSYoungGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.ParallelScavengeHeap;
import sun.jvm.hotspot.gc_interface.CollectedHeap;
import sun.jvm.hotspot.memory.GenCollectedHeap;
import sun.jvm.hotspot.memory.Generation;
import sun.jvm.hotspot.memory.Universe;
import sun.jvm.hotspot.oops.Instance;
import sun.jvm.hotspot.oops.Klass;
import sun.jvm.hotspot.oops.ObjectHeap;
import sun.jvm.hotspot.oops.Oop;
import sun.jvm.hotspot.oops.Symbol;
import sun.jvm.hotspot.runtime.AddressVisitor;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.ui.AnnotatedMemoryPanel;
import sun.jvm.hotspot.ui.Annotation;
import sun.jvm.hotspot.utilities.Assert;

final class HSDB$34$1
  implements AddressVisitor
{
  private final HSDB.34 this$1;
  
  HSDB$34$1(HSDB.34 param34) {}
  
  public void visitAddress(Address addr)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1L) == null, "Address " + addr + "should have been aligned");
    }
    OopHandle handle = addr.getOopHandleAt(0L);
    addAnnotation(addr, handle);
  }
  
  public void visitCompOopAddress(Address addr)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1L) == null, "Address " + addr + "should have been aligned");
    }
    OopHandle handle = addr.getCompOopHandleAt(0L);
    addAnnotation(addr, handle);
  }
  
  public void addAnnotation(Address addr, OopHandle handle)
  {
    String anno = "null oop";
    if (handle != null)
    {
      CollectedHeap collHeap = VM.getVM().getUniverse().heap();
      boolean bad = true;
      anno = "BAD OOP";
      if ((collHeap instanceof GenCollectedHeap))
      {
        GenCollectedHeap heap = (GenCollectedHeap)collHeap;
        for (int i = 0; i < heap.nGens(); i++) {
          if (heap.getGen(i).isIn(handle))
          {
            if (i == 0) {
              anno = "NewGen ";
            } else if (i == 1) {
              anno = "OldGen ";
            } else {
              anno = "Gen " + i + " ";
            }
            bad = false;
            break;
          }
        }
        if (bad) {
          if (heap.permGen().isIn(handle))
          {
            anno = "PermGen ";
            bad = false;
          }
        }
      }
      else if ((collHeap instanceof ParallelScavengeHeap))
      {
        ParallelScavengeHeap heap = (ParallelScavengeHeap)collHeap;
        if (heap.youngGen().isIn(handle))
        {
          anno = "PSYoungGen ";
          bad = false;
        }
        else if (heap.oldGen().isIn(handle))
        {
          anno = "PSOldGen ";
          bad = false;
        }
        else if (heap.permGen().isIn(handle))
        {
          anno = "PSPermGen ";
          bad = false;
        }
      }
      else
      {
        anno = "[Unknown generation] ";
        bad = false;
      }
      if (!bad) {
        try
        {
          Oop oop = VM.getVM().getObjectHeap().newOop(handle);
          if ((oop instanceof Instance))
          {
            anno = anno + oop.getKlass().getName().asString();
          }
          else
          {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            Oop.printOopValueOn(oop, new PrintStream(bos));
            anno = anno + bos.toString();
          }
        }
        catch (AddressException e)
        {
          anno = anno + "CORRUPT OOP";
        }
        catch (NullPointerException e)
        {
          anno = anno + "CORRUPT OOP (null pointer)";
        }
      }
    }
    this$1.annoPanel.addAnnotation(new Annotation(addr, addr.addOffsetTo(HSDB.34.access$3300(this$1)), anno));
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.34.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.Map;
import sun.jvm.hotspot.code.CodeBlob;
import sun.jvm.hotspot.code.CodeCache;
import sun.jvm.hotspot.compiler.OopMapSet;
import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.debugger.AddressException;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSOldGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSPermGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.PSYoungGen;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.ParallelScavengeHeap;
import sun.jvm.hotspot.gc_interface.CollectedHeap;
import sun.jvm.hotspot.interpreter.Interpreter;
import sun.jvm.hotspot.interpreter.InterpreterCodelet;
import sun.jvm.hotspot.memory.GenCollectedHeap;
import sun.jvm.hotspot.memory.Generation;
import sun.jvm.hotspot.memory.Universe;
import sun.jvm.hotspot.oops.Instance;
import sun.jvm.hotspot.oops.Klass;
import sun.jvm.hotspot.oops.Method;
import sun.jvm.hotspot.oops.ObjectHeap;
import sun.jvm.hotspot.oops.Oop;
import sun.jvm.hotspot.oops.Symbol;
import sun.jvm.hotspot.runtime.AddressVisitor;
import sun.jvm.hotspot.runtime.BasicObjectLock;
import sun.jvm.hotspot.runtime.Frame;
import sun.jvm.hotspot.runtime.JavaThread;
import sun.jvm.hotspot.runtime.JavaVFrame;
import sun.jvm.hotspot.runtime.RegisterMap;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.ui.AnnotatedMemoryPanel;
import sun.jvm.hotspot.ui.Annotation;
import sun.jvm.hotspot.utilities.Assert;

final class HSDB$34
  extends HSDB.StackWalker
{
  private final HSDB this$0;
  
  HSDB$34(HSDB paramHSDB, JavaVFrame x0, AnnotatedMemoryPanel x1, JavaThread paramJavaThread, long paramLong)
  {
    super(paramHSDB, x0, x1);
  }
  
  public void run()
  {
    Address startAddr = null;
    
    Map interruptedFrameMap = new HashMap();
    
    Frame tmpFrame = val$thread.getCurrentFrameGuess();
    RegisterMap tmpMap = val$thread.newRegisterMap(false);
    while ((tmpFrame != null) && (!tmpFrame.isFirstFrame()))
    {
      if (tmpFrame.isSignalHandlerFrameDbg())
      {
        Frame interruptedFrame = tmpFrame.sender(tmpMap);
        HSDB.SignalInfo info = new HSDB.SignalInfo(this$0);
        sigNum = tmpFrame.getSignalNumberDbg();
        sigName = tmpFrame.getSignalNameDbg();
        interruptedFrameMap.put(interruptedFrame, info);
      }
      tmpFrame = tmpFrame.sender(tmpMap);
    }
    while (vf != null)
    {
      String anno = null;
      JavaVFrame curVFrame = vf;
      Frame curFrame = curVFrame.getFrame();
      Method interpreterFrameMethod = null;
      if (curVFrame.isInterpretedFrame())
      {
        anno = "Interpreted frame";
      }
      else
      {
        anno = "Compiled frame";
        if (curVFrame.isDeoptimized()) {
          anno = anno + " (deoptimized)";
        }
      }
      if (curVFrame.mayBeImpreciseDbg()) {
        anno = anno + "; information may be imprecise";
      }
      if (curVFrame.isInterpretedFrame())
      {
        InterpreterCodelet codelet = VM.getVM().getInterpreter().getCodeletContaining(curFrame.getPC());
        String description = null;
        if (codelet != null) {
          description = codelet.getDescription();
        }
        if (description == null) {
          anno = anno + "\n(Unknown interpreter codelet)";
        } else {
          anno = anno + "\nExecuting in codelet \"" + description + "\" at PC = " + curFrame.getPC();
        }
      }
      else if (curVFrame.isCompiledFrame())
      {
        anno = anno + "\nExecuting at PC = " + curFrame.getPC();
      }
      if (startAddr == null) {
        startAddr = curFrame.getSP();
      }
      boolean shouldSkipOopMaps = false;
      if (curVFrame.isCompiledFrame())
      {
        CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC());
        OopMapSet maps = cb.getOopMaps();
        if ((maps == null) || (maps.getSize() == 0L)) {
          shouldSkipOopMaps = true;
        }
      }
      HSDB.SignalInfo sigInfo = (HSDB.SignalInfo)interruptedFrameMap.get(curFrame);
      if (sigInfo != null) {
        anno = anno + "\n*** INTERRUPTED BY SIGNAL " + Integer.toString(sigNum) + " (" + sigName + ")";
      }
      JavaVFrame nextVFrame = curVFrame;
      Frame nextFrame = curFrame;
      do
      {
        curVFrame = nextVFrame;
        curFrame = nextFrame;
        try
        {
          Method method = curVFrame.getMethod();
          if ((interpreterFrameMethod == null) && (curVFrame.isInterpretedFrame())) {
            interpreterFrameMethod = method;
          }
          int bci = curVFrame.getBCI();
          String lineNumberAnno = "";
          if (method.hasLineNumberTable()) {
            if ((bci == -1) || ((bci >= 0) && (bci < method.getCodeSize()))) {
              lineNumberAnno = ", line " + method.getLineNumberFromBCI(bci);
            } else {
              lineNumberAnno = " (INVALID BCI)";
            }
          }
          anno = anno + "\n" + method.getMethodHolder().getName().asString() + "." + method.getName().asString() + method.getSignature().asString() + "\n@bci " + bci + lineNumberAnno;
        }
        catch (Exception e)
        {
          anno = anno + "\n(ERROR while iterating vframes for frame " + curFrame + ")";
        }
        nextVFrame = curVFrame.javaSender();
        if (nextVFrame != null) {
          nextFrame = nextVFrame.getFrame();
        }
      } while ((nextVFrame != null) && (nextFrame.equals(curFrame)));
      if (shouldSkipOopMaps) {
        anno = anno + "\nNOTE: null or empty OopMapSet found for this CodeBlob";
      }
      if (curFrame.getFP() != null)
      {
        annoPanel.addAnnotation(new Annotation(curFrame.getSP(), curFrame.getFP(), anno));
      }
      else if ((VM.getVM().getCPU().equals("x86")) || (VM.getVM().getCPU().equals("amd64")))
      {
        CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC());
        Address sp = curFrame.getSP();
        if (Assert.ASSERTS_ENABLED) {
          Assert.that(cb.getFrameSize() > 0L, "CodeBlob must have non-zero frame size");
        }
        annoPanel.addAnnotation(new Annotation(sp, sp.addOffsetTo(cb.getFrameSize()), anno));
      }
      else
      {
        Assert.that(VM.getVM().getCPU().equals("ia64"), "only ia64 should reach here");
      }
      if (curFrame.isInterpretedFrame())
      {
        annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameExpressionStack(), curFrame.addressOfInterpreterFrameTOS(), "Interpreter expression stack"));
        
        Address monBegin = curFrame.interpreterFrameMonitorBegin().address();
        Address monEnd = curFrame.interpreterFrameMonitorEnd().address();
        if (!monBegin.equals(monEnd)) {
          annoPanel.addAnnotation(new Annotation(monBegin, monEnd, "BasicObjectLocks"));
        }
        if (interpreterFrameMethod != null)
        {
          int offset = 1;
          annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameLocal(offset), curFrame.addressOfInterpreterFrameLocal((int)interpreterFrameMethod.getMaxLocals() + offset), "Interpreter locals area for frame with SP = " + curFrame.getSP()));
        }
        String methodAnno = "Interpreter frame methodOop";
        if (interpreterFrameMethod == null) {
          methodAnno = methodAnno + " (BAD OOP)";
        }
        Address a = curFrame.addressOfInterpreterFrameMethod();
        annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(val$addressSize), methodAnno));
        a = curFrame.addressOfInterpreterFrameCPCache();
        annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(val$addressSize), "Interpreter constant pool cache"));
      }
      RegisterMap rm = (RegisterMap)vf.getRegisterMap().clone();
      if (!shouldSkipOopMaps) {
        try
        {
          curFrame.oopsDo(new AddressVisitor()
          {
            public void visitAddress(Address addr)
            {
              if (Assert.ASSERTS_ENABLED) {
                Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1L) == null, "Address " + addr + "should have been aligned");
              }
              OopHandle handle = addr.getOopHandleAt(0L);
              addAnnotation(addr, handle);
            }
            
            public void visitCompOopAddress(Address addr)
            {
              if (Assert.ASSERTS_ENABLED) {
                Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1L) == null, "Address " + addr + "should have been aligned");
              }
              OopHandle handle = addr.getCompOopHandleAt(0L);
              addAnnotation(addr, handle);
            }
            
            public void addAnnotation(Address addr, OopHandle handle)
            {
              String anno = "null oop";
              if (handle != null)
              {
                CollectedHeap collHeap = VM.getVM().getUniverse().heap();
                boolean bad = true;
                anno = "BAD OOP";
                if ((collHeap instanceof GenCollectedHeap))
                {
                  GenCollectedHeap heap = (GenCollectedHeap)collHeap;
                  for (int i = 0; i < heap.nGens(); i++) {
                    if (heap.getGen(i).isIn(handle))
                    {
                      if (i == 0) {
                        anno = "NewGen ";
                      } else if (i == 1) {
                        anno = "OldGen ";
                      } else {
                        anno = "Gen " + i + " ";
                      }
                      bad = false;
                      break;
                    }
                  }
                  if (bad) {
                    if (heap.permGen().isIn(handle))
                    {
                      anno = "PermGen ";
                      bad = false;
                    }
                  }
                }
                else if ((collHeap instanceof ParallelScavengeHeap))
                {
                  ParallelScavengeHeap heap = (ParallelScavengeHeap)collHeap;
                  if (heap.youngGen().isIn(handle))
                  {
                    anno = "PSYoungGen ";
                    bad = false;
                  }
                  else if (heap.oldGen().isIn(handle))
                  {
                    anno = "PSOldGen ";
                    bad = false;
                  }
                  else if (heap.permGen().isIn(handle))
                  {
                    anno = "PSPermGen ";
                    bad = false;
                  }
                }
                else
                {
                  anno = "[Unknown generation] ";
                  bad = false;
                }
                if (!bad) {
                  try
                  {
                    Oop oop = VM.getVM().getObjectHeap().newOop(handle);
                    if ((oop instanceof Instance))
                    {
                      anno = anno + oop.getKlass().getName().asString();
                    }
                    else
                    {
                      ByteArrayOutputStream bos = new ByteArrayOutputStream();
                      Oop.printOopValueOn(oop, new PrintStream(bos));
                      anno = anno + bos.toString();
                    }
                  }
                  catch (AddressException e)
                  {
                    anno = anno + "CORRUPT OOP";
                  }
                  catch (NullPointerException e)
                  {
                    anno = anno + "CORRUPT OOP (null pointer)";
                  }
                }
              }
              annoPanel.addAnnotation(new Annotation(addr, addr.addOffsetTo(val$addressSize), anno));
            }
          }, rm);
        }
        catch (Exception e)
        {
          System.err.println("Error while performing oopsDo for frame " + curFrame);
          e.printStackTrace();
        }
      }
      vf = nextVFrame;
    }
    annoPanel.makeVisible(startAddr);
    annoPanel.repaint();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.34
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JOptionPane;

final class HSDB$35
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$35(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
    JOptionPane.showInternalMessageDialog(HSDB.access$1600(this$0), "Unable to parse process ID \"" + HSDB.access$3400(this$0) + "\".\nPlease enter a number.", "Parse error", 2);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.35
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;

final class HSDB$36
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$36(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.access$3500(this$0).setVisible(false);
    HSDB.access$1600(this$0).remove(HSDB.access$3500(this$0));
    HSDB.access$3502(this$0, null);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.36
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;

final class HSDB$37
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$37(HSDB paramHSDB) {}
  
  public void run()
  {
    JOptionPane pane = new JOptionPane("Attaching to process " + HSDB.access$3600(this$0) + ", please wait...", 1);
    pane.setOptions(new Object[0]);
    HSDB.access$3502(this$0, pane.createInternalFrame(HSDB.access$1600(this$0), "Attaching to Process"));
    HSDB.access$3500(this$0).show();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.37
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JOptionPane;

final class HSDB$38
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$38(HSDB paramHSDB, String paramString) {}
  
  public void run()
  {
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
    JOptionPane.showInternalMessageDialog(HSDB.access$1600(this$0), "Unable to connect to process ID " + HSDB.access$3600(this$0) + ":\n\n" + val$errMsg, "Unable to Connect", 2);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.38
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;

final class HSDB$39
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$39(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.access$3500(this$0).setVisible(false);
    HSDB.access$1600(this$0).remove(HSDB.access$3500(this$0));
    HSDB.access$3502(this$0, null);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.39
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$4
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$4(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    HSDB.access$300(this$0);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.4
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;

final class HSDB$40
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$40(HSDB paramHSDB) {}
  
  public void run()
  {
    JOptionPane pane = new JOptionPane("Opening core file, please wait...", 1);
    pane.setOptions(new Object[0]);
    HSDB.access$3502(this$0, pane.createInternalFrame(HSDB.access$1600(this$0), "Opening Core File"));
    HSDB.access$3500(this$0).show();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.40
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JOptionPane;

final class HSDB$41
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$41(HSDB paramHSDB, String paramString1, String paramString2) {}
  
  public void run()
  {
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
    JOptionPane.showInternalMessageDialog(HSDB.access$1600(this$0), "Unable to open core file\n" + val$corePath + ":\n\n" + val$errMsg, "Unable to Open Core File", 2);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.41
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;

final class HSDB$42
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$42(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.access$3500(this$0).setVisible(false);
    HSDB.access$1600(this$0).remove(HSDB.access$3500(this$0));
    HSDB.access$3502(this$0, null);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.42
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;

final class HSDB$43
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$43(HSDB paramHSDB) {}
  
  public void run()
  {
    JOptionPane pane = new JOptionPane("Connecting to debug server, please wait...", 1);
    pane.setOptions(new Object[0]);
    HSDB.access$3502(this$0, pane.createInternalFrame(HSDB.access$1600(this$0), "Connecting to Debug Server"));
    HSDB.access$3500(this$0).show();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.43
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import javax.swing.JOptionPane;

final class HSDB$44
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$44(HSDB paramHSDB, String paramString1, String paramString2) {}
  
  public void run()
  {
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), true);
    JOptionPane.showInternalMessageDialog(HSDB.access$1600(this$0), "Unable to connect to machine \"" + val$remoteMachineName + "\":\n\n" + val$errMsg, "Unable to Connect", 2);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.44
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.util.Observable;
import java.util.Observer;
import javax.swing.JMenuItem;

final class HSDB$45$1
  implements Observer
{
  private final HSDB.45 this$1;
  
  HSDB$45$1(HSDB.45 param45) {}
  
  public void update(Observable o, Object data)
  {
    HSDB.access$3000(HSDB.45.access$4000(this$1)).setEnabled(true);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.45.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.Container;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.ui.GraphicsUtilities;
import sun.jvm.hotspot.ui.JavaThreadsPanel;

final class HSDB$45
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$45(HSDB paramHSDB) {}
  
  public void run()
  {
    HSDB.access$3702(this$0, new JInternalFrame("Java Threads"));
    HSDB.access$3700(this$0).setResizable(true);
    HSDB.access$3700(this$0).setIconifiable(true);
    JavaThreadsPanel threadsPanel = new JavaThreadsPanel();
    threadsPanel.addPanelListener(this$0);
    HSDB.access$3700(this$0).getContentPane().add(threadsPanel);
    HSDB.access$3700(this$0).setSize(500, 300);
    HSDB.access$3700(this$0).pack();
    HSDB.access$1600(this$0).add(HSDB.access$3700(this$0));
    GraphicsUtilities.moveToInContainer(HSDB.access$3700(this$0), 0.75F, 0.25F, 0, 20);
    HSDB.access$3700(this$0).show();
    HSDB.access$2200(this$0, HSDB.access$2100(this$0), false);
    HSDB.access$2200(this$0, HSDB.access$3800(this$0), true);
    HSDB.access$3900(this$0).setEnabled(true);
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        HSDB.access$3000(this$0).setEnabled(true);
      }
    });
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.45
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

final class HSDB$46
  extends CommandProcessor.DebuggerInterface
{
  private final HSDB this$0;
  
  HSDB$46(HSDB paramHSDB) {}
  
  public HotSpotAgent getAgent()
  {
    return HSDB.access$4300(this$0);
  }
  
  public boolean isAttached()
  {
    return HSDB.access$4400(this$0);
  }
  
  public void attach(String pid)
  {
    attach(pid);
  }
  
  public void attach(String java, String core) {}
  
  public void detach()
  {
    HSDB.access$1500(this$0);
  }
  
  public void reattach()
  {
    if (HSDB.access$4400(this$0)) {
      HSDB.access$1500(this$0);
    }
    if (HSDB.access$3400(this$0) != null) {
      attach(HSDB.access$3400(this$0));
    } else {
      attach(HSDB.access$4500(this$0), HSDB.access$4600(this$0));
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.46
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import sun.jvm.hotspot.ui.GraphicsUtilities;
import sun.jvm.hotspot.ui.classbrowser.ClassBrowserPanel;

final class HSDB$47$1
  implements Runnable
{
  private final HSDB.47 this$1;
  
  HSDB$47$1(HSDB.47 param47, String paramString) {}
  
  public void run()
  {
    JInternalFrame cbFrame = new JInternalFrame("Class Browser");
    cbFrame.getContentPane().setLayout(new BorderLayout());
    cbFrame.setResizable(true);
    cbFrame.setClosable(true);
    cbFrame.setIconifiable(true);
    ClassBrowserPanel cbPanel = new ClassBrowserPanel();
    cbFrame.getContentPane().add(cbPanel, "Center");
    HSDB.access$1600(HSDB.47.access$4800(this$1)).remove(HSDB.47.access$4700(this$1));
    HSDB.access$1600(HSDB.47.access$4800(this$1)).repaint();
    HSDB.access$1600(HSDB.47.access$4800(this$1)).add(cbFrame);
    GraphicsUtilities.reshapeToAspectRatio(cbFrame, 1.25F, 0.85F, cbFrame.getParent().getSize());
    
    cbFrame.show();
    cbPanel.setClassesText(val$htmlText);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.47.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.SwingUtilities;
import sun.jvm.hotspot.oops.InstanceKlass;
import sun.jvm.hotspot.ui.GraphicsUtilities;
import sun.jvm.hotspot.ui.classbrowser.ClassBrowserPanel;
import sun.jvm.hotspot.ui.classbrowser.HTMLGenerator;
import sun.jvm.hotspot.utilities.SystemDictionaryHelper;

final class HSDB$47
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$47(HSDB paramHSDB, JInternalFrame paramJInternalFrame) {}
  
  public void run()
  {
    HTMLGenerator htmlGen = new HTMLGenerator();
    InstanceKlass[] klasses = SystemDictionaryHelper.getAllInstanceKlasses();
    final String htmlText = htmlGen.genHTMLForKlassNames(klasses);
    SwingUtilities.invokeLater(new Runnable()
    {
      public void run()
      {
        JInternalFrame cbFrame = new JInternalFrame("Class Browser");
        cbFrame.getContentPane().setLayout(new BorderLayout());
        cbFrame.setResizable(true);
        cbFrame.setClosable(true);
        cbFrame.setIconifiable(true);
        ClassBrowserPanel cbPanel = new ClassBrowserPanel();
        cbFrame.getContentPane().add(cbPanel, "Center");
        HSDB.access$1600(this$0).remove(val$progressFrame);
        HSDB.access$1600(this$0).repaint();
        HSDB.access$1600(this$0).add(cbFrame);
        GraphicsUtilities.reshapeToAspectRatio(cbFrame, 1.25F, 0.85F, cbFrame.getParent().getSize());
        
        cbFrame.show();
        cbPanel.setClassesText(htmlText);
      }
    });
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.47
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.ui.classbrowser.CodeViewerPanel;

final class HSDB$48
  implements Runnable
{
  private final HSDB this$0;
  
  HSDB$48(HSDB paramHSDB, CodeViewerPanel paramCodeViewerPanel, Address paramAddress) {}
  
  public void run()
  {
    val$panel.viewAddress(val$address);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.48
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$5
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$5(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    System.exit(0);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.5
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$6
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$6(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    this$0.showClassBrowser();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.6
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$7
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$7(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    this$0.showCodeViewer();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.7
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$8
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$8(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    HSDB.access$400(this$0);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.8
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

final class HSDB$9
  implements ActionListener
{
  private final HSDB this$0;
  
  HSDB$9(HSDB paramHSDB) {}
  
  public void actionPerformed(ActionEvent e)
  {
    HSDB.access$500(this$0);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.9
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

abstract interface HSDB$CleanupThunk
{
  public abstract void heapIterationComplete();
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.CleanupThunk
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import sun.jvm.hotspot.ui.GraphicsUtilities;
import sun.jvm.hotspot.ui.ObjectListPanel;
import sun.jvm.hotspot.utilities.FindObjectByType;

final class HSDB$FindObjectByTypeCleanupThunk$1
  implements Runnable
{
  private final HSDB.FindObjectByTypeCleanupThunk this$1;
  
  HSDB$FindObjectByTypeCleanupThunk$1(HSDB.FindObjectByTypeCleanupThunk paramFindObjectByTypeCleanupThunk) {}
  
  public void run()
  {
    JInternalFrame finderFrame = new JInternalFrame("Show Objects of Type");
    finderFrame.getContentPane().setLayout(new BorderLayout());
    finderFrame.setResizable(true);
    finderFrame.setClosable(true);
    finderFrame.setIconifiable(true);
    ObjectListPanel panel = new ObjectListPanel(this$1.finder.getResults(), new HSDB.HeapProgress(HSDB.FindObjectByTypeCleanupThunk.access$4200(this$1), "Reverse Pointers Analysis"));
    
    panel.addPanelListener(HSDB.FindObjectByTypeCleanupThunk.access$4200(this$1));
    finderFrame.getContentPane().add(panel);
    HSDB.access$1600(HSDB.FindObjectByTypeCleanupThunk.access$4200(this$1)).add(finderFrame);
    GraphicsUtilities.reshapeToAspectRatio(finderFrame, 1.3333334F, 0.6F, finderFrame.getParent().getSize());
    
    GraphicsUtilities.centerInContainer(finderFrame);
    finderFrame.show();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.HSDB.FindObjectByTypeCleanupThunk.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.SwingUtilities;
import sun.jvm.hotspot.ui.GraphicsUtilities;
import sun.jvm.hotspot.ui.ObjectListPanel;
import sun.jvm.hotspot.utilities.FindObjectByType;

class HSDB$FindObjectByTypeCleanupThunk
  implements HSDB.CleanupThunk
{
  FindObjectByType finder;
  private final HSDB this$0;
  
  HSDB$FindObjectByTypeCleanupThunk(HSDB paramHSDB, FindObjectByType finder)
  {
    this.finder = finder;
  }
  
  public void heapIterationComplete()
  {
    SwingUtilities.invokeLater(new Runnable()
    {
      public void run()
      {
        JInternalFrame finderFrame = new JInternalFrame("Show Objects of Type");
        finderFrame.getContentPane().setLayout(new BorderLayout());
        finderFrame.setResizable(true);
        finderFrame.setClosable(true);
        finderFrame.setIconifiable(true);
        ObjectListPanel panel = new ObjectListPanel(finder.getResults(), new HSDB.HeapProgress(this$0, "Reverse Pointers Analysis"));
        
        panel.addPanelListener(this
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd