rev 10195 : 8048267: Replace uses of 'new Long()' with appropriate alternative across core classes
Reviewed-by: chegar, psandoz
Contributed-by: otaviojava@java.net

   1 /*
   2  * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.jdi;
  27 
  28 import com.sun.jdi.*;
  29 import com.sun.jdi.connect.spi.Connection;
  30 import com.sun.jdi.request.EventRequestManager;
  31 import com.sun.jdi.request.EventRequest;
  32 import com.sun.jdi.request.BreakpointRequest;
  33 import com.sun.jdi.event.EventQueue;
  34 
  35 import java.util.*;
  36 import java.text.MessageFormat;
  37 import java.lang.ref.ReferenceQueue;
  38 import java.lang.ref.Reference;
  39 import java.lang.ref.SoftReference;
  40 import java.lang.ref.WeakReference;
  41 
  42 class VirtualMachineImpl extends MirrorImpl
  43              implements PathSearchingVirtualMachine, ThreadListener {
  44     // VM Level exported variables, these
  45     // are unique to a given vm
  46     public final int sizeofFieldRef;
  47     public final int sizeofMethodRef;
  48     public final int sizeofObjectRef;
  49     public final int sizeofClassRef;
  50     public final int sizeofFrameRef;
  51 
  52     final int sequenceNumber;
  53 
  54     private final TargetVM target;
  55     private final EventQueueImpl eventQueue;
  56     private final EventRequestManagerImpl internalEventRequestManager;
  57     private final EventRequestManagerImpl eventRequestManager;
  58     final VirtualMachineManagerImpl vmManager;
  59     private final ThreadGroup threadGroupForJDI;
  60 
  61     // Allow direct access to this field so that that tracing code slows down
  62     // JDI as little as possible when not enabled.
  63     int traceFlags = TRACE_NONE;
  64 
  65     static int TRACE_RAW_SENDS     = 0x01000000;
  66     static int TRACE_RAW_RECEIVES  = 0x02000000;
  67 
  68     boolean traceReceives = false;   // pre-compute because of frequency
  69 
  70     // ReferenceType access - updated with class prepare and unload events
  71     // Protected by "synchronized(this)". "retrievedAllTypes" may be
  72     // tested unsynchronized (since once true, it stays true), but must
  73     // be set synchronously
  74     private Map<Long, ReferenceType> typesByID;
  75     private TreeSet<ReferenceType> typesBySignature;
  76     private boolean retrievedAllTypes = false;
  77 
  78     // For other languages support
  79     private String defaultStratum = null;
  80 
  81     // ObjectReference cache
  82     // "objectsByID" protected by "synchronized(this)".
  83     private final Map<Long, SoftObjectReference> objectsByID = new HashMap<Long, SoftObjectReference>();
  84     private final ReferenceQueue<ObjectReferenceImpl> referenceQueue = new ReferenceQueue<ObjectReferenceImpl>();
  85     static private final int DISPOSE_THRESHOLD = 50;
  86     private final List<SoftObjectReference> batchedDisposeRequests =
  87             Collections.synchronizedList(new ArrayList<SoftObjectReference>(DISPOSE_THRESHOLD + 10));
  88 
  89     // These are cached once for the life of the VM
  90     private JDWP.VirtualMachine.Version versionInfo;
  91     private JDWP.VirtualMachine.ClassPaths pathInfo;
  92     private JDWP.VirtualMachine.Capabilities capabilities = null;
  93     private JDWP.VirtualMachine.CapabilitiesNew capabilitiesNew = null;
  94 
  95     // Per-vm singletons for primitive types and for void.
  96     // singleton-ness protected by "synchronized(this)".
  97     private BooleanType theBooleanType;
  98     private ByteType    theByteType;
  99     private CharType    theCharType;
 100     private ShortType   theShortType;
 101     private IntegerType theIntegerType;
 102     private LongType    theLongType;
 103     private FloatType   theFloatType;
 104     private DoubleType  theDoubleType;
 105 
 106     private VoidType    theVoidType;
 107 
 108     private VoidValue voidVal;
 109 
 110     // Launched debuggee process
 111     private Process process;
 112 
 113     // coordinates state changes and corresponding listener notifications
 114     private VMState state = new VMState(this);
 115 
 116     private Object initMonitor = new Object();
 117     private boolean initComplete = false;
 118     private boolean shutdown = false;
 119 
 120     private void notifyInitCompletion() {
 121         synchronized(initMonitor) {
 122             initComplete = true;
 123             initMonitor.notifyAll();
 124         }
 125     }
 126 
 127     void waitInitCompletion() {
 128         synchronized(initMonitor) {
 129             while (!initComplete) {
 130                 try {
 131                     initMonitor.wait();
 132                 } catch (InterruptedException e) {
 133                     // ignore
 134                 }
 135             }
 136         }
 137     }
 138 
 139     VMState state() {
 140         return state;
 141     }
 142 
 143     /*
 144      * ThreadListener implementation
 145      */
 146     public boolean threadResumable(ThreadAction action) {
 147         /*
 148          * If any thread is resumed, the VM is considered not suspended.
 149          * Just one thread is being resumed so pass it to thaw.
 150          */
 151         state.thaw(action.thread());
 152         return true;
 153     }
 154 
 155     VirtualMachineImpl(VirtualMachineManager manager,
 156                        Connection connection, Process process,
 157                        int sequenceNumber) {
 158         super(null);  // Can't use super(this)
 159         vm = this;
 160 
 161         this.vmManager = (VirtualMachineManagerImpl)manager;
 162         this.process = process;
 163         this.sequenceNumber = sequenceNumber;
 164 
 165         /* Create ThreadGroup to be used by all threads servicing
 166          * this VM.
 167          */
 168         threadGroupForJDI = new ThreadGroup(vmManager.mainGroupForJDI(),
 169                                             "JDI [" +
 170                                             this.hashCode() + "]");
 171 
 172         /*
 173          * Set up a thread to communicate with the target VM over
 174          * the specified transport.
 175          */
 176         target = new TargetVM(this, connection);
 177 
 178         /*
 179          * Set up a thread to handle events processed internally
 180          * the JDI implementation.
 181          */
 182         EventQueueImpl internalEventQueue = new EventQueueImpl(this, target);
 183         new InternalEventHandler(this, internalEventQueue);
 184         /*
 185          * Initialize client access to event setting and handling
 186          */
 187         eventQueue = new EventQueueImpl(this, target);
 188         eventRequestManager = new EventRequestManagerImpl(this);
 189 
 190         target.start();
 191 
 192         /*
 193          * Many ids are variably sized, depending on target VM.
 194          * Find out the sizes right away.
 195          */
 196         JDWP.VirtualMachine.IDSizes idSizes;
 197         try {
 198             idSizes = JDWP.VirtualMachine.IDSizes.process(vm);
 199         } catch (JDWPException exc) {
 200             throw exc.toJDIException();
 201         }
 202         sizeofFieldRef  = idSizes.fieldIDSize;
 203         sizeofMethodRef = idSizes.methodIDSize;
 204         sizeofObjectRef = idSizes.objectIDSize;
 205         sizeofClassRef = idSizes.referenceTypeIDSize;
 206         sizeofFrameRef  = idSizes.frameIDSize;
 207 
 208         /**
 209          * Set up requests needed by internal event handler.
 210          * Make sure they are distinguished by creating them with
 211          * an internal event request manager.
 212          *
 213          * Warning: create events only with SUSPEND_NONE policy.
 214          * In the current implementation other policies will not
 215          * be handled correctly when the event comes in. (notfiySuspend()
 216          * will not be properly called, and if the event is combined
 217          * with external events in the same set, suspend policy is not
 218          * correctly determined for the internal vs. external event sets)
 219          */
 220         internalEventRequestManager = new EventRequestManagerImpl(this);
 221         EventRequest er = internalEventRequestManager.createClassPrepareRequest();
 222         er.setSuspendPolicy(EventRequest.SUSPEND_NONE);
 223         er.enable();
 224         er = internalEventRequestManager.createClassUnloadRequest();
 225         er.setSuspendPolicy(EventRequest.SUSPEND_NONE);
 226         er.enable();
 227 
 228         /*
 229          * Tell other threads, notably TargetVM, that initialization
 230          * is complete.
 231          */
 232         notifyInitCompletion();
 233     }
 234 
 235     EventRequestManagerImpl getInternalEventRequestManager() {
 236         return internalEventRequestManager;
 237     }
 238 
 239     void validateVM() {
 240         /*
 241          * We no longer need to do this.  The spec now says
 242          * that a VMDisconnected _may_ be thrown in these
 243          * cases, not that it _will_ be thrown.
 244          * So, to simplify things we will just let the
 245          * caller's of this method proceed with their business.
 246          * If the debuggee is disconnected, either because it
 247          * crashed or finished or something, or because the
 248          * debugger called exit() or dispose(), then if
 249          * we end up trying to communicate with the debuggee,
 250          * code in TargetVM will throw a VMDisconnectedException.
 251          * This means that if we can satisfy a request without
 252          * talking to the debuggee, (eg, with cached data) then
 253          * VMDisconnectedException will _not_ be thrown.
 254          * if (shutdown) {
 255          *    throw new VMDisconnectedException();
 256          * }
 257          */
 258     }
 259 
 260     public boolean equals(Object obj) {
 261         return this == obj;
 262     }
 263 
 264     public int hashCode() {
 265         return System.identityHashCode(this);
 266     }
 267 
 268     public List<ReferenceType> classesByName(String className) {
 269         validateVM();
 270         String signature = JNITypeParser.typeNameToSignature(className);
 271         List<ReferenceType> list;
 272         if (retrievedAllTypes) {
 273            list = findReferenceTypes(signature);
 274         } else {
 275            list = retrieveClassesBySignature(signature);
 276         }
 277         return Collections.unmodifiableList(list);
 278     }
 279 
 280     public List<ReferenceType> allClasses() {
 281         validateVM();
 282 
 283         if (!retrievedAllTypes) {
 284             retrieveAllClasses();
 285         }
 286         ArrayList<ReferenceType> a;
 287         synchronized (this) {
 288             a = new ArrayList<ReferenceType>(typesBySignature);
 289         }
 290         return Collections.unmodifiableList(a);
 291     }
 292 
 293     public void
 294         redefineClasses(Map<? extends ReferenceType,byte[]> classToBytes)
 295     {
 296         int cnt = classToBytes.size();
 297         JDWP.VirtualMachine.RedefineClasses.ClassDef[] defs =
 298             new JDWP.VirtualMachine.RedefineClasses.ClassDef[cnt];
 299         validateVM();
 300         if (!canRedefineClasses()) {
 301             throw new UnsupportedOperationException();
 302         }
 303         Iterator<?> it = classToBytes.entrySet().iterator();
 304         for (int i = 0; it.hasNext(); i++) {
 305             Map.Entry<?,?> entry = (Map.Entry)it.next();
 306             ReferenceTypeImpl refType = (ReferenceTypeImpl)entry.getKey();
 307             validateMirror(refType);
 308             defs[i] = new JDWP.VirtualMachine.RedefineClasses
 309                        .ClassDef(refType, (byte[])entry.getValue());
 310         }
 311 
 312         // flush caches and disable caching until the next suspend
 313         vm.state().thaw();
 314 
 315         try {
 316             JDWP.VirtualMachine.RedefineClasses.
 317                 process(vm, defs);
 318         } catch (JDWPException exc) {
 319             switch (exc.errorCode()) {
 320             case JDWP.Error.INVALID_CLASS_FORMAT :
 321                 throw new ClassFormatError(
 322                         "class not in class file format");
 323             case JDWP.Error.CIRCULAR_CLASS_DEFINITION :
 324                 throw new ClassCircularityError(
 325        "circularity has been detected while initializing a class");
 326             case JDWP.Error.FAILS_VERIFICATION :
 327                 throw new VerifyError(
 328    "verifier detected internal inconsistency or security problem");
 329             case JDWP.Error.UNSUPPORTED_VERSION :
 330                 throw new UnsupportedClassVersionError(
 331                     "version numbers of class are not supported");
 332             case JDWP.Error.ADD_METHOD_NOT_IMPLEMENTED:
 333                 throw new UnsupportedOperationException(
 334                               "add method not implemented");
 335             case JDWP.Error.SCHEMA_CHANGE_NOT_IMPLEMENTED :
 336                 throw new UnsupportedOperationException(
 337                               "schema change not implemented");
 338             case JDWP.Error.HIERARCHY_CHANGE_NOT_IMPLEMENTED:
 339                 throw new UnsupportedOperationException(
 340                               "hierarchy change not implemented");
 341             case JDWP.Error.DELETE_METHOD_NOT_IMPLEMENTED :
 342                 throw new UnsupportedOperationException(
 343                               "delete method not implemented");
 344             case JDWP.Error.CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED:
 345                 throw new UnsupportedOperationException(
 346                        "changes to class modifiers not implemented");
 347             case JDWP.Error.METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED :
 348                 throw new UnsupportedOperationException(
 349                        "changes to method modifiers not implemented");
 350             case JDWP.Error.NAMES_DONT_MATCH :
 351                 throw new NoClassDefFoundError(
 352                               "class names do not match");
 353             default:
 354                 throw exc.toJDIException();
 355             }
 356         }
 357 
 358         // Delete any record of the breakpoints
 359         List<BreakpointRequest> toDelete = new ArrayList<BreakpointRequest>();
 360         EventRequestManager erm = eventRequestManager();
 361         it = erm.breakpointRequests().iterator();
 362         while (it.hasNext()) {
 363             BreakpointRequest req = (BreakpointRequest)it.next();
 364             if (classToBytes.containsKey(req.location().declaringType())) {
 365                 toDelete.add(req);
 366             }
 367         }
 368         erm.deleteEventRequests(toDelete);
 369 
 370         // Invalidate any information cached for the classes just redefined.
 371         it = classToBytes.keySet().iterator();
 372         while (it.hasNext()) {
 373             ReferenceTypeImpl rti = (ReferenceTypeImpl)it.next();
 374             rti.noticeRedefineClass();
 375         }
 376     }
 377 
 378     public List<ThreadReference> allThreads() {
 379         validateVM();
 380         return state.allThreads();
 381     }
 382 
 383     public List<ThreadGroupReference> topLevelThreadGroups() {
 384         validateVM();
 385         return state.topLevelThreadGroups();
 386     }
 387 
 388     /*
 389      * Sends a command to the back end which is defined to do an
 390      * implicit vm-wide resume. The VM can no longer be considered
 391      * suspended, so certain cached data must be invalidated.
 392      */
 393     PacketStream sendResumingCommand(CommandSender sender) {
 394         return state.thawCommand(sender);
 395     }
 396 
 397     /*
 398      * The VM has been suspended. Additional caching can be done
 399      * as long as there are no pending resumes.
 400      */
 401     void notifySuspend() {
 402         state.freeze();
 403     }
 404 
 405     public void suspend() {
 406         validateVM();
 407         try {
 408             JDWP.VirtualMachine.Suspend.process(vm);
 409         } catch (JDWPException exc) {
 410             throw exc.toJDIException();
 411         }
 412         notifySuspend();
 413     }
 414 
 415     public void resume() {
 416         validateVM();
 417         CommandSender sender =
 418             new CommandSender() {
 419                 public PacketStream send() {
 420                     return JDWP.VirtualMachine.Resume.enqueueCommand(vm);
 421                 }
 422         };
 423         try {
 424             PacketStream stream = state.thawCommand(sender);
 425             JDWP.VirtualMachine.Resume.waitForReply(vm, stream);
 426         } catch (VMDisconnectedException exc) {
 427             /*
 428              * If the debugger makes a VMDeathRequest with SUSPEND_ALL,
 429              * then when it does an EventSet.resume after getting the
 430              * VMDeathEvent, the normal flow of events is that the
 431              * BE shuts down, but the waitForReply comes back ok.  In this
 432              * case, the run loop in TargetVM that is waiting for a packet
 433              * gets an EOF because the socket closes. It generates a
 434              * VMDisconnectedEvent and everyone is happy.
 435              * However, sometimes, the BE gets shutdown before this
 436              * waitForReply completes.  In this case, TargetVM.waitForReply
 437              * gets awakened with no reply and so gens a VMDisconnectedException
 438              * which is not what we want.  It might be possible to fix this
 439              * in the BE, but it is ok to just ignore the VMDisconnectedException
 440              * here.  This will allow the VMDisconnectedEvent to be generated
 441              * correctly.  And, if the debugger should happen to make another
 442              * request, it will get a VMDisconnectedException at that time.
 443              */
 444         } catch (JDWPException exc) {
 445             switch (exc.errorCode()) {
 446                 case JDWP.Error.VM_DEAD:
 447                     return;
 448                 default:
 449                     throw exc.toJDIException();
 450             }
 451         }
 452     }
 453 
 454     public EventQueue eventQueue() {
 455         /*
 456          * No VM validation here. We allow access to the event queue
 457          * after disconnection, so that there is access to the terminating
 458          * events.
 459          */
 460         return eventQueue;
 461     }
 462 
 463     public EventRequestManager eventRequestManager() {
 464         validateVM();
 465         return eventRequestManager;
 466     }
 467 
 468     EventRequestManagerImpl eventRequestManagerImpl() {
 469         return eventRequestManager;
 470     }
 471 
 472     public BooleanValue mirrorOf(boolean value) {
 473         validateVM();
 474         return new BooleanValueImpl(this,value);
 475     }
 476 
 477     public ByteValue mirrorOf(byte value) {
 478         validateVM();
 479         return new ByteValueImpl(this,value);
 480     }
 481 
 482     public CharValue mirrorOf(char value) {
 483         validateVM();
 484         return new CharValueImpl(this,value);
 485     }
 486 
 487     public ShortValue mirrorOf(short value) {
 488         validateVM();
 489         return new ShortValueImpl(this,value);
 490     }
 491 
 492     public IntegerValue mirrorOf(int value) {
 493         validateVM();
 494         return new IntegerValueImpl(this,value);
 495     }
 496 
 497     public LongValue mirrorOf(long value) {
 498         validateVM();
 499         return new LongValueImpl(this,value);
 500     }
 501 
 502     public FloatValue mirrorOf(float value) {
 503         validateVM();
 504         return new FloatValueImpl(this,value);
 505     }
 506 
 507     public DoubleValue mirrorOf(double value) {
 508         validateVM();
 509         return new DoubleValueImpl(this,value);
 510     }
 511 
 512     public StringReference mirrorOf(String value) {
 513         validateVM();
 514         try {
 515             return (StringReference)JDWP.VirtualMachine.CreateString.
 516                              process(vm, value).stringObject;
 517         } catch (JDWPException exc) {
 518             throw exc.toJDIException();
 519         }
 520     }
 521 
 522     public VoidValue mirrorOfVoid() {
 523         if (voidVal == null) {
 524             voidVal = new VoidValueImpl(this);
 525         }
 526         return voidVal;
 527     }
 528 
 529     public long[] instanceCounts(List<? extends ReferenceType> classes) {
 530         if (!canGetInstanceInfo()) {
 531             throw new UnsupportedOperationException(
 532                 "target does not support getting instances");
 533         }
 534         long[] retValue ;
 535         ReferenceTypeImpl[] rtArray = new ReferenceTypeImpl[classes.size()];
 536         int ii = 0;
 537         for (ReferenceType rti: classes) {
 538             validateMirror(rti);
 539             rtArray[ii++] = (ReferenceTypeImpl)rti;
 540         }
 541         try {
 542             retValue = JDWP.VirtualMachine.InstanceCounts.
 543                                 process(vm, rtArray).counts;
 544         } catch (JDWPException exc) {
 545             throw exc.toJDIException();
 546         }
 547 
 548         return retValue;
 549     }
 550 
 551     public void dispose() {
 552         validateVM();
 553         shutdown = true;
 554         try {
 555             JDWP.VirtualMachine.Dispose.process(vm);
 556         } catch (JDWPException exc) {
 557             throw exc.toJDIException();
 558         }
 559         target.stopListening();
 560     }
 561 
 562     public void exit(int exitCode) {
 563         validateVM();
 564         shutdown = true;
 565         try {
 566             JDWP.VirtualMachine.Exit.process(vm, exitCode);
 567         } catch (JDWPException exc) {
 568             throw exc.toJDIException();
 569         }
 570         target.stopListening();
 571     }
 572 
 573     public Process process() {
 574         validateVM();
 575         return process;
 576     }
 577 
 578     private JDWP.VirtualMachine.Version versionInfo() {
 579        try {
 580            if (versionInfo == null) {
 581                // Need not be synchronized since it is static information
 582                versionInfo = JDWP.VirtualMachine.Version.process(vm);
 583            }
 584            return versionInfo;
 585        } catch (JDWPException exc) {
 586            throw exc.toJDIException();
 587        }
 588    }
 589     public String description() {
 590         validateVM();
 591 
 592         return MessageFormat.format(vmManager.getString("version_format"),
 593                                     "" + vmManager.majorInterfaceVersion(),
 594                                     "" + vmManager.minorInterfaceVersion(),
 595                                      versionInfo().description);
 596     }
 597 
 598     public String version() {
 599         validateVM();
 600         return versionInfo().vmVersion;
 601     }
 602 
 603     public String name() {
 604         validateVM();
 605         return versionInfo().vmName;
 606     }
 607 
 608     public boolean canWatchFieldModification() {
 609         validateVM();
 610         return capabilities().canWatchFieldModification;
 611     }
 612     public boolean canWatchFieldAccess() {
 613         validateVM();
 614         return capabilities().canWatchFieldAccess;
 615     }
 616     public boolean canGetBytecodes() {
 617         validateVM();
 618         return capabilities().canGetBytecodes;
 619     }
 620     public boolean canGetSyntheticAttribute() {
 621         validateVM();
 622         return capabilities().canGetSyntheticAttribute;
 623     }
 624     public boolean canGetOwnedMonitorInfo() {
 625         validateVM();
 626         return capabilities().canGetOwnedMonitorInfo;
 627     }
 628     public boolean canGetCurrentContendedMonitor() {
 629         validateVM();
 630         return capabilities().canGetCurrentContendedMonitor;
 631     }
 632     public boolean canGetMonitorInfo() {
 633         validateVM();
 634         return capabilities().canGetMonitorInfo;
 635     }
 636 
 637     private boolean hasNewCapabilities() {
 638         return versionInfo().jdwpMajor > 1 ||
 639             versionInfo().jdwpMinor >= 4;
 640     }
 641 
 642     boolean canGet1_5LanguageFeatures() {
 643         return versionInfo().jdwpMajor > 1 ||
 644             versionInfo().jdwpMinor >= 5;
 645     }
 646 
 647     public boolean canUseInstanceFilters() {
 648         validateVM();
 649         return hasNewCapabilities() &&
 650             capabilitiesNew().canUseInstanceFilters;
 651     }
 652     public boolean canRedefineClasses() {
 653         validateVM();
 654         return hasNewCapabilities() &&
 655             capabilitiesNew().canRedefineClasses;
 656     }
 657     public boolean canAddMethod() {
 658         validateVM();
 659         return hasNewCapabilities() &&
 660             capabilitiesNew().canAddMethod;
 661     }
 662     public boolean canUnrestrictedlyRedefineClasses() {
 663         validateVM();
 664         return hasNewCapabilities() &&
 665             capabilitiesNew().canUnrestrictedlyRedefineClasses;
 666     }
 667     public boolean canPopFrames() {
 668         validateVM();
 669         return hasNewCapabilities() &&
 670             capabilitiesNew().canPopFrames;
 671     }
 672     public boolean canGetMethodReturnValues() {
 673         return versionInfo().jdwpMajor > 1 ||
 674             versionInfo().jdwpMinor >= 6;
 675     }
 676     public boolean canGetInstanceInfo() {
 677         if (versionInfo().jdwpMajor < 1 ||
 678             versionInfo().jdwpMinor < 6) {
 679             return false;
 680         }
 681         validateVM();
 682         return hasNewCapabilities() &&
 683             capabilitiesNew().canGetInstanceInfo;
 684     }
 685     public boolean canUseSourceNameFilters() {
 686         if (versionInfo().jdwpMajor < 1 ||
 687             versionInfo().jdwpMinor < 6) {
 688             return false;
 689         }
 690         return true;
 691     }
 692     public boolean canForceEarlyReturn() {
 693         validateVM();
 694         return hasNewCapabilities() &&
 695             capabilitiesNew().canForceEarlyReturn;
 696     }
 697     public boolean canBeModified() {
 698         return true;
 699     }
 700     public boolean canGetSourceDebugExtension() {
 701         validateVM();
 702         return hasNewCapabilities() &&
 703             capabilitiesNew().canGetSourceDebugExtension;
 704     }
 705     public boolean canGetClassFileVersion() {
 706         if ( versionInfo().jdwpMajor < 1 &&
 707              versionInfo().jdwpMinor  < 6) {
 708             return false;
 709         } else {
 710             return true;
 711         }
 712     }
 713     public boolean canGetConstantPool() {
 714         validateVM();
 715         return hasNewCapabilities() &&
 716             capabilitiesNew().canGetConstantPool;
 717     }
 718     public boolean canRequestVMDeathEvent() {
 719         validateVM();
 720         return hasNewCapabilities() &&
 721             capabilitiesNew().canRequestVMDeathEvent;
 722     }
 723     public boolean canRequestMonitorEvents() {
 724         validateVM();
 725         return hasNewCapabilities() &&
 726             capabilitiesNew().canRequestMonitorEvents;
 727     }
 728     public boolean canGetMonitorFrameInfo() {
 729         validateVM();
 730         return hasNewCapabilities() &&
 731             capabilitiesNew().canGetMonitorFrameInfo;
 732     }
 733 
 734     public void setDebugTraceMode(int traceFlags) {
 735         validateVM();
 736         this.traceFlags = traceFlags;
 737         this.traceReceives = (traceFlags & TRACE_RECEIVES) != 0;
 738     }
 739 
 740     void printTrace(String string) {
 741         System.err.println("[JDI: " + string + "]");
 742     }
 743 
 744     void printReceiveTrace(int depth, String string) {
 745         StringBuilder sb = new StringBuilder("Receiving:");
 746         for (int i = depth; i > 0; --i) {
 747             sb.append("    ");
 748         }
 749         sb.append(string);
 750         printTrace(sb.toString());
 751     }
 752 
 753     private synchronized ReferenceTypeImpl addReferenceType(long id,
 754                                                        int tag,
 755                                                        String signature) {
 756         if (typesByID == null) {
 757             initReferenceTypes();
 758         }
 759         ReferenceTypeImpl type = null;
 760         switch(tag) {
 761             case JDWP.TypeTag.CLASS:
 762                 type = new ClassTypeImpl(vm, id);
 763                 break;
 764             case JDWP.TypeTag.INTERFACE:
 765                 type = new InterfaceTypeImpl(vm, id);
 766                 break;
 767             case JDWP.TypeTag.ARRAY:
 768                 type = new ArrayTypeImpl(vm, id);
 769                 break;
 770             default:
 771                 throw new InternalException("Invalid reference type tag");
 772         }
 773 
 774         /*
 775          * If a signature was specified, make sure to set it ASAP, to
 776          * prevent any needless JDWP command to retrieve it. (for example,
 777          * typesBySignature.add needs the signature, to maintain proper
 778          * ordering.
 779          */
 780         if (signature != null) {
 781             type.setSignature(signature);
 782         }
 783 
 784         typesByID.put(new Long(id), type);
 785         typesBySignature.add(type);
 786 
 787         if ((vm.traceFlags & VirtualMachine.TRACE_REFTYPES) != 0) {
 788            vm.printTrace("Caching new ReferenceType, sig=" + signature +
 789                          ", id=" + id);
 790         }
 791 
 792         return type;
 793     }
 794 
 795     synchronized void removeReferenceType(String signature) {
 796         if (typesByID == null) {
 797             return;
 798         }
 799         /*
 800          * There can be multiple classes with the same name. Since
 801          * we can't differentiate here, we first remove all
 802          * matching classes from our cache...
 803          */
 804         Iterator<ReferenceType> iter = typesBySignature.iterator();
 805         int matches = 0;
 806         while (iter.hasNext()) {
 807             ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next();
 808             int comp = signature.compareTo(type.signature());
 809             if (comp == 0) {
 810                 matches++;
 811                 iter.remove();
 812                 typesByID.remove(new Long(type.ref()));
 813                 if ((vm.traceFlags & VirtualMachine.TRACE_REFTYPES) != 0) {
 814                    vm.printTrace("Uncaching ReferenceType, sig=" + signature +
 815                                  ", id=" + type.ref());
 816                 }
 817 /* fix for 4359077 , don't break out. list is no longer sorted
 818         in the order we think
 819  */
 820             }
 821         }
 822 
 823         /*
 824          * ...and if there was more than one, re-retrieve the classes
 825          * with that name
 826          */
 827         if (matches > 1) {
 828             retrieveClassesBySignature(signature);
 829         }
 830     }
 831 
 832     private synchronized List<ReferenceType> findReferenceTypes(String signature) {
 833         if (typesByID == null) {
 834             return new ArrayList<ReferenceType>(0);
 835         }
 836         Iterator<ReferenceType> iter = typesBySignature.iterator();
 837         List<ReferenceType> list = new ArrayList<ReferenceType>();
 838         while (iter.hasNext()) {
 839             ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next();
 840             int comp = signature.compareTo(type.signature());
 841             if (comp == 0) {
 842                 list.add(type);
 843 /* fix for 4359077 , don't break out. list is no longer sorted
 844         in the order we think
 845  */
 846             }
 847         }
 848         return list;
 849     }
 850 
 851     private void initReferenceTypes() {
 852         typesByID = new HashMap<Long, ReferenceType>(300);
 853         typesBySignature = new TreeSet<ReferenceType>();
 854     }
 855 
 856     ReferenceTypeImpl referenceType(long ref, byte tag) {
 857         return referenceType(ref, tag, null);
 858     }
 859 
 860     ClassTypeImpl classType(long ref) {
 861         return (ClassTypeImpl)referenceType(ref, JDWP.TypeTag.CLASS, null);
 862     }
 863 
 864     InterfaceTypeImpl interfaceType(long ref) {
 865         return (InterfaceTypeImpl)referenceType(ref, JDWP.TypeTag.INTERFACE, null);
 866     }
 867 
 868     ArrayTypeImpl arrayType(long ref) {
 869         return (ArrayTypeImpl)referenceType(ref, JDWP.TypeTag.ARRAY, null);
 870     }
 871 
 872     ReferenceTypeImpl referenceType(long id, int tag,
 873                                                  String signature) {
 874         if ((vm.traceFlags & VirtualMachine.TRACE_REFTYPES) != 0) {
 875             StringBuilder sb = new StringBuilder();
 876             sb.append("Looking up ");
 877             if (tag == JDWP.TypeTag.CLASS) {
 878                 sb.append("Class");
 879             } else if (tag == JDWP.TypeTag.INTERFACE) {
 880                 sb.append("Interface");
 881             } else if (tag == JDWP.TypeTag.ARRAY) {
 882                 sb.append("ArrayType");
 883             } else {
 884                 sb.append("UNKNOWN TAG: " + tag);
 885             }
 886             if (signature != null) {
 887                 sb.append(", signature='" + signature + "'");
 888             }
 889             sb.append(", id=" + id);
 890             vm.printTrace(sb.toString());
 891         }
 892         if (id == 0) {
 893             return null;
 894         } else {
 895             ReferenceTypeImpl retType = null;
 896             synchronized (this) {
 897                 if (typesByID != null) {
 898                     retType = (ReferenceTypeImpl)typesByID.get(new Long(id));
 899                 }
 900                 if (retType == null) {
 901                     retType = addReferenceType(id, tag, signature);
 902                 }
 903             }
 904             return retType;
 905         }
 906     }
 907 
 908     private JDWP.VirtualMachine.Capabilities capabilities() {
 909         if (capabilities == null) {
 910             try {
 911                 capabilities = JDWP.VirtualMachine
 912                                  .Capabilities.process(vm);
 913             } catch (JDWPException exc) {
 914                 throw exc.toJDIException();
 915             }
 916         }
 917         return capabilities;
 918     }
 919 
 920     private JDWP.VirtualMachine.CapabilitiesNew capabilitiesNew() {
 921         if (capabilitiesNew == null) {
 922             try {
 923                 capabilitiesNew = JDWP.VirtualMachine
 924                                  .CapabilitiesNew.process(vm);
 925             } catch (JDWPException exc) {
 926                 throw exc.toJDIException();
 927             }
 928         }
 929         return capabilitiesNew;
 930     }
 931 
 932     private List<ReferenceType> retrieveClassesBySignature(String signature) {
 933         if ((vm.traceFlags & VirtualMachine.TRACE_REFTYPES) != 0) {
 934             vm.printTrace("Retrieving matching ReferenceTypes, sig=" + signature);
 935         }
 936         JDWP.VirtualMachine.ClassesBySignature.ClassInfo[] cinfos;
 937         try {
 938             cinfos = JDWP.VirtualMachine.ClassesBySignature.
 939                                       process(vm, signature).classes;
 940         } catch (JDWPException exc) {
 941             throw exc.toJDIException();
 942         }
 943 
 944         int count = cinfos.length;
 945         List<ReferenceType> list = new ArrayList<ReferenceType>(count);
 946 
 947         // Hold lock during processing to improve performance
 948         synchronized (this) {
 949             for (int i = 0; i < count; i++) {
 950                 JDWP.VirtualMachine.ClassesBySignature.ClassInfo ci =
 951                                                                cinfos[i];
 952                 ReferenceTypeImpl type = referenceType(ci.typeID,
 953                                                        ci.refTypeTag,
 954                                                        signature);
 955                 type.setStatus(ci.status);
 956                 list.add(type);
 957             }
 958         }
 959         return list;
 960     }
 961 
 962     private void retrieveAllClasses1_4() {
 963         JDWP.VirtualMachine.AllClasses.ClassInfo[] cinfos;
 964         try {
 965             cinfos = JDWP.VirtualMachine.AllClasses.process(vm).classes;
 966         } catch (JDWPException exc) {
 967             throw exc.toJDIException();
 968         }
 969 
 970         // Hold lock during processing to improve performance
 971         // and to have safe check/set of retrievedAllTypes
 972         synchronized (this) {
 973             if (!retrievedAllTypes) {
 974                 // Number of classes
 975                 int count = cinfos.length;
 976                 for (int i=0; i<count; i++) {
 977                     JDWP.VirtualMachine.AllClasses.ClassInfo ci =
 978                                                                cinfos[i];
 979                     ReferenceTypeImpl type = referenceType(ci.typeID,
 980                                                            ci.refTypeTag,
 981                                                            ci.signature);
 982                     type.setStatus(ci.status);
 983                 }
 984                 retrievedAllTypes = true;
 985             }
 986         }
 987     }
 988 
 989     private void retrieveAllClasses() {
 990         if ((vm.traceFlags & VirtualMachine.TRACE_REFTYPES) != 0) {
 991             vm.printTrace("Retrieving all ReferenceTypes");
 992         }
 993 
 994         if (!vm.canGet1_5LanguageFeatures()) {
 995             retrieveAllClasses1_4();
 996             return;
 997         }
 998 
 999         /*
1000          * To save time (assuming the caller will be
1001          * using then) we will get the generic sigs too.
1002          */
1003 
1004         JDWP.VirtualMachine.AllClassesWithGeneric.ClassInfo[] cinfos;
1005         try {
1006             cinfos = JDWP.VirtualMachine.AllClassesWithGeneric.process(vm).classes;
1007         } catch (JDWPException exc) {
1008             throw exc.toJDIException();
1009         }
1010 
1011         // Hold lock during processing to improve performance
1012         // and to have safe check/set of retrievedAllTypes
1013         synchronized (this) {
1014             if (!retrievedAllTypes) {
1015                 // Number of classes
1016                 int count = cinfos.length;
1017                 for (int i=0; i<count; i++) {
1018                     JDWP.VirtualMachine.AllClassesWithGeneric.ClassInfo ci =
1019                                                                cinfos[i];
1020                     ReferenceTypeImpl type = referenceType(ci.typeID,
1021                                                            ci.refTypeTag,
1022                                                            ci.signature);
1023                     type.setGenericSignature(ci.genericSignature);
1024                     type.setStatus(ci.status);
1025                 }
1026                 retrievedAllTypes = true;
1027             }
1028         }
1029     }
1030 
1031     void sendToTarget(Packet packet) {
1032         target.send(packet);
1033     }
1034 
1035     void waitForTargetReply(Packet packet) {
1036         target.waitForReply(packet);
1037         /*
1038          * If any object disposes have been batched up, send them now.
1039          */
1040         processBatchedDisposes();
1041     }
1042 
1043     Type findBootType(String signature) throws ClassNotLoadedException {
1044         List<ReferenceType> types = allClasses();
1045         Iterator<ReferenceType> iter = types.iterator();
1046         while (iter.hasNext()) {
1047             ReferenceType type = iter.next();
1048             if ((type.classLoader() == null) &&
1049                 (type.signature().equals(signature))) {
1050                 return type;
1051             }
1052         }
1053         JNITypeParser parser = new JNITypeParser(signature);
1054         throw new ClassNotLoadedException(parser.typeName(),
1055                                          "Type " + parser.typeName() + " not loaded");
1056     }
1057 
1058     BooleanType theBooleanType() {
1059         if (theBooleanType == null) {
1060             synchronized(this) {
1061                 if (theBooleanType == null) {
1062                     theBooleanType = new BooleanTypeImpl(this);
1063                 }
1064             }
1065         }
1066         return theBooleanType;
1067     }
1068 
1069     ByteType theByteType() {
1070         if (theByteType == null) {
1071             synchronized(this) {
1072                 if (theByteType == null) {
1073                     theByteType = new ByteTypeImpl(this);
1074                 }
1075             }
1076         }
1077         return theByteType;
1078     }
1079 
1080     CharType theCharType() {
1081         if (theCharType == null) {
1082             synchronized(this) {
1083                 if (theCharType == null) {
1084                     theCharType = new CharTypeImpl(this);
1085                 }
1086             }
1087         }
1088         return theCharType;
1089     }
1090 
1091     ShortType theShortType() {
1092         if (theShortType == null) {
1093             synchronized(this) {
1094                 if (theShortType == null) {
1095                     theShortType = new ShortTypeImpl(this);
1096                 }
1097             }
1098         }
1099         return theShortType;
1100     }
1101 
1102     IntegerType theIntegerType() {
1103         if (theIntegerType == null) {
1104             synchronized(this) {
1105                 if (theIntegerType == null) {
1106                     theIntegerType = new IntegerTypeImpl(this);
1107                 }
1108             }
1109         }
1110         return theIntegerType;
1111     }
1112 
1113     LongType theLongType() {
1114         if (theLongType == null) {
1115             synchronized(this) {
1116                 if (theLongType == null) {
1117                     theLongType = new LongTypeImpl(this);
1118                 }
1119             }
1120         }
1121         return theLongType;
1122     }
1123 
1124     FloatType theFloatType() {
1125         if (theFloatType == null) {
1126             synchronized(this) {
1127                 if (theFloatType == null) {
1128                     theFloatType = new FloatTypeImpl(this);
1129                 }
1130             }
1131         }
1132         return theFloatType;
1133     }
1134 
1135     DoubleType theDoubleType() {
1136         if (theDoubleType == null) {
1137             synchronized(this) {
1138                 if (theDoubleType == null) {
1139                     theDoubleType = new DoubleTypeImpl(this);
1140                 }
1141             }
1142         }
1143         return theDoubleType;
1144     }
1145 
1146     VoidType theVoidType() {
1147         if (theVoidType == null) {
1148             synchronized(this) {
1149                 if (theVoidType == null) {
1150                     theVoidType = new VoidTypeImpl(this);
1151                 }
1152             }
1153         }
1154         return theVoidType;
1155     }
1156 
1157     PrimitiveType primitiveTypeMirror(byte tag) {
1158         switch (tag) {
1159             case JDWP.Tag.BOOLEAN:
1160                 return theBooleanType();
1161             case JDWP.Tag.BYTE:
1162                 return theByteType();
1163             case JDWP.Tag.CHAR:
1164                 return theCharType();
1165             case JDWP.Tag.SHORT:
1166                 return theShortType();
1167             case JDWP.Tag.INT:
1168                 return theIntegerType();
1169             case JDWP.Tag.LONG:
1170                 return theLongType();
1171             case JDWP.Tag.FLOAT:
1172                 return theFloatType();
1173             case JDWP.Tag.DOUBLE:
1174                 return theDoubleType();
1175             default:
1176                 throw new IllegalArgumentException("Unrecognized primitive tag " + tag);
1177         }
1178     }
1179 
1180     private void processBatchedDisposes() {
1181         if (shutdown) {
1182             return;
1183         }
1184 
1185         JDWP.VirtualMachine.DisposeObjects.Request[] requests = null;
1186         synchronized(batchedDisposeRequests) {
1187             int size = batchedDisposeRequests.size();
1188             if (size >= DISPOSE_THRESHOLD) {
1189                 if ((traceFlags & TRACE_OBJREFS) != 0) {
1190                     printTrace("Dispose threashold reached. Will dispose "
1191                                + size + " object references...");
1192                 }
1193                 requests = new JDWP.VirtualMachine.DisposeObjects.Request[size];
1194                 for (int i = 0; i < requests.length; i++) {
1195                     SoftObjectReference ref = batchedDisposeRequests.get(i);
1196                     if ((traceFlags & TRACE_OBJREFS) != 0) {
1197                         printTrace("Disposing object " + ref.key().longValue() +
1198                                    " (ref count = " + ref.count() + ")");
1199                     }
1200 
1201                     // This is kludgy. We temporarily re-create an object
1202                     // reference so that we can correctly pass its id to the
1203                     // JDWP command.
1204                     requests[i] =
1205                         new JDWP.VirtualMachine.DisposeObjects.Request(
1206                             new ObjectReferenceImpl(this, ref.key().longValue()),
1207                             ref.count());
1208                 }
1209                 batchedDisposeRequests.clear();
1210             }
1211         }
1212         if (requests != null) {
1213             try {
1214                 JDWP.VirtualMachine.DisposeObjects.process(vm, requests);
1215             } catch (JDWPException exc) {
1216                 throw exc.toJDIException();
1217             }
1218         }
1219     }
1220 
1221     private void batchForDispose(SoftObjectReference ref) {
1222         if ((traceFlags & TRACE_OBJREFS) != 0) {
1223             printTrace("Batching object " + ref.key().longValue() +
1224                        " for dispose (ref count = " + ref.count() + ")");
1225         }
1226         batchedDisposeRequests.add(ref);
1227     }
1228 
1229     private void processQueue() {
1230         Reference<?> ref;
1231         //if ((traceFlags & TRACE_OBJREFS) != 0) {
1232         //    printTrace("Checking for softly reachable objects");
1233         //}
1234         while ((ref = referenceQueue.poll()) != null) {
1235             SoftObjectReference softRef = (SoftObjectReference)ref;
1236             removeObjectMirror(softRef);
1237             batchForDispose(softRef);
1238         }
1239     }
1240 
1241     synchronized ObjectReferenceImpl objectMirror(long id, int tag) {
1242 
1243         // Handle any queue elements that are not strongly reachable
1244         processQueue();
1245 
1246         if (id == 0) {
1247             return null;
1248         }
1249         ObjectReferenceImpl object = null;
1250         Long key = new Long(id);
1251 
1252         /*
1253          * Attempt to retrieve an existing object object reference
1254          */
1255         SoftObjectReference ref = objectsByID.get(key);
1256         if (ref != null) {
1257             object = ref.object();
1258         }
1259 
1260         /*
1261          * If the object wasn't in the table, or it's soft reference was
1262          * cleared, create a new instance.
1263          */
1264         if (object == null) {
1265             switch (tag) {
1266                 case JDWP.Tag.OBJECT:
1267                     object = new ObjectReferenceImpl(vm, id);
1268                     break;
1269                 case JDWP.Tag.STRING:
1270                     object = new StringReferenceImpl(vm, id);
1271                     break;
1272                 case JDWP.Tag.ARRAY:
1273                     object = new ArrayReferenceImpl(vm, id);
1274                     break;
1275                 case JDWP.Tag.THREAD:
1276                     ThreadReferenceImpl thread =
1277                         new ThreadReferenceImpl(vm, id);
1278                     thread.addListener(this);
1279                     object = thread;
1280                     break;
1281                 case JDWP.Tag.THREAD_GROUP:
1282                     object = new ThreadGroupReferenceImpl(vm, id);
1283                     break;
1284                 case JDWP.Tag.CLASS_LOADER:
1285                     object = new ClassLoaderReferenceImpl(vm, id);
1286                     break;
1287                 case JDWP.Tag.CLASS_OBJECT:
1288                     object = new ClassObjectReferenceImpl(vm, id);
1289                     break;
1290                 default:
1291                     throw new IllegalArgumentException("Invalid object tag: " + tag);
1292             }
1293             ref = new SoftObjectReference(key, object, referenceQueue);
1294 
1295             /*
1296              * If there was no previous entry in the table, we add one here
1297              * If the previous entry was cleared, we replace it here.
1298              */
1299             objectsByID.put(key, ref);
1300             if ((traceFlags & TRACE_OBJREFS) != 0) {
1301                 printTrace("Creating new " +
1302                            object.getClass().getName() + " (id = " + id + ")");
1303             }
1304         } else {
1305             ref.incrementCount();
1306         }
1307 
1308         return object;
1309     }
1310 
1311     synchronized void removeObjectMirror(ObjectReferenceImpl object) {
1312 
1313         // Handle any queue elements that are not strongly reachable
1314         processQueue();
1315 
1316         SoftObjectReference ref = objectsByID.remove(new Long(object.ref()));
1317         if (ref != null) {
1318             batchForDispose(ref);
1319         } else {
1320             /*
1321              * If there's a live ObjectReference about, it better be part
1322              * of the cache.
1323              */
1324             throw new InternalException("ObjectReference " + object.ref() +
1325                                         " not found in object cache");
1326         }
1327     }
1328 
1329     synchronized void removeObjectMirror(SoftObjectReference ref) {
1330         /*
1331          * This will remove the soft reference if it has not been
1332          * replaced in the cache.
1333          */
1334         objectsByID.remove(ref.key());
1335     }
1336 
1337     ObjectReferenceImpl objectMirror(long id) {
1338         return objectMirror(id, JDWP.Tag.OBJECT);
1339     }
1340 
1341     StringReferenceImpl stringMirror(long id) {
1342         return (StringReferenceImpl)objectMirror(id, JDWP.Tag.STRING);
1343     }
1344 
1345     ArrayReferenceImpl arrayMirror(long id) {
1346        return (ArrayReferenceImpl)objectMirror(id, JDWP.Tag.ARRAY);
1347     }
1348 
1349     ThreadReferenceImpl threadMirror(long id) {
1350         return (ThreadReferenceImpl)objectMirror(id, JDWP.Tag.THREAD);
1351     }
1352 
1353     ThreadGroupReferenceImpl threadGroupMirror(long id) {
1354         return (ThreadGroupReferenceImpl)objectMirror(id,
1355                                                       JDWP.Tag.THREAD_GROUP);
1356     }
1357 
1358     ClassLoaderReferenceImpl classLoaderMirror(long id) {
1359         return (ClassLoaderReferenceImpl)objectMirror(id,
1360                                                       JDWP.Tag.CLASS_LOADER);
1361     }
1362 
1363     ClassObjectReferenceImpl classObjectMirror(long id) {
1364         return (ClassObjectReferenceImpl)objectMirror(id,
1365                                                       JDWP.Tag.CLASS_OBJECT);
1366     }
1367 
1368     /*
1369      * Implementation of PathSearchingVirtualMachine
1370      */
1371     private JDWP.VirtualMachine.ClassPaths getClasspath() {
1372         if (pathInfo == null) {
1373             try {
1374                 pathInfo = JDWP.VirtualMachine.ClassPaths.process(vm);
1375             } catch (JDWPException exc) {
1376                 throw exc.toJDIException();
1377             }
1378         }
1379         return pathInfo;
1380     }
1381 
1382    public List<String> classPath() {
1383        return Arrays.asList(getClasspath().classpaths);
1384    }
1385 
1386    public List<String> bootClassPath() {
1387        return Arrays.asList(getClasspath().bootclasspaths);
1388    }
1389 
1390    public String baseDirectory() {
1391        return getClasspath().baseDir;
1392    }
1393 
1394     public void setDefaultStratum(String stratum) {
1395         defaultStratum = stratum;
1396         if (stratum == null) {
1397             stratum = "";
1398         }
1399         try {
1400             JDWP.VirtualMachine.SetDefaultStratum.process(vm,
1401                                                           stratum);
1402         } catch (JDWPException exc) {
1403             throw exc.toJDIException();
1404         }
1405     }
1406 
1407     public String getDefaultStratum() {
1408         return defaultStratum;
1409     }
1410 
1411     ThreadGroup threadGroupForJDI() {
1412         return threadGroupForJDI;
1413     }
1414 
1415    static private class SoftObjectReference extends SoftReference<ObjectReferenceImpl> {
1416        int count;
1417        Long key;
1418 
1419        SoftObjectReference(Long key, ObjectReferenceImpl mirror,
1420                            ReferenceQueue<ObjectReferenceImpl> queue) {
1421            super(mirror, queue);
1422            this.count = 1;
1423            this.key = key;
1424        }
1425 
1426        int count() {
1427            return count;
1428        }
1429 
1430        void incrementCount() {
1431            count++;
1432        }
1433 
1434        Long key() {
1435            return key;
1436        }
1437 
1438        ObjectReferenceImpl object() {
1439            return get();
1440        }
1441    }
1442 }
--- EOF ---