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 /*
  27  * This source code is provided to illustrate the usage of a given feature
  28  * or technique and has been deliberately simplified. Additional steps
  29  * required for a production-quality application, such as security checks,
  30  * input validation and proper error handling, might not be present in
  31  * this sample code.
  32  */
  33 
  34 
  35 package com.sun.tools.example.debug.gui;
  36 
  37 import java.io.*;
  38 import java.util.*;
  39 
  40 import com.sun.jdi.*;
  41 import com.sun.tools.example.debug.event.*;
  42 import com.sun.tools.example.debug.bdi.*;
  43 
  44 public class ContextManager {
  45 
  46     private ClassManager classManager;
  47     private ExecutionManager runtime;
  48 
  49     private String mainClassName;
  50     private String vmArguments;
  51     private String commandArguments;
  52     private String remotePort;
  53 
  54     private ThreadReference currentThread;
  55 
  56     private boolean verbose;
  57 
  58     private ArrayList<ContextListener> contextListeners = new ArrayList<ContextListener>();
  59 
  60     public ContextManager(Environment env) {
  61         classManager = env.getClassManager();
  62         runtime = env.getExecutionManager();
  63         mainClassName = "";
  64         vmArguments = "";
  65         commandArguments = "";
  66         currentThread = null;
  67 
  68         ContextManagerListener listener = new ContextManagerListener();
  69         runtime.addJDIListener(listener);
  70         runtime.addSessionListener(listener);
  71     }
  72 
  73     // Program execution defaults.
  74 
  75     //### Should there be change listeners for these?
  76     //### They would be needed if we expected a dialog to be
  77     //### synchronized with command input while it was open.
  78 
  79     public String getMainClassName() {
  80         return mainClassName;
  81     }
  82 
  83     public void setMainClassName(String mainClassName) {
  84         this.mainClassName = mainClassName;
  85     }
  86 
  87     public String getVmArguments() {
  88         return processClasspathDefaults(vmArguments);
  89     }
  90 
  91     public void setVmArguments(String vmArguments) {
  92         this.vmArguments = vmArguments;
  93     }
  94 
  95     public String getProgramArguments() {
  96         return commandArguments;
  97     }
  98 
  99     public void setProgramArguments(String commandArguments) {
 100         this.commandArguments = commandArguments;
 101     }
 102 
 103     public String getRemotePort() {
 104         return remotePort;
 105     }
 106 
 107     public void setRemotePort(String remotePort) {
 108         this.remotePort = remotePort;
 109 
 110     }
 111 
 112 
 113     // Miscellaneous debugger session preferences.
 114 
 115     public boolean getVerboseFlag() {
 116         return verbose;
 117     }
 118 
 119     public void setVerboseFlag(boolean verbose) {
 120         this.verbose = verbose;
 121     }
 122 
 123 
 124     // Thread focus.
 125 
 126     public ThreadReference getCurrentThread() {
 127         return currentThread;
 128     }
 129 
 130     public void setCurrentThread(ThreadReference t) {
 131         if (t != currentThread) {
 132             currentThread = t;
 133             notifyCurrentThreadChanged(t);
 134         }
 135     }
 136 
 137     public void setCurrentThreadInvalidate(ThreadReference t) {
 138         currentThread = t;
 139         notifyCurrentFrameChanged(runtime.threadInfo(t),
 140                                   0, true);
 141     }
 142 
 143     public void invalidateCurrentThread() {
 144         notifyCurrentFrameChanged(null, 0, true);
 145     }
 146 
 147 
 148     // If a view is displaying the current thread, it may
 149     // choose to indicate which frame is current in the
 150     // sense of the command-line UI.  It may also "warp" the
 151     // selection to that frame when changed by an 'up' or 'down'
 152     // command. Hence, a notifier is provided.
 153 
 154     /******
 155     public int getCurrentFrameIndex() {
 156         return getCurrentFrameIndex(currentThreadInfo);
 157     }
 158     ******/
 159 
 160     public int getCurrentFrameIndex(ThreadReference t) {
 161         return getCurrentFrameIndex(runtime.threadInfo(t));
 162     }
 163 
 164     //### Used in StackTraceTool.
 165     public int getCurrentFrameIndex(ThreadInfo tinfo) {
 166         if (tinfo == null) {
 167             return 0;
 168         }
 169         Integer currentFrame = (Integer)tinfo.getUserObject();
 170         if (currentFrame == null) {
 171             return 0;
 172         } else {
 173             return currentFrame.intValue();
 174         }
 175     }
 176 
 177     public int moveCurrentFrameIndex(ThreadReference t, int count) throws VMNotInterruptedException {
 178         return setCurrentFrameIndex(t,count, true);
 179     }
 180 
 181     public int setCurrentFrameIndex(ThreadReference t, int newIndex) throws VMNotInterruptedException {
 182         return setCurrentFrameIndex(t, newIndex, false);
 183     }
 184 
 185     public int setCurrentFrameIndex(int newIndex) throws VMNotInterruptedException {
 186         if (currentThread == null) {
 187             return 0;
 188         } else {
 189             return setCurrentFrameIndex(currentThread, newIndex, false);
 190         }
 191     }
 192 
 193     private int setCurrentFrameIndex(ThreadReference t, int x, boolean relative) throws VMNotInterruptedException {
 194         boolean sameThread = t.equals(currentThread);
 195         ThreadInfo tinfo = runtime.threadInfo(t);
 196         if (tinfo == null) {
 197             return 0;
 198         }
 199         int maxIndex = tinfo.getFrameCount()-1;
 200         int oldIndex = getCurrentFrameIndex(tinfo);
 201         int newIndex = relative? oldIndex + x : x;
 202         if (newIndex > maxIndex) {
 203             newIndex = maxIndex;
 204         } else  if (newIndex < 0) {
 205             newIndex = 0;
 206         }
 207         if (!sameThread || newIndex != oldIndex) {  // don't recurse
 208             setCurrentFrameIndex(tinfo, newIndex);
 209         }
 210         return newIndex - oldIndex;
 211     }
 212 
 213     private void setCurrentFrameIndex(ThreadInfo tinfo, int index) {
 214         tinfo.setUserObject(index);
 215         //### In fact, the value may not have changed at this point.
 216         //### We need to signal that the user attempted to change it,
 217         //### however, so that the selection can be "warped" to the
 218         //### current location.
 219         notifyCurrentFrameChanged(tinfo.thread(), index);
 220     }
 221 
 222     public StackFrame getCurrentFrame() throws VMNotInterruptedException {
 223         return getCurrentFrame(runtime.threadInfo(currentThread));
 224     }
 225 
 226     public StackFrame getCurrentFrame(ThreadReference t) throws VMNotInterruptedException {
 227         return getCurrentFrame(runtime.threadInfo(t));
 228     }
 229 
 230     public StackFrame getCurrentFrame(ThreadInfo tinfo) throws VMNotInterruptedException {
 231         int index = getCurrentFrameIndex(tinfo);
 232         try {
 233             // It is possible, though unlikely, that the VM was interrupted
 234             // before the thread created its Java stack.
 235             return tinfo.getFrame(index);
 236         } catch (FrameIndexOutOfBoundsException e) {
 237             return null;
 238         }
 239     }
 240 
 241     public void addContextListener(ContextListener cl) {
 242         contextListeners.add(cl);
 243     }
 244 
 245     public void removeContextListener(ContextListener cl) {
 246         contextListeners.remove(cl);
 247     }
 248 
 249     //### These notifiers are fired only in response to USER-INITIATED changes
 250     //### to the current thread and current frame.  When the current thread is set automatically
 251     //### after a breakpoint hit or step completion, no event is generated.  Instead,
 252     //### interested parties are expected to listen for the BreakpointHit and StepCompleted
 253     //### events.  This convention is unclean, and I believe that it reflects a defect in
 254     //### in the current architecture.  Unfortunately, however, we cannot guarantee the
 255     //### order in which various listeners receive a given event, and the handlers for
 256     //### the very same events that cause automatic changes to the current thread may also
 257     //### need to know the current thread.
 258 
 259     private void notifyCurrentThreadChanged(ThreadReference t) {
 260         ThreadInfo tinfo = null;
 261         int index = 0;
 262         if (t != null) {
 263             tinfo = runtime.threadInfo(t);
 264             index = getCurrentFrameIndex(tinfo);
 265         }
 266         notifyCurrentFrameChanged(tinfo, index, false);
 267     }
 268 
 269     private void notifyCurrentFrameChanged(ThreadReference t, int index) {
 270         notifyCurrentFrameChanged(runtime.threadInfo(t),
 271                                   index, false);
 272     }
 273 
 274     private void notifyCurrentFrameChanged(ThreadInfo tinfo, int index,
 275                                            boolean invalidate) {
 276         ArrayList<ContextListener> l =  new ArrayList<ContextListener>(contextListeners);
 277         CurrentFrameChangedEvent evt =
 278             new CurrentFrameChangedEvent(this, tinfo, index, invalidate);
 279         for (int i = 0; i < l.size(); i++) {
 280             l.get(i).currentFrameChanged(evt);
 281         }
 282     }
 283 
 284     private class ContextManagerListener extends JDIAdapter
 285                        implements SessionListener, JDIListener {
 286 
 287         // SessionListener
 288 
 289         @Override
 290         public void sessionStart(EventObject e) {
 291             invalidateCurrentThread();
 292         }
 293 
 294         @Override
 295         public void sessionInterrupt(EventObject e) {
 296             setCurrentThreadInvalidate(currentThread);
 297         }
 298 
 299         @Override
 300         public void sessionContinue(EventObject e) {
 301             invalidateCurrentThread();
 302         }
 303 
 304         // JDIListener
 305 
 306         @Override
 307         public void locationTrigger(LocationTriggerEventSet e) {
 308             setCurrentThreadInvalidate(e.getThread());
 309         }
 310 
 311         @Override
 312         public void exception(ExceptionEventSet e) {
 313             setCurrentThreadInvalidate(e.getThread());
 314         }
 315 
 316         @Override
 317         public void vmDisconnect(VMDisconnectEventSet e) {
 318             invalidateCurrentThread();
 319         }
 320 
 321     }
 322 
 323 
 324     /**
 325      * Add a -classpath argument to the arguments passed to the exec'ed
 326      * VM with the contents of CLASSPATH environment variable,
 327      * if -classpath was not already specified.
 328      *
 329      * @param javaArgs the arguments to the VM being exec'd that
 330      *                 potentially has a user specified -classpath argument.
 331      * @return a javaArgs whose -classpath option has been added
 332      */
 333 
 334     private String processClasspathDefaults(String javaArgs) {
 335         if (javaArgs.indexOf("-classpath ") == -1) {
 336             StringBuilder munged = new StringBuilder(javaArgs);
 337             SearchPath classpath = classManager.getClassPath();
 338             if (classpath.isEmpty()) {
 339                 String envcp = System.getProperty("env.class.path");
 340                 if ((envcp != null) && (envcp.length() > 0)) {
 341                     munged.append(" -classpath ").append(envcp);
 342                 }
 343             } else {
 344                 munged.append(" -classpath ").append(classpath.asString());
 345             }
 346             return munged.toString();
 347         } else {
 348             return javaArgs;
 349         }
 350     }
 351 
 352 }