();
// Sockets for communicating with PDA debugger
+ @ThreadSafe
private Socket fRequestSocket;
+ @ThreadSafe
private PrintWriter fRequestWriter;
+ @ThreadSafe
private BufferedReader fRequestReader;
+ @ThreadSafe
private Socket fEventSocket;
+ @ThreadSafe
private BufferedReader fEventReader;
// Jobs servicing the sockets.
private EventDispatchJob fEventDispatchJob;
- private CommandSendJob fRequestJob;
+ private CommandSendJob fCommandSendJob;
/**
* Command control constructor.
@@ -170,8 +175,8 @@ public class PDACommandControl extends AbstractDsfService implements ICommandCon
fEventDispatchJob = new EventDispatchJob();
fEventDispatchJob.schedule();
- fRequestJob = new CommandSendJob();
- fRequestJob.schedule();
+ fCommandSendJob = new CommandSendJob();
+ fCommandSendJob.schedule();
socketsInitializeRm.done();
} catch (UnknownHostException e) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDACommandControl.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDACommandControl.java.html
new file mode 100644
index 00000000000..556bfa472ed
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDACommandControl.java.html
@@ -0,0 +1,547 @@
+
+
+
+PDACommandControl.java
+
+
+
+
+
+ 1: package org.eclipse.dd.examples.pda.service;
+
+ 3: import java.io.BufferedReader;
+ 4: import java.io.IOException;
+ 5: import java.io.InputStreamReader;
+ 6: import java.io.PrintWriter;
+ 7: import java.net.Socket;
+ 8: import java.net.UnknownHostException;
+ 9: import java.util.ArrayList;
+ 10: import java.util.Hashtable;
+ 11: import java.util.Iterator;
+ 12: import java.util.LinkedList;
+ 13: import java.util.List;
+ 14: import java.util.concurrent.BlockingQueue;
+ 15: import java.util.concurrent.LinkedBlockingQueue;
+ 16: import java.util.concurrent.RejectedExecutionException;
+
+ 18: import org.eclipse.core.runtime.IProgressMonitor;
+ 19: import org.eclipse.core.runtime.IStatus;
+ 20: import org.eclipse.core.runtime.Status;
+ 21: import org.eclipse.core.runtime.jobs.Job;
+ 22: import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
+ 23: import org.eclipse.dd.dsf.concurrent.DsfRunnable;
+ 24: import org.eclipse.dd.dsf.concurrent.RequestMonitor;
+ 25: import org.eclipse.dd.dsf.concurrent.ThreadSafe;
+ 26: import org.eclipse.dd.dsf.debug.service.command.ICommand;
+ 27: import org.eclipse.dd.dsf.debug.service.command.ICommandControl;
+ 28: import org.eclipse.dd.dsf.debug.service.command.ICommandListener;
+ 29: import org.eclipse.dd.dsf.debug.service.command.ICommandResult;
+ 30: import org.eclipse.dd.dsf.debug.service.command.IEventListener;
+ 31: import org.eclipse.dd.dsf.service.AbstractDsfService;
+ 32: import org.eclipse.dd.dsf.service.DsfSession;
+ 33: import org.eclipse.dd.examples.pda.PDAPlugin;
+ 34: import org.eclipse.dd.examples.pda.service.commands.AbstractPDACommand;
+ 35: import org.eclipse.dd.examples.pda.service.commands.PDACommandResult;
+ 36: import org.eclipse.dd.examples.pda.service.commands.PDAExitCommand;
+ 37: import org.osgi.framework.BundleContext;
+
+
+ 40: /**
+ 41: * Service that handles communication with a PDA debugger back end.
+ 42: */
+ 43: public class PDACommandControl extends AbstractDsfService implements ICommandControl {
+
+ 45: // Structure used to store command information in services internal queues.
+ 46: private static class CommandHandle {
+ 47: final private AbstractPDACommand<PDACommandResult> fCommand;
+ 48: final private DataRequestMonitor<PDACommandResult> fRequestMonitor;
+ 49:
+ 50: CommandHandle(AbstractPDACommand<PDACommandResult> c, DataRequestMonitor<PDACommandResult> rm) {
+ 51: fCommand = c;
+ 52: fRequestMonitor = rm;
+ 53: }
+ 54: }
+
+ 56: // Parameters that the command control is created with.
+ 57: final private String fProgram;
+ 58: final private int fRequestPort;
+ 59: final private int fEventPort;
+
+ 61: // Queue of commands waiting to be sent to the debugger. As long as commands
+ 62: // are in this queue, they can still be removed by clients.
+ 63: private final List<CommandHandle> fCommandQueue = new LinkedList<CommandHandle>();
+ 64:
+ 65: // Queue of commands that are being sent to the debugger. This queue is read
+ 66: // by the send job, so as soon as commands are inserted into this queue, they can
+ 67: // be considered as sent.
+ 68: @ThreadSafe
+ 69: private final BlockingQueue<CommandHandle> fTxCommands = new LinkedBlockingQueue<CommandHandle>();
+ 70:
+ 71: // Flag indicating that the PDA debugger started
+ 72: private boolean fStarted = false;
+ 73:
+ 74: // Flag indicating that the PDA debugger has been disconnected
+ 75: @ThreadSafe
+ 76: private boolean fTerminated = false;
+ 77:
+ 78: // Data Model context of this command control.
+ 79: private PDAProgramDMContext fDMContext;
+
+ 81: // Synchronous listeners for commands and events.
+ 82: private final List<ICommandListener> fCommandListeners = new ArrayList<ICommandListener>();
+ 83: private final List<IEventListener> fEventListeners = new ArrayList<IEventListener>();
+ 84:
+ 85: // Sockets for communicating with PDA debugger
+ 86: @ThreadSafe
+ 87: private Socket fRequestSocket;
+ 88: @ThreadSafe
+ 89: private PrintWriter fRequestWriter;
+ 90: @ThreadSafe
+ 91: private BufferedReader fRequestReader;
+ 92: @ThreadSafe
+ 93: private Socket fEventSocket;
+ 94: @ThreadSafe
+ 95: private BufferedReader fEventReader;
+
+ 97: // Jobs servicing the sockets.
+ 98: private EventDispatchJob fEventDispatchJob;
+ 99: private CommandSendJob fCommandSendJob;
+100:
+101: /**
+102: * Command control constructor.
+103: * @param session The DSF session that this service is a part of.
+104: * @param requestPort Port number for sending PDA commands.
+105: * @param eventPort Port for listening to PDA events.
+106: */
+107: public PDACommandControl(DsfSession session, String program, int requestPort, int eventPort) {
+108: super(session);
+109: fProgram = program;
+110: fRequestPort = requestPort;
+111: fEventPort = eventPort;
+112: }
+113:
+114: @Override
+115: public void initialize(final RequestMonitor rm) {
+116: // Call the super-class to perform initialization first.
+117: super.initialize( new RequestMonitor(getExecutor(), rm) {
+118: @Override
+119: protected void handleOK() {
+120: doInitialize(rm);
+121: }
+122: });
+123: }
+
+125: private void doInitialize(final RequestMonitor rm) {
+126: // Create the control's data model context.
+127: fDMContext = new PDAProgramDMContext(getSession().getId(), fProgram);
+
+129: // Add a listener for PDA events to track the started/terminated state.
+130: addEventListener(new IEventListener() {
+131: public void eventReceived(Object output) {
+132: if ("started".equals(output)) {
+133: setStarted();
+134: } else if ("terminated".equals(output)) {
+135: setTerminated();
+136: }
+137: }
+138: });
+139:
+140: // Request monitor that will be invoked when the socket initialization is
+141: // completed.
+142: final RequestMonitor socketsInitializeRm = new RequestMonitor(getExecutor(), rm) {
+143: @Override
+144: protected void handleOK() {
+145: // Register the service with OSGi as the last step in initialization of
+146: // the service.
+147: register(
+148: new String[]{ ICommandControl.class.getName(), PDACommandControl.class.getName() },
+149: new Hashtable<String,String>());
+150: rm.done();
+151: }
+152: };
+153:
+154: // To avoid blocking the DSF dispatch thread use a job to initialize communication sockets.
+155: new Job("PDA Initialize") {
+156: @Override
+157: protected IStatus run(IProgressMonitor monitor) {
+158: try {
+159: // give interpreter a chance to start
+160: try {
+161: Thread.sleep(1000);
+162: } catch (InterruptedException e) {
+163: }
+164: fRequestSocket = new Socket("localhost", fRequestPort);
+165: fRequestWriter = new PrintWriter(fRequestSocket.getOutputStream());
+166: fRequestReader = new BufferedReader(new InputStreamReader(fRequestSocket.getInputStream()));
+167: // give interpreter a chance to open next socket
+168: try {
+169: Thread.sleep(1000);
+170: } catch (InterruptedException e) {
+171: }
+172: fEventSocket = new Socket("localhost", fEventPort);
+173: fEventReader = new BufferedReader(new InputStreamReader(fEventSocket.getInputStream()));
+
+175: fEventDispatchJob = new EventDispatchJob();
+176: fEventDispatchJob.schedule();
+177:
+178: fCommandSendJob = new CommandSendJob();
+179: fCommandSendJob.schedule();
+
+181: socketsInitializeRm.done();
+182: } catch (UnknownHostException e) {
+183: socketsInitializeRm.setStatus(new Status(
+184: IStatus.ERROR, PDAPlugin.PLUGIN_ID, REQUEST_FAILED, "Unable to connect to PDA VM", e));
+185: socketsInitializeRm.done();
+186: } catch (IOException e) {
+187: socketsInitializeRm.setStatus(new Status(
+188: IStatus.ERROR, PDAPlugin.PLUGIN_ID, REQUEST_FAILED, "Unable to connect to PDA VM", e));
+189: socketsInitializeRm.done();
+190: }
+191: return Status.OK_STATUS;
+192: }
+193: }.schedule();
+194: }
+
+196: @Override
+197: public void shutdown(final RequestMonitor requestMonitor) {
+198: // Unregister the service first, so that clients may no longer gain access to it.
+199: unregister();
+200:
+201: if (!isTerminated()) {
+202: // If the debugger is still connected, send it the exit command.
+203: terminate(new RequestMonitor(getExecutor(), requestMonitor) {
+204: @Override
+205: protected void handleCompleted() {
+206: // Mark the command control as terminated.
+207: setTerminated();
+
+209: // Ignore any error resulting from the exit command.
+210: // Errors will most likely result if the PDA process is
+211: // already terminated.
+212: requestMonitor.done();
+213: }
+214: });
+215: } else {
+216: requestMonitor.done();
+217: }
+218: }
+
+220: @Override
+221: protected BundleContext getBundleContext() {
+222: return PDAPlugin.getBundleContext();
+223: }
+224:
+225: /**
+226: * Job that services the send command queue.
+227: */
+228: private class CommandSendJob extends Job {
+229: CommandSendJob() {
+230: super("PDA Command Send");
+231: setSystem(true);
+232: }
+233:
+234: @Override
+235: protected IStatus run(IProgressMonitor monitor) {
+236: while (!isTerminated()) {
+237: synchronized(fTxCommands) {
+238: try {
+239: // Remove comamnd from send queue.
+240: final CommandHandle commandHandle = fTxCommands.take();
+241:
+242: // Send the request to PDA
+243: fRequestWriter.println(commandHandle.fCommand.getRequest());
+244: fRequestWriter.flush();
+245:
+246: try {
+247: // wait for reply
+248: final String response = fRequestReader.readLine();
+249:
+250: // Process the reply in the executor thread.
+251: try {
+252: getExecutor().execute(new DsfRunnable() {
+253: public void run() {
+254: processCommandDone(commandHandle, response);
+255: }
+256: });
+257: } catch (RejectedExecutionException e) {
+258: // Acceptable race condition may see the session shut down
+259: // while we're waiting for command response. Still complete
+260: // the request monitor.
+261: assert isTerminated();
+262: assert isTerminated();
+263: PDAPlugin.failRequest(commandHandle.fRequestMonitor, REQUEST_FAILED, "Command control shut down.");
+264: }
+265: } catch (final IOException e) {
+266: // Process error it in the executor thread
+267: try {
+268: getExecutor().execute(new DsfRunnable() {
+269: public void run() {
+270: processCommandException(commandHandle, e);
+271: }
+272: });
+273: } catch (RejectedExecutionException re) {
+274: // Acceptable race condition... see above
+275: assert isTerminated();
+276: PDAPlugin.failRequest(commandHandle.fRequestMonitor, REQUEST_FAILED, "Command control shut down.");
+277: }
+278: }
+279: } catch (InterruptedException e) {
+280: break; // Shutting down.
+281: }
+282: }
+283: }
+284: return Status.OK_STATUS;
+285: }
+286:
+287: }
+288:
+289: /**
+290: * Job that services the PDA event socket.
+291: */
+292: class EventDispatchJob extends Job {
+293:
+294: public EventDispatchJob() {
+295: super("PDA Event Listner");
+296: setSystem(true);
+297: }
+
+299: @Override
+300: protected IStatus run(IProgressMonitor monitor) {
+301: while (!isTerminated()) {
+302: try {
+303: // Wait for an event.
+304: final String event = fEventReader.readLine();
+305: if (event != null) {
+306: try {
+307: // Process the event in executor thread.
+308: getExecutor().execute(new DsfRunnable() {
+309: public void run() {
+310: processEventReceived(event);
+311: }
+312: });
+313: } catch (RejectedExecutionException e) {}
+314: } else {
+315: break;
+316: }
+317: } catch (IOException e) {
+318: break;
+319: }
+320: }
+321: if (!isTerminated()) {
+322: // Exception from the event socket is an indicator that the PDA debugger
+323: // has exited. Call setTerminated() in executor thread.
+324: try {
+325: getExecutor().execute(new DsfRunnable() {
+326: public void run() {
+327: setTerminated();
+328: }
+329: });
+330: } catch (RejectedExecutionException e) {}
+331: }
+332: return Status.OK_STATUS;
+333: }
+334:
+335: }
+336:
+337: public <V extends ICommandResult> void queueCommand(ICommand<V> command, DataRequestMonitor<V> rm) {
+338: if (command instanceof AbstractPDACommand<?>) {
+339: // Cast from command with "<V extends ICommandResult>" to a more concrete
+340: // type to use internally in the command control.
+341: @SuppressWarnings("unchecked")
+342: AbstractPDACommand<PDACommandResult> pdaCommand = (AbstractPDACommand<PDACommandResult>)command;
+343:
+344: // Similarly, cast the request monitor to a more concrete type.
+345: @SuppressWarnings("unchecked")
+346: DataRequestMonitor<PDACommandResult> pdaRM = (DataRequestMonitor<PDACommandResult>)rm;
+
+348: // Add the command to the queue and notify command listeners.
+349: fCommandQueue.add( new CommandHandle(pdaCommand, pdaRM) );
+350: for (ICommandListener listener : fCommandListeners) {
+351: listener.commandQueued(command);
+352: }
+353:
+354: // In a separate dispatch cycle. This allows command listeners to repond to the
+355: // command queued event.
+356: getExecutor().execute(new DsfRunnable() {
+357: public void run() {
+358: processQueues();
+359: }
+360: });
+361:
+362: } else {
+363: PDAPlugin.failRequest(rm, INTERNAL_ERROR, "Unrecognized command: " + command);
+364: }
+365: }
+
+367: public void cancelCommand(ICommand<? extends ICommandResult> command) {
+368: // This debugger is unable of canceling commands once they have
+369: // been sent.
+370: }
+
+372: public void removeCommand(ICommand<? extends ICommandResult> command) {
+373: // Removes given command from the queue and notify the listeners
+374: for (Iterator<CommandHandle> itr = fCommandQueue.iterator(); itr.hasNext();) {
+375: CommandHandle handle = itr.next();
+376: if (command.equals(handle.fCommand)) {
+377: itr.remove();
+378: for (ICommandListener listener : fCommandListeners) {
+379: listener.commandRemoved(command);
+380: }
+381: }
+382: }
+383: }
+384:
+385: public void addCommandListener(ICommandListener processor) {
+386: fCommandListeners.add(processor);
+387: }
+388:
+389: public void removeCommandListener(ICommandListener processor) {
+390: fCommandListeners.remove(processor);
+391: }
+392:
+393: public void addEventListener(IEventListener processor) {
+394: fEventListeners.add(processor);
+395: }
+396:
+397: public void removeEventListener(IEventListener processor) {
+398: fEventListeners.remove(processor);
+399: }
+
+401: private void processCommandDone(CommandHandle handle, String response) {
+402: // Trace to debug output.
+403: PDAPlugin.debug("R: " + response);
+404:
+405: // Given the PDA response string, create the result using the command
+406: // that was sent.
+407: PDACommandResult result = handle.fCommand.createResult(response);
+408:
+409: // Set the result to the request monitor and return to sender.
+410: // Note: as long as PDA sends some response, a PDA command will never
+411: // return an error.
+412: handle.fRequestMonitor.setData(result);
+413: handle.fRequestMonitor.done();
+
+415: // Notify listeners of the response
+416: for (ICommandListener listener : fCommandListeners) {
+417: listener.commandDone(handle.fCommand, result);
+418: }
+419:
+420: // Process next command in queue.
+421: processQueues();
+422: }
+
+424:
+425: private void processCommandException(CommandHandle handle, Throwable exception) {
+426:
+427: // If sending a command resulted in an exception, notify the client.
+428: handle.fRequestMonitor.setStatus(new Status(
+429: IStatus.ERROR, PDAPlugin.PLUGIN_ID, REQUEST_FAILED, "Exception reading request response", exception));
+430: handle.fRequestMonitor.done();
+
+432: // Notify listeners also.
+433: for (ICommandListener listener : fCommandListeners) {
+434: listener.commandDone(handle.fCommand, null);
+435: }
+436: }
+
+438: private void processEventReceived(String event) {
+439: // Notify the listeners only.
+440: PDAPlugin.debug("E: " + event);
+441: for (IEventListener listener : fEventListeners) {
+442: listener.eventReceived(event);
+443: }
+444: }
+445:
+446: private synchronized void processQueues() {
+447: if (isTerminated()) {
+448: // If the PDA debugger is terminated. Return all submitted commands
+449: // with an error.
+450: for (CommandHandle handle : fCommandQueue) {
+451: handle.fRequestMonitor.setStatus(new Status(
+452: IStatus.ERROR, PDAPlugin.PLUGIN_ID, INVALID_STATE, "Command control is terminated", null));
+453: handle.fRequestMonitor.done();
+454: }
+455: fCommandQueue.clear();
+456: } else if (fStarted && fTxCommands.isEmpty() && !fCommandQueue.isEmpty()) {
+457: // Process the queues if:
+458: // - the PDA debugger has started,
+459: // - there are no pending commands in the send queue,
+460: // - and there are commands waiting to be sent.
+461: CommandHandle handle = fCommandQueue.remove(0);
+462: fTxCommands.add(handle);
+463: PDAPlugin.debug("C: " + handle.fCommand.getRequest());
+464: for (ICommandListener listener : fCommandListeners) {
+465: listener.commandSent(handle.fCommand);
+466: }
+467: }
+468: }
+469:
+470: /**
+471: * Return the PDA Debugger top-level Data Model context.
+472: * @see PDAProgramDMContext
+473: */
+474: @ThreadSafe
+475: public PDAProgramDMContext getProgramDMContext() {
+476: return fDMContext;
+477: }
+
+479: private void setStarted() {
+480: // Mark the command control as started and ready to process commands.
+481: fStarted = true;
+482:
+483: // Process any commands which may have been queued before the
+484: processQueues();
+
+486: // Issue a data model event.
+487: getSession().dispatchEvent(new PDAStartedEvent(getProgramDMContext()), getProperties());
+488: }
+489:
+490: /**
+491: * Returns whether the PDA debugger has started and is processing commands.
+492: */
+493: public boolean isStarted() {
+494: return fStarted;
+495: }
+496:
+497: @ThreadSafe
+498: private synchronized void setTerminated() {
+499: // Set terminated may be called more than once: by event listener thread,
+500: // by the terminate command, etc, so protect against sending events multiple
+501: // times.
+502: if (!fTerminated) {
+503: fTerminated = true;
+504:
+505: // Process any waiting commands, they all should return with an error.
+506: processQueues();
+507:
+508: // Issue a data model event.
+509: getSession().dispatchEvent(new PDATerminatedEvent(getProgramDMContext()), getProperties());
+510: }
+511: }
+
+513: /**
+514: * Returns whether the PDA debugger has been terminated.
+515: */
+516: @ThreadSafe
+517: public synchronized boolean isTerminated() {
+518: return fTerminated;
+519: }
+
+521: /**
+522: * Sends a command to PDA debugger to terminate.
+523: */
+524: public void terminate(RequestMonitor rm) {
+525: if (!isTerminated()) {
+526: queueCommand(
+527: new PDAExitCommand(fDMContext),
+528: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm));
+529: } else {
+530: // If already terminated, indicate success.
+531: rm.done();
+532: }
+533: }
+534: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAExpressions.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAExpressions.java.html
new file mode 100644
index 00000000000..8292629dd69
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAExpressions.java.html
@@ -0,0 +1,386 @@
+
+
+
+PDAExpressions.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2008 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: *******************************************************************************/
+ 11: package org.eclipse.dd.examples.pda.service;
+
+ 13: import java.util.Hashtable;
+ 14: import java.util.Map;
+
+ 16: import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
+ 17: import org.eclipse.dd.dsf.concurrent.Immutable;
+ 18: import org.eclipse.dd.dsf.concurrent.RequestMonitor;
+ 19: import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
+ 20: import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
+ 21: import org.eclipse.dd.dsf.datamodel.DMContexts;
+ 22: import org.eclipse.dd.dsf.datamodel.IDMContext;
+ 23: import org.eclipse.dd.dsf.debug.service.IExpressions;
+ 24: import org.eclipse.dd.dsf.debug.service.IStack;
+ 25: import org.eclipse.dd.dsf.debug.service.IRegisters.IRegisterDMContext;
+ 26: import org.eclipse.dd.dsf.debug.service.IRunControl.IResumedDMEvent;
+ 27: import org.eclipse.dd.dsf.debug.service.IRunControl.ISuspendedDMEvent;
+ 28: import org.eclipse.dd.dsf.debug.service.IRunControl.StateChangeReason;
+ 29: import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;
+ 30: import org.eclipse.dd.dsf.debug.service.command.CommandCache;
+ 31: import org.eclipse.dd.dsf.service.AbstractDsfService;
+ 32: import org.eclipse.dd.dsf.service.DsfServiceEventHandler;
+ 33: import org.eclipse.dd.dsf.service.DsfSession;
+ 34: import org.eclipse.dd.examples.pda.PDAPlugin;
+ 35: import org.eclipse.dd.examples.pda.service.commands.PDACommandResult;
+ 36: import org.eclipse.dd.examples.pda.service.commands.PDASetVarCommand;
+ 37: import org.eclipse.dd.examples.pda.service.commands.PDAVarCommand;
+ 38: import org.osgi.framework.BundleContext;
+
+ 40: /**
+ 41: *
+ 42: */
+ 43: public class PDAExpressions extends AbstractDsfService implements IExpressions {
+
+ 45: @Immutable
+ 46: private static class ExpressionDMContext extends AbstractDMContext implements IExpressionDMContext {
+
+ 48: final private String fExpression;
+ 49:
+ 50: ExpressionDMContext(String sessionId, IFrameDMContext frameDmc, String expressin) {
+ 51: super(sessionId, new IDMContext[] { frameDmc });
+ 52: fExpression = expressin;
+ 53: }
+
+ 55: public String getExpression() {
+ 56: return fExpression;
+ 57: }
+ 58:
+ 59: @Override
+ 60: public boolean equals(Object other) {
+ 61: return super.baseEquals(other) && ((ExpressionDMContext)other).fExpression.equals(fExpression);
+ 62: }
+ 63:
+ 64: @Override
+ 65: public int hashCode() {
+ 66: return super.baseHashCode() + fExpression.hashCode();
+ 67: }
+ 68:
+ 69: @Override
+ 70: public String toString() {
+ 71: return baseToString() + ".expression(" + fExpression + ")";
+ 72: }
+ 73: }
+
+ 75: /**
+ 76: * PDA expressions are simply variables. Only the variable name
+ 77: * is relevant for its data.
+ 78: */
+ 79: @Immutable
+ 80: private static class ExpressionDMData implements IExpressionDMData {
+
+ 82: final private String fExpression;
+ 83:
+ 84: public ExpressionDMData(String expression) {
+ 85: fExpression = expression;
+ 86: }
+ 87:
+ 88: public BasicType getBasicType() {
+ 89: return BasicType.basic;
+ 90: }
+
+ 92: public String getEncoding() {
+ 93: return null;
+ 94: }
+
+ 96: public Map<String, Integer> getEnumerations() {
+ 97: return null;
+ 98: }
+
+100: public String getName() {
+101: return fExpression;
+102: }
+
+104: public IRegisterDMContext getRegister() {
+105: return null;
+106: }
+
+108: public String getStringValue() {
+109: return null;
+110: }
+
+112: public String getTypeId() {
+113: return null;
+114: }
+
+116: public String getTypeName() {
+117: return null;
+118: }
+
+120: }
+
+122: // @see #createExpression()
+123: @Immutable
+124: private static class InvalidExpressionDMContext extends AbstractDMContext implements IExpressionDMContext {
+125: final private String fExpression;
+126:
+127: public InvalidExpressionDMContext(String sessionId, IDMContext parent, String expr) {
+128: super(sessionId, new IDMContext[] { parent });
+129: fExpression = expr;
+130: }
+131:
+132: @Override
+133: public boolean equals(Object other) {
+134: return super.baseEquals(other) &&
+135: fExpression == null
+136: ? ((InvalidExpressionDMContext) other).getExpression() == null
+137: : fExpression.equals(((InvalidExpressionDMContext) other).getExpression());
+138: }
+139:
+140: @Override
+141: public int hashCode() {
+142: return fExpression == null ? super.baseHashCode() : super.baseHashCode() ^ fExpression.hashCode();
+143: }
+144:
+145: @Override
+146: public String toString() {
+147: return baseToString() + ".invalid_expr[" + fExpression + "]";
+148: }
+149:
+150: public String getExpression() {
+151: return fExpression;
+152: }
+153: }
+154:
+155: @Immutable
+156: private static class ExpressionChangedDMEvent extends AbstractDMEvent<IExpressionDMContext>
+157: implements IExpressionChangedDMEvent
+158: {
+159: ExpressionChangedDMEvent(IExpressionDMContext expression) {
+160: super(expression);
+161: }
+162: }
+
+164:
+165: private PDACommandControl fCommandControl;
+166: private IStack fStack;
+
+168: private CommandCache fCommandCache;
+
+170: public PDAExpressions(DsfSession session) {
+171: super(session);
+172: }
+
+174: @Override
+175: protected BundleContext getBundleContext() {
+176: return PDAPlugin.getBundleContext();
+177: }
+
+179: @Override
+180: public void initialize(final RequestMonitor rm) {
+181: super.initialize(
+182: new RequestMonitor(getExecutor(), rm) {
+183: @Override
+184: protected void handleOK() {
+185: doInitialize(rm);
+186: }});
+187: }
+
+189: private void doInitialize(final RequestMonitor rm) {
+190: fCommandControl = getServicesTracker().getService(PDACommandControl.class);
+191: fStack = getServicesTracker().getService(IStack.class);
+192: fCommandCache = new CommandCache(fCommandControl);
+
+194: getSession().addServiceEventListener(this, null);
+195:
+196: register(new String[]{IExpressions.class.getName(), PDAExpressions.class.getName()}, new Hashtable<String,String>());
+197:
+198: rm.done();
+199: }
+
+201: @Override
+202: public void shutdown(final RequestMonitor rm) {
+203: getSession().removeServiceEventListener(this);
+204: fCommandCache.reset();
+205: super.shutdown(rm);
+206: }
+
+208: public void canWriteExpression(IExpressionDMContext expressionContext, DataRequestMonitor<Boolean> rm) {
+209: rm.setData(true);
+210: rm.done();
+211: }
+
+213: public IExpressionDMContext createExpression(IDMContext ctx, String expression) {
+214: // Create an expression based on the given context and string expression.
+215: // The PDA debugger can only evaluate variables as expressions and only
+216: // in context of a frame.
+217: IFrameDMContext frameCtx = DMContexts.getAncestorOfType(ctx, IFrameDMContext.class);
+218: if (frameCtx != null) {
+219: return new ExpressionDMContext(getSession().getId(), frameCtx, expression);
+220: } else {
+221: // If a frame cannot be found in context, return an "invalid"
+222: // expression context, because a null return value is not allowed.
+223: // Evaluating an invalid expression context will always yield an
+224: // error.
+225: return new InvalidExpressionDMContext(getSession().getId(), ctx, expression);
+226: }
+227: }
+
+229: public void getBaseExpressions(IExpressionDMContext exprContext, DataRequestMonitor<IExpressionDMContext[]> rm) {
+230: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Not supported");
+231: }
+
+233: public void getExpressionAddressData(IExpressionDMContext dmc, DataRequestMonitor<IExpressionDMAddress> rm) {
+234: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Not supported");
+235: }
+
+237: public void getExpressionData(final IExpressionDMContext exprCtx, final DataRequestMonitor<IExpressionDMData> rm) {
+238: // Since expression data doesn't contain any more information than the
+239: // context, it doesn't require any debugger commmands.
+240: if (exprCtx instanceof ExpressionDMContext) {
+241: rm.setData(new ExpressionDMData(exprCtx.getExpression()));
+242: rm.done();
+243: } else {
+244: PDAPlugin.failRequest(rm, INVALID_HANDLE, "Invalid expression context " + exprCtx);
+245: }
+246: }
+
+248: public void getSubExpressionCount(IExpressionDMContext exprCtx, DataRequestMonitor<Integer> rm) {
+249: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Not supported");
+250: }
+
+252: public void getSubExpressions(IExpressionDMContext exprCtx, DataRequestMonitor<IExpressionDMContext[]> rm) {
+253: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Not supported");
+254: }
+
+256: public void getSubExpressions(IExpressionDMContext exprCtx, int startIndex, int length,
+257: DataRequestMonitor<IExpressionDMContext[]> rm)
+258: {
+259: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Not supported");
+260: }
+
+262: public void getAvailableFormats(IFormattedDataDMContext dmc, DataRequestMonitor<String[]> rm) {
+263: // PDA debugger doesn't support formatting the expression. Natural
+264: // formatting is the only available option.
+265: rm.setData(new String[] { NATURAL_FORMAT });
+266: rm.done();
+267: }
+
+269: public FormattedValueDMContext getFormattedValueContext(IFormattedDataDMContext exprCtx, String formatId) {
+270: // Creates a context that can be used to retrieve a formatted value.
+271: return new FormattedValueDMContext(this, exprCtx, formatId);
+272: }
+
+274: public void getFormattedExpressionValue(FormattedValueDMContext formattedCtx,
+275: final DataRequestMonitor<FormattedValueDMData> rm)
+276: {
+277: final ExpressionDMContext exprCtx = DMContexts.getAncestorOfType(formattedCtx, ExpressionDMContext.class);
+278: if (exprCtx != null) {
+279: final IFrameDMContext frameCtx = DMContexts.getAncestorOfType(exprCtx, IFrameDMContext.class);
+280:
+281: // First retrieve the stack depth, needed to properly calculate
+282: // the frame index that is used by the PDAVarCommand.
+283: fStack.getStackDepth(
+284: frameCtx, 0,
+285: new DataRequestMonitor<Integer>(getExecutor(), rm) {
+286: @Override
+287: protected void handleOK() {
+288: // Calculate the frame index.
+289: int frameId = getData() - frameCtx.getLevel() - 1;
+290:
+291: // Send the command to evaluate the variable.
+292: fCommandCache.execute(
+293: new PDAVarCommand(fCommandControl.getProgramDMContext(), frameId, exprCtx.getExpression()),
+294: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm) {
+295: @Override
+296: protected void handleOK() {
+297: rm.setData(new FormattedValueDMData(getData().fResponseText));
+298: rm.done();
+299: }
+300: });
+301: }
+302: });
+303: } else {
+304: PDAPlugin.failRequest(rm, INVALID_HANDLE, "Invalid expression context " + formattedCtx);
+305: rm.done();
+306: }
+307: }
+
+309: public void writeExpression(final IExpressionDMContext exprCtx, final String exprValue, String formatId,
+310: final RequestMonitor rm)
+311: {
+312: if (exprCtx instanceof ExpressionDMContext) {
+313: final IFrameDMContext frameCtx = DMContexts.getAncestorOfType(exprCtx, IFrameDMContext.class);
+314:
+315: // Similarly to retrieving the variable, retrieve the
+316: // stack depth first.
+317: fStack.getStackDepth(
+318: frameCtx, 0,
+319: new DataRequestMonitor<Integer>(getExecutor(), rm) {
+320: @Override
+321: protected void handleOK() {
+322: // Calculate the frame index.
+323: int frameId = getData() - frameCtx.getLevel() - 1;
+324:
+325: // Send the "write" command to PDA debugger
+326: fCommandCache.execute(
+327: new PDASetVarCommand(fCommandControl.getProgramDMContext(), frameId, exprCtx.getExpression(), exprValue),
+328: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm) {
+329: @Override
+330: protected void handleOK() {
+331: getSession().dispatchEvent(new ExpressionChangedDMEvent(exprCtx), getProperties());
+332: rm.done();
+333: }
+334: });
+335: }
+336: });
+337: } else {
+338: PDAPlugin.failRequest(rm, INVALID_HANDLE, "Invalid expression context " + exprCtx);
+339: rm.done();
+340: }
+341: }
+
+343: @SuppressWarnings("unchecked")
+344: @Deprecated
+345: public void getModelData(IDMContext dmc, DataRequestMonitor<?> rm) {
+346: if (dmc instanceof IExpressionDMContext) {
+347: getExpressionData((IExpressionDMContext) dmc, (DataRequestMonitor<IExpressionDMData>) rm);
+348: } else if (dmc instanceof FormattedValueDMContext) {
+349: getFormattedExpressionValue((FormattedValueDMContext) dmc, (DataRequestMonitor<FormattedValueDMData>) rm);
+350: } else {
+351: PDAPlugin.failRequest(rm, INVALID_HANDLE, "Unknown DMC type");
+352: rm.done();
+353: }
+354: }
+
+356: @DsfServiceEventHandler
+357: public void eventDispatched(IResumedDMEvent e) {
+358: // Mark the cache as not available, so that data retrieval commands
+359: // will fail. Also reset the cache unless it was a step command.
+360: fCommandCache.setTargetAvailable(false);
+361: if (!e.getReason().equals(StateChangeReason.STEP)) {
+362: fCommandCache.reset();
+363: }
+364: }
+
+
+367: @DsfServiceEventHandler
+368: public void eventDispatched(ISuspendedDMEvent e) {
+369: // Enable sending commands to target and clear the cache.
+370: fCommandCache.setTargetAvailable(true);
+371: fCommandCache.reset();
+372: }
+373: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java
index 62a59002dfa..bf4fbedf66b 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java
@@ -182,7 +182,7 @@ public class PDARunControl extends AbstractDsfService
if (!(output instanceof String)) return;
String event = (String)output;
- // Handle PDA debugger suspende/resumed events and issue the
+ // Handle PDA debugger suspended/resumed events and issue the
// corresponding Data Model events. Do not update the state
// information until we start dispatching the service events.
if (event.startsWith("suspended")) {
@@ -248,6 +248,7 @@ public class PDARunControl extends AbstractDsfService
// If the resume command failed, we no longer
// expect to receive a resumed event.
fResumePending = false;
+ super.handleErrorOrCancel();
}
}
);
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java.html
new file mode 100644
index 00000000000..00690033f51
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDARunControl.java.html
@@ -0,0 +1,330 @@
+
+
+
+PDARunControl.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2006 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: * Ericsson AB - Modified for handling of multiple threads
+ 11: *******************************************************************************/
+ 12: package org.eclipse.dd.examples.pda.service;
+
+ 14: import java.util.Hashtable;
+
+ 16: import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
+ 17: import org.eclipse.dd.dsf.concurrent.Immutable;
+ 18: import org.eclipse.dd.dsf.concurrent.RequestMonitor;
+ 19: import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
+ 20: import org.eclipse.dd.dsf.datamodel.IDMContext;
+ 21: import org.eclipse.dd.dsf.datamodel.IDMEvent;
+ 22: import org.eclipse.dd.dsf.debug.service.IRunControl;
+ 23: import org.eclipse.dd.dsf.debug.service.command.IEventListener;
+ 24: import org.eclipse.dd.dsf.service.AbstractDsfService;
+ 25: import org.eclipse.dd.dsf.service.DsfServiceEventHandler;
+ 26: import org.eclipse.dd.dsf.service.DsfSession;
+ 27: import org.eclipse.dd.dsf.service.IDsfService;
+ 28: import org.eclipse.dd.examples.pda.PDAPlugin;
+ 29: import org.eclipse.dd.examples.pda.service.commands.PDACommandResult;
+ 30: import org.eclipse.dd.examples.pda.service.commands.PDAResumeCommand;
+ 31: import org.eclipse.dd.examples.pda.service.commands.PDAStepCommand;
+ 32: import org.eclipse.dd.examples.pda.service.commands.PDASuspendCommand;
+ 33: import org.osgi.framework.BundleContext;
+
+
+ 36: /**
+ 37: * Service for monitoring and controlling execution state of the DPA
+ 38: * program.
+ 39: * <p>
+ 40: * This service depends on the {@link PDACommandControl} service.
+ 41: * It must be initialized before this service is initialized.
+ 42: * </p>
+ 43: */
+ 44: public class PDARunControl extends AbstractDsfService
+ 45: implements IRunControl, IEventListener
+ 46: {
+ 47: // Implementation note about tracking execution state:
+ 48: // This class implements event handlers for the events that are generated by
+ 49: // this service itself. When the event is dispatched, these handlers will
+ 50: // be called first, before any of the clients. These handlers update the
+ 51: // service's internal state information to make them consistent with the
+ 52: // events being issued. Doing this in the handlers as opposed to when
+ 53: // the events are generated, guarantees that the state of the service will
+ 54: // always be consistent with the events.
+ 55: // The purpose of this pattern is to allow clients that listen to service
+ 56: // events and track service state, to be perfectly in sync with the service
+ 57: // state.
+ 58:
+ 59: @Immutable
+ 60: private static class ExecutionDMData implements IExecutionDMData {
+ 61: private final StateChangeReason fReason;
+ 62: ExecutionDMData(StateChangeReason reason) {
+ 63: fReason = reason;
+ 64: }
+ 65: public StateChangeReason getStateChangeReason() { return fReason; }
+ 66: }
+ 67:
+ 68: @Immutable
+ 69: private static class ResumedEvent extends AbstractDMEvent<IExecutionDMContext>
+ 70: implements IResumedDMEvent
+ 71: {
+ 72: private final String fPDAEvent;
+
+ 74: ResumedEvent(IExecutionDMContext ctx, String pdaEvent) {
+ 75: super(ctx);
+ 76: fPDAEvent = pdaEvent;
+ 77: }
+ 78:
+ 79: public StateChangeReason getReason() {
+ 80: if (fPDAEvent.startsWith("resumed breakpoint") || fPDAEvent.startsWith("suspended watch")) {
+ 81: return StateChangeReason.BREAKPOINT;
+ 82: } else if (fPDAEvent.equals("resumed step") || fPDAEvent.equals("resumed drop")) {
+ 83: return StateChangeReason.STEP;
+ 84: } else if (fPDAEvent.equals("resumed client")) {
+ 85: return StateChangeReason.USER_REQUEST;
+ 86: } else {
+ 87: return StateChangeReason.UNKNOWN;
+ 88: }
+ 89: }
+ 90: }
+ 91:
+ 92: @Immutable
+ 93: private static class SuspendedEvent extends AbstractDMEvent<IExecutionDMContext>
+ 94: implements ISuspendedDMEvent
+ 95: {
+ 96: private final String fPDAEvent;
+ 97:
+ 98: SuspendedEvent(IExecutionDMContext ctx, String pdaEvent) {
+ 99: super(ctx);
+100: fPDAEvent = pdaEvent;
+101: }
+102:
+103: public StateChangeReason getReason() {
+104: if (fPDAEvent.startsWith("suspended breakpoint") || fPDAEvent.startsWith("suspended watch")) {
+105: return StateChangeReason.BREAKPOINT;
+106: } else if (fPDAEvent.equals("suspended step") || fPDAEvent.equals("suspended drop")) {
+107: return StateChangeReason.STEP;
+108: } else if (fPDAEvent.equals("suspended client")) {
+109: return StateChangeReason.USER_REQUEST;
+110: } else {
+111: return StateChangeReason.UNKNOWN;
+112: }
+113: }
+114: }
+
+116: // Services
+117: private PDACommandControl fCommandControl;
+118:
+119: // State flags
+120: private boolean fSuspended = true;
+121: private boolean fResumePending = false;
+122: private boolean fStepping = false;
+123: private StateChangeReason fStateChangeReason;
+124:
+125: public PDARunControl(DsfSession session) {
+126: super(session);
+127: }
+128:
+129: @Override
+130: protected BundleContext getBundleContext() {
+131: return PDAPlugin.getBundleContext();
+132: }
+133:
+134: @Override
+135: public void initialize(final RequestMonitor rm) {
+136: super.initialize(
+137: new RequestMonitor(getExecutor(), rm) {
+138: @Override
+139: protected void handleOK() {
+140: doInitialize(rm);
+141: }});
+142: }
+
+144: private void doInitialize(final RequestMonitor rm) {
+145: fCommandControl = getServicesTracker().getService(PDACommandControl.class);
+
+147: // Add ourselves as a listener to PDA events, to catch suspended/resumed
+148: // events.
+149: fCommandControl.addEventListener(this);
+150:
+151: // Add ourselves as a listener to service events, in order to process
+152: // our own suspended/resumed events.
+153: getSession().addServiceEventListener(this, null);
+154:
+155: // Register the service with OSGi
+156: register(new String[]{IRunControl.class.getName(), PDARunControl.class.getName()}, new Hashtable<String,String>());
+157:
+158: rm.done();
+159: }
+
+161: @Override
+162: public void shutdown(final RequestMonitor rm) {
+163: fCommandControl.removeEventListener(this);
+164: getSession().removeServiceEventListener(this);
+165: super.shutdown(rm);
+166: }
+167:
+168: @Deprecated
+169: @SuppressWarnings("unchecked")
+170: public void getModelData(IDMContext dmc, DataRequestMonitor<?> rm) {
+171: // The getModelData() is deprecated and clients are expected to switch
+172: // to getExecutionData() and other data retrieve methods directly.
+173: // However the UI cache still uses it for now.
+174: if (dmc instanceof IExecutionDMContext) {
+175: getExecutionData((IExecutionDMContext)dmc, (DataRequestMonitor<IExecutionDMData>)rm);
+176: } else {
+177: PDAPlugin.failRequest(rm, INVALID_HANDLE, "Unknown DMC type");
+178: }
+179: }
+180:
+181: public void eventReceived(Object output) {
+182: if (!(output instanceof String)) return;
+183: String event = (String)output;
+184:
+185: // Handle PDA debugger suspended/resumed events and issue the
+186: // corresponding Data Model events. Do not update the state
+187: // information until we start dispatching the service events.
+188: if (event.startsWith("suspended")) {
+189: IDMEvent<?> dmEvent = new SuspendedEvent(fCommandControl.getProgramDMContext(), event);
+190: getSession().dispatchEvent(dmEvent, getProperties());
+191: } else if (event.startsWith("resumed")) {
+192: IDMEvent<?> dmEvent = new ResumedEvent(fCommandControl.getProgramDMContext(), event);
+193: getSession().dispatchEvent(dmEvent, getProperties());
+194: }
+195: }
+196:
+197:
+198: @DsfServiceEventHandler
+199: public void eventDispatched(ResumedEvent e) {
+200: // This service should be the first to receive the ResumedEvent,
+201: // (before any other listeners are called). Here, update the
+202: // service state information based on the the resumed event.
+203: fSuspended = false;
+204: fResumePending = false;
+205: fStateChangeReason = e.getReason();
+206: fStepping = e.getReason().equals(StateChangeReason.STEP);
+207: }
+
+
+210: @DsfServiceEventHandler
+211: public void eventDispatched(SuspendedEvent e) {
+212: // This service should be the first to receive the SuspendedEvent also,
+213: // (before any other listeners are called). Here, update the
+214: // service state information based on the the suspended event.
+215: fStateChangeReason = e.getReason();
+216: fResumePending = false;
+217: fSuspended = true;
+218: fStepping = false;
+219: }
+220:
+221:
+222: public boolean canResume(IExecutionDMContext context) {
+223: return isSuspended(context) && !fResumePending;
+224: }
+
+226: public boolean canSuspend(IExecutionDMContext context) {
+227: return !isSuspended(context);
+228: }
+
+230: public boolean isSuspended(IExecutionDMContext context) {
+231: return fSuspended;
+232: }
+
+234: public boolean isStepping(IExecutionDMContext context) {
+235: return !isSuspended(context) && fStepping;
+236: }
+
+238: public void resume(IExecutionDMContext context, final RequestMonitor rm) {
+239: assert context != null;
+
+241: if (canResume(context)) {
+242: fResumePending = true;
+243: fCommandControl.queueCommand(
+244: new PDAResumeCommand(fCommandControl.getProgramDMContext()),
+245: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm) {
+246: @Override
+247: protected void handleErrorOrCancel() {
+248: // If the resume command failed, we no longer
+249: // expect to receive a resumed event.
+250: fResumePending = false;
+251: }
+252: }
+253: );
+254: }else {
+255: PDAPlugin.failRequest(rm, INVALID_STATE, "Given context: " + context + ", is already running.");
+256: }
+257: }
+258:
+259: public void suspend(IExecutionDMContext context, final RequestMonitor rm){
+260: assert context != null;
+
+262: if (canSuspend(context)) {
+263: fCommandControl.queueCommand(
+264: new PDASuspendCommand(fCommandControl.getProgramDMContext()),
+265: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm));
+266:
+267: } else {
+268: PDAPlugin.failRequest(rm, IDsfService.INVALID_STATE, "Given context: " + context + ", is already suspended.");
+269: }
+270: }
+271:
+272: public boolean canStep(IExecutionDMContext context) {
+273: return canResume(context);
+274: }
+275:
+276: public void step(IExecutionDMContext context, StepType stepType, final RequestMonitor rm) {
+277: assert context != null;
+278:
+279: if (canResume(context)) {
+280: fResumePending = true;
+281: fStepping = true;
+
+283: fCommandControl.queueCommand(
+284: new PDAStepCommand(fCommandControl.getProgramDMContext()),
+285: new DataRequestMonitor<PDACommandResult>(getExecutor(), rm) {
+286: @Override
+287: protected void handleErrorOrCancel() {
+288: // If the step command failed, we no longer
+289: // expect to receive a resumed event.
+290: fResumePending = false;
+291: fStepping = false;
+292: }
+293: });
+
+295: } else {
+296: PDAPlugin.failRequest(rm, INVALID_STATE, "Cannot resume context");
+297: return;
+298: }
+299: }
+
+301: public boolean canInstructionStep(IExecutionDMContext context) {
+302: return false;
+303: }
+304:
+305: public void instructionStep(IExecutionDMContext context, StepType stepType, RequestMonitor rm) {
+306: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Operation not implemented");
+307: }
+
+309: public void getExecutionContexts(final IContainerDMContext containerDmc, final DataRequestMonitor<IExecutionDMContext[]> rm) {
+310: PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Operation not implemented");
+311: }
+312:
+313: public void getExecutionData(IExecutionDMContext dmc, DataRequestMonitor<IExecutionDMData> rm){
+314: rm.setData( new ExecutionDMData(fStateChangeReason) );
+315: rm.done();
+316: }
+317: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java
index f85e2f9e52f..6aa231cc771 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java
@@ -54,24 +54,24 @@ public class PDAStack extends AbstractDsfService implements IStack {
private static class FrameDMContext extends AbstractDMContext implements IFrameDMContext {
final private int fLevel;
-
+
FrameDMContext(String sessionId, IExecutionDMContext execDmc, int level) {
super(sessionId, new IDMContext[] { execDmc });
fLevel = level;
}
public int getLevel() { return fLevel; }
-
+
@Override
public boolean equals(Object other) {
return super.baseEquals(other) && ((FrameDMContext)other).fLevel == fLevel;
}
-
+
@Override
public int hashCode() {
return super.baseHashCode() ^ fLevel;
}
-
+
@Override
public String toString() {
return baseToString() + ".frame[" + fLevel + "]"; //$NON-NLS-1$ //$NON-NLS-2$
@@ -85,11 +85,11 @@ public class PDAStack extends AbstractDsfService implements IStack {
private static class FrameDMData implements IFrameDMData {
final private PDAFrame fFrame;
-
+
FrameDMData(PDAFrame frame) {
fFrame = frame;
}
-
+
public String getFile() {
return fFrame.fFilePath.lastSegment();
}
@@ -118,24 +118,24 @@ public class PDAStack extends AbstractDsfService implements IStack {
private static class VariableDMContext extends AbstractDMContext implements IVariableDMContext {
final private String fVariable;
-
+
VariableDMContext(String sessionId, IFrameDMContext frameCtx, String variable) {
super(sessionId, new IDMContext[] { frameCtx });
fVariable = variable;
- }
-
+ }
+
String getVariable() { return fVariable; }
-
+
@Override
public boolean equals(Object other) {
return super.baseEquals(other) && ((VariableDMContext)other).fVariable.equals(fVariable);
}
-
+
@Override
public int hashCode() {
return super.baseHashCode() + fVariable.hashCode();
}
-
+
@Override
public String toString() {
return baseToString() + ".variable(" + fVariable + ")"; //$NON-NLS-1$ //$NON-NLS-2$
@@ -149,11 +149,11 @@ public class PDAStack extends AbstractDsfService implements IStack {
private static class VariableDMData implements IVariableDMData {
final private String fVariable;
-
+
VariableDMData(String variable) {
fVariable = variable;
}
-
+
public String getName() {
return fVariable;
}
@@ -193,16 +193,16 @@ public class PDAStack extends AbstractDsfService implements IStack {
// Initialize service references that stack service depends on
fCommandControl = getServicesTracker().getService(PDACommandControl.class);
fRunControl = getServicesTracker().getService(IRunControl.class);
-
+
// Create the commands cache
fCommandCache = new CommandCache(fCommandControl);
// Register to listen for run control events, to clear cache accordingly.
getSession().addServiceEventListener(this, null);
-
+
// Register stack service with OSGi
register(new String[]{IStack.class.getName(), PDAStack.class.getName()}, new Hashtable());
-
+
rm.done();
}
@@ -213,7 +213,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
super.shutdown(rm);
}
-
+
public void getArguments(IFrameDMContext frameCtx, DataRequestMonitor rm) {
PDAPlugin.failRequest(rm, IDsfService.NOT_SUPPORTED, "PDA debugger does not support function arguments.");
}
@@ -232,7 +232,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid frame level " + frameCtx);
return;
}
-
+
// Create the frame data object based on the corresponding PDAFrame
rm.setData(new FrameDMData(getData().fFrames[frameId]));
rm.done();
@@ -240,7 +240,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
});
}
-
+
public void getFrames(IDMContext context, final DataRequestMonitor rm) {
// Can only create stack frames for an execution context as a parent,
// however the argument context is a generic context type, so it could
@@ -251,7 +251,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid context " + context);
return;
}
-
+
// Execute the stack command and create the corresponding frame contexts.
fCommandCache.execute(
new PDAStackCommand(fCommandControl.getProgramDMContext()),
@@ -282,7 +282,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
return;
}
PDAFrame pdaFrame = getData().fFrames[frameId];
-
+
// Create variable contexts for all variables in frame.
IVariableDMContext[] variableCtxs = new IVariableDMContext[pdaFrame.fVariables.length];
for (int i = 0; i < pdaFrame.fVariables.length; i++) {
@@ -334,7 +334,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
// The variable data doen't contain a value. So there's no need to
// go to the back end to retrieve it.
String variable = ((VariableDMContext)variableCtx).getVariable();
-
+
rm.setData(new VariableDMData(variable));
rm.done();
}
@@ -359,7 +359,7 @@ public class PDAStack extends AbstractDsfService implements IStack {
PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Unknown context type");
}
}
-
+
@DsfServiceEventHandler
public void eventDispatched(IResumedDMEvent e) {
// Mark the cache as not available, so that stack commands will
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java.html
new file mode 100644
index 00000000000..efa44c42c84
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/PDAStack.java.html
@@ -0,0 +1,393 @@
+
+
+
+PDAStack.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2008 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: *******************************************************************************/
+ 11: package org.eclipse.dd.examples.pda.service;
+
+ 13: import java.util.Hashtable;
+
+ 15: import org.eclipse.cdt.core.IAddress;
+ 16: import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
+ 17: import org.eclipse.dd.dsf.concurrent.Immutable;
+ 18: import org.eclipse.dd.dsf.concurrent.RequestMonitor;
+ 19: import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
+ 20: import org.eclipse.dd.dsf.datamodel.DMContexts;
+ 21: import org.eclipse.dd.dsf.datamodel.IDMContext;
+ 22: import org.eclipse.dd.dsf.debug.service.IRunControl;
+ 23: import org.eclipse.dd.dsf.debug.service.IStack;
+ 24: import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
+ 25: import org.eclipse.dd.dsf.debug.service.IRunControl.IResumedDMEvent;
+ 26: import org.eclipse.dd.dsf.debug.service.IRunControl.ISuspendedDMEvent;
+ 27: import org.eclipse.dd.dsf.debug.service.IRunControl.StateChangeReason;
+ 28: import org.eclipse.dd.dsf.debug.service.command.CommandCache;
+ 29: import org.eclipse.dd.dsf.service.AbstractDsfService;
+ 30: import org.eclipse.dd.dsf.service.DsfServiceEventHandler;
+ 31: import org.eclipse.dd.dsf.service.DsfSession;
+ 32: import org.eclipse.dd.dsf.service.IDsfService;
+ 33: import org.eclipse.dd.examples.pda.PDAPlugin;
+ 34: import org.eclipse.dd.examples.pda.service.commands.PDAFrame;
+ 35: import org.eclipse.dd.examples.pda.service.commands.PDAStackCommand;
+ 36: import org.eclipse.dd.examples.pda.service.commands.PDAStackCommandResult;
+ 37: import org.osgi.framework.BundleContext;
+
+ 39: /**
+ 40: * Service for retrieving PDA debugger stack data.
+ 41: * <p>
+ 42: * This service depends on the {@link PDACommandControl} service and the
+ 43: * {@link IRunControl} service. These services must be initialized before
+ 44: * this service is initialized.
+ 45: * </p>
+ 46: */
+ 47: public class PDAStack extends AbstractDsfService implements IStack {
+
+ 49: /**
+ 50: * PDA stack frame contains only the stack frame level. It is only
+ 51: * used as an index into the frame data returned by the PDA debugger.
+ 52: */
+ 53: @Immutable
+ 54: private static class FrameDMContext extends AbstractDMContext implements IFrameDMContext {
+
+ 56: final private int fLevel;
+
+ 58: FrameDMContext(String sessionId, IExecutionDMContext execDmc, int level) {
+ 59: super(sessionId, new IDMContext[] { execDmc });
+ 60: fLevel = level;
+ 61: }
+
+ 63: public int getLevel() { return fLevel; }
+
+ 65: @Override
+ 66: public boolean equals(Object other) {
+ 67: return super.baseEquals(other) && ((FrameDMContext)other).fLevel == fLevel;
+ 68: }
+
+ 70: @Override
+ 71: public int hashCode() {
+ 72: return super.baseHashCode() ^ fLevel;
+ 73: }
+
+ 75: @Override
+ 76: public String toString() {
+ 77: return baseToString() + ".frame[" + fLevel + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ 78: }
+ 79: }
+
+ 81: /**
+ 82: * Frame data based on the PDAFrame object returned by the PDA debugger.
+ 83: */
+ 84: @Immutable
+ 85: private static class FrameDMData implements IFrameDMData {
+
+ 87: final private PDAFrame fFrame;
+
+ 89: FrameDMData(PDAFrame frame) {
+ 90: fFrame = frame;
+ 91: }
+
+ 93: public String getFile() {
+ 94: return fFrame.fFilePath.lastSegment();
+ 95: }
+
+ 97: public String getFunction() {
+ 98: return fFrame.fFunction;
+ 99: }
+
+101: public int getLine() {
+102: return fFrame.fLine + 1;
+103: }
+
+105: public int getColumn() {
+106: return 0;
+107: }
+
+109: public IAddress getAddress() {
+110: return null;
+111: }
+112: }
+
+114: /**
+115: * Context representing a variable in a given stack frame.
+116: */
+117: @Immutable
+118: private static class VariableDMContext extends AbstractDMContext implements IVariableDMContext {
+
+120: final private String fVariable;
+
+122: VariableDMContext(String sessionId, IFrameDMContext frameCtx, String variable) {
+123: super(sessionId, new IDMContext[] { frameCtx });
+124: fVariable = variable;
+125: }
+
+127: String getVariable() { return fVariable; }
+
+129: @Override
+130: public boolean equals(Object other) {
+131: return super.baseEquals(other) && ((VariableDMContext)other).fVariable.equals(fVariable);
+132: }
+
+134: @Override
+135: public int hashCode() {
+136: return super.baseHashCode() + fVariable.hashCode();
+137: }
+
+139: @Override
+140: public String toString() {
+141: return baseToString() + ".variable(" + fVariable + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+142: }
+143: }
+
+145: /**
+146: * PDA variable data, only supports returning the variable name.
+147: */
+148: @Immutable
+149: private static class VariableDMData implements IVariableDMData {
+
+151: final private String fVariable;
+
+153: VariableDMData(String variable) {
+154: fVariable = variable;
+155: }
+
+157: public String getName() {
+158: return fVariable;
+159: }
+
+161: public String getValue() {
+162: return null;
+163: }
+164: }
+
+166: // Services that this service depends on.
+167: private PDACommandControl fCommandControl;
+168: private IRunControl fRunControl;
+
+170: // Command cache
+171: private CommandCache fCommandCache;
+
+173: public PDAStack(DsfSession session) {
+174: super(session);
+175: }
+
+177: @Override
+178: protected BundleContext getBundleContext() {
+179: return PDAPlugin.getBundleContext();
+180: }
+
+182: @Override
+183: public void initialize(final RequestMonitor rm) {
+184: super.initialize(
+185: new RequestMonitor(getExecutor(), rm) {
+186: @Override
+187: protected void handleOK() {
+188: doInitialize(rm);
+189: }});
+190: }
+
+192: private void doInitialize(final RequestMonitor rm) {
+193: // Initialize service references that stack service depends on
+194: fCommandControl = getServicesTracker().getService(PDACommandControl.class);
+195: fRunControl = getServicesTracker().getService(IRunControl.class);
+
+197: // Create the commands cache
+198: fCommandCache = new CommandCache(fCommandControl);
+
+200: // Register to listen for run control events, to clear cache accordingly.
+201: getSession().addServiceEventListener(this, null);
+
+203: // Register stack service with OSGi
+204: register(new String[]{IStack.class.getName(), PDAStack.class.getName()}, new Hashtable<String,String>());
+
+206: rm.done();
+207: }
+
+209: @Override
+210: public void shutdown(final RequestMonitor rm) {
+211: getSession().removeServiceEventListener(this);
+212: fCommandCache.reset();
+213: super.shutdown(rm);
+214: }
+
+
+217: public void getArguments(IFrameDMContext frameCtx, DataRequestMonitor<IVariableDMContext[]> rm) {
+218: PDAPlugin.failRequest(rm, IDsfService.NOT_SUPPORTED, "PDA debugger does not support function arguments.");
+219: }
+
+221: public void getFrameData(final IFrameDMContext frameCtx, final DataRequestMonitor<IFrameDMData> rm) {
+222: // Execute the PDA stack command, or retrieve the result from cache if already available.
+223: fCommandCache.execute(
+224: new PDAStackCommand(fCommandControl.getProgramDMContext()),
+225: new DataRequestMonitor<PDAStackCommandResult>(getExecutor(), rm) {
+226: @Override
+227: protected void handleOK() {
+228: // PDAFrame array is ordered highest to lowest. We need to
+229: // calculate the index based on frame level.
+230: int frameId = getData().fFrames.length - frameCtx.getLevel() - 1;
+231: if (frameId < 0) {
+232: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid frame level " + frameCtx);
+233: return;
+234: }
+
+236: // Create the frame data object based on the corresponding PDAFrame
+237: rm.setData(new FrameDMData(getData().fFrames[frameId]));
+238: rm.done();
+239: }
+240: });
+241: }
+
+
+244: public void getFrames(IDMContext context, final DataRequestMonitor<IFrameDMContext[]> rm) {
+245: // Can only create stack frames for an execution context as a parent,
+246: // however the argument context is a generic context type, so it could
+247: // be an execution context, a frame, a variable, etc. Search the
+248: // hierarchy of the argument context to find the execution one.
+249: final IExecutionDMContext execCtx = DMContexts.getAncestorOfType(context, IExecutionDMContext.class);
+250: if (execCtx == null) {
+251: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid context " + context);
+252: return;
+253: }
+
+255: // Execute the stack command and create the corresponding frame contexts.
+256: fCommandCache.execute(
+257: new PDAStackCommand(fCommandControl.getProgramDMContext()),
+258: new DataRequestMonitor<PDAStackCommandResult>(getExecutor(), rm) {
+259: @Override
+260: protected void handleOK() {
+261: IFrameDMContext[] frameCtxs = new IFrameDMContext[getData().fFrames.length];
+262: for (int i = 0; i < getData().fFrames.length; i++) {
+263: frameCtxs[i] = new FrameDMContext(getSession().getId(), execCtx, i);
+264: }
+265: rm.setData(frameCtxs);
+266: rm.done();
+267: }
+268: });
+269: }
+
+271: public void getLocals(final IFrameDMContext frameCtx, final DataRequestMonitor<IVariableDMContext[]> rm) {
+272: // Execute the stack command again.
+273: fCommandCache.execute(
+274: new PDAStackCommand(fCommandControl.getProgramDMContext()),
+275: new DataRequestMonitor<PDAStackCommandResult>(getExecutor(), rm) {
+276: @Override
+277: protected void handleOK() {
+278: // Find the correct PDAFrame
+279: int frameId = getData().fFrames.length - frameCtx.getLevel() - 1;
+280: if (frameId < 0) {
+281: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid frame level " + frameCtx);
+282: return;
+283: }
+284: PDAFrame pdaFrame = getData().fFrames[frameId];
+
+286: // Create variable contexts for all variables in frame.
+287: IVariableDMContext[] variableCtxs = new IVariableDMContext[pdaFrame.fVariables.length];
+288: for (int i = 0; i < pdaFrame.fVariables.length; i++) {
+289: variableCtxs[i] = new VariableDMContext(getSession().getId(), frameCtx, pdaFrame.fVariables[i]);
+290: }
+291: rm.setData(variableCtxs);
+292: rm.done();
+293: }
+294: });
+
+296: }
+
+298: public void getStackDepth(IDMContext context, int maxDepth, final DataRequestMonitor<Integer> rm) {
+299: // Execute stack command and return the data's size.
+300: fCommandCache.execute(
+301: new PDAStackCommand(fCommandControl.getProgramDMContext()),
+302: new DataRequestMonitor<PDAStackCommandResult>(getExecutor(), rm) {
+303: @Override
+304: protected void handleOK() {
+305: rm.setData(getData().fFrames.length);
+306: rm.done();
+307: }
+308: });
+309: }
+
+311: public void getTopFrame(IDMContext context, final DataRequestMonitor<IFrameDMContext> rm) {
+312: // Can only create stack frames for an execution context as a parent,
+313: // however the argument context is a generic context type, so it could
+314: // be an execution context, a frame, a variable, etc. Search the
+315: // hierarchy of the argument context to find the execution one.
+316: final IExecutionDMContext execCtx = DMContexts.getAncestorOfType(context, IExecutionDMContext.class);
+317: if (execCtx == null) {
+318: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid context " + context);
+319: return;
+320: }
+
+322: // Since the frame context only contain the level, there's no need to
+323: // call the PDA debugger. Simply create a context for level 0.
+324: rm.setData(new FrameDMContext(getSession().getId(), execCtx, 0));
+325: rm.done();
+326: }
+
+328: public void getVariableData(IVariableDMContext variableCtx, DataRequestMonitor<IVariableDMData> rm) {
+329: if ( !(variableCtx instanceof VariableDMContext) ) {
+330: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Invalid context " + variableCtx);
+331: return;
+332: }
+
+334: // The variable data doen't contain a value. So there's no need to
+335: // go to the back end to retrieve it.
+336: String variable = ((VariableDMContext)variableCtx).getVariable();
+
+338: rm.setData(new VariableDMData(variable));
+339: rm.done();
+340: }
+
+342: public boolean isStackAvailable(IDMContext context) {
+343: // Stack is available if the program is suspended or stepping.
+344: IExecutionDMContext execCtx = DMContexts.getAncestorOfType(context, IExecutionDMContext.class);
+345: return execCtx != null && (fRunControl.isSuspended(execCtx) || (fRunControl.isStepping(execCtx)));
+346: }
+
+348: @SuppressWarnings("unchecked")
+349: @Deprecated
+350: public void getModelData(IDMContext dmc, DataRequestMonitor<?> rm) {
+351: // The getModelData() is deprecated and clients are expected to switch
+352: // to getExecutionData() and other data retrieve methods directly.
+353: // However the UI cache still uses it for now.
+354: if (dmc instanceof IFrameDMContext) {
+355: getFrameData((IFrameDMContext)dmc, (DataRequestMonitor<IFrameDMData>)rm);
+356: } else if (dmc instanceof IVariableDMContext) {
+357: getVariableData((IVariableDMContext)dmc, (DataRequestMonitor<IVariableDMData>)rm);
+358: } else {
+359: PDAPlugin.failRequest(rm, IDsfService.INVALID_HANDLE, "Unknown context type");
+360: }
+361: }
+
+363: @DsfServiceEventHandler
+364: public void eventDispatched(IResumedDMEvent e) {
+365: // Mark the cache as not available, so that stack commands will
+366: // fail. Also reset the cache unless it was a step command.
+367: fCommandCache.setTargetAvailable(false);
+368: if (!e.getReason().equals(StateChangeReason.STEP)) {
+369: fCommandCache.reset();
+370: }
+371: }
+
+
+374: @DsfServiceEventHandler
+375: public void eventDispatched(ISuspendedDMEvent e) {
+376: // Enable sending commands to target and clear the cache.
+377: fCommandCache.setTargetAvailable(true);
+378: fCommandCache.reset();
+379: }
+380: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/AbstractPDACommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/AbstractPDACommand.java
index bd75d996c63..fd73851120c 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/AbstractPDACommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/AbstractPDACommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.dsf.datamodel.IDMContext;
import org.eclipse.dd.dsf.debug.service.command.ICommand;
import org.eclipse.dd.dsf.debug.service.command.ICommandResult;
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* a context. Since the PDA debugger protocol is stateless, the context is only
* needed to satisfy the ICommand interface.
*/
+@Immutable
abstract public class AbstractPDACommand implements ICommand {
final private IDMContext fContext;
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAClearBreakpointCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAClearBreakpointCommand.java
index b0873d3254d..35b9717e3f9 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAClearBreakpointCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAClearBreakpointCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -21,6 +22,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
*
*/
+@Immutable
public class PDAClearBreakpointCommand extends AbstractPDACommand {
public PDAClearBreakpointCommand(PDAProgramDMContext context, int line) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDACommandResult.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDACommandResult.java
index 053f2e99796..16cfe82fd3d 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDACommandResult.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDACommandResult.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.dsf.debug.service.command.ICommand;
import org.eclipse.dd.dsf.debug.service.command.ICommandResult;
@@ -19,6 +20,7 @@ import org.eclipse.dd.dsf.debug.service.command.ICommandResult;
* PDA response. Sub-classes may override to optionally parse the response text
* and return higher-level objects.
*/
+@Immutable
public class PDACommandResult implements ICommandResult {
final public String fResponseText;
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java
index fab0f679ba0..2fa76f1bed4 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,14 +21,15 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: {value 1}|{value 2}|{value 3}|...|
*
*/
-public class PDADataCommand extends AbstractPDACommand {
+@Immutable
+public class PDADataCommand extends AbstractPDACommand {
public PDADataCommand(PDAProgramDMContext context) {
super(context, "data");
}
@Override
- public PDACommandResult createResult(String resultText) {
- return new PDACommandResult(resultText);
+ public PDADataCommandResult createResult(String resultText) {
+ return new PDADataCommandResult(resultText);
}
}
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java.html
new file mode 100644
index 00000000000..311cbceb6b0
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommand.java.html
@@ -0,0 +1,46 @@
+
+
+
+PDADataCommand.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2008 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: *******************************************************************************/
+ 11: package org.eclipse.dd.examples.pda.service.commands;
+
+ 13: import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
+
+ 15: /**
+ 16: * Retrieves data stack information
+ 17: *
+ 18: * <pre>
+ 19: * C: data
+ 20: * R: {value 1}|{value 2}|{value 3}|...|
+ 21: * </pre>
+ 22: */
+ 23: public class PDADataCommand extends AbstractPDACommand<PDADataCommandResult> {
+
+ 25: public PDADataCommand(PDAProgramDMContext context) {
+ 26: super(context, "data");
+ 27: }
+ 28:
+ 29: @Override
+ 30: public PDADataCommandResult createResult(String resultText) {
+ 31: return new PDADataCommandResult(resultText);
+ 32: }
+ 33: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java
index e31b1c8ae58..aff431a7ec6 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java
@@ -14,10 +14,13 @@ import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
+import org.eclipse.dd.dsf.concurrent.Immutable;
+
/**
* @see PDADataCommand
*/
+@Immutable
public class PDADataCommandResult extends PDACommandResult {
final public String[] fValues;
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java.html
new file mode 100644
index 00000000000..b5f3ae2cb46
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADataCommandResult.java.html
@@ -0,0 +1,55 @@
+
+
+
+PDADataCommandResult.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2008 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: *******************************************************************************/
+ 11: package org.eclipse.dd.examples.pda.service.commands;
+
+ 13: import java.util.ArrayList;
+ 14: import java.util.List;
+ 15: import java.util.StringTokenizer;
+
+
+ 18: /**
+ 19: * @see PDADataCommand
+ 20: */
+ 21: public class PDADataCommandResult extends PDACommandResult {
+ 22:
+ 23: final public String[] fValues;
+ 24:
+ 25: PDADataCommandResult(String response) {
+ 26: super(response);
+ 27: StringTokenizer st = new StringTokenizer(response, "|");
+ 28: List<String> valuesList = new ArrayList<String>();
+ 29:
+ 30: while (st.hasMoreTokens()) {
+ 31: String token = st.nextToken();
+ 32: if (token.length() != 0) {
+ 33: valuesList.add(st.nextToken());
+ 34: }
+ 35: }
+ 36:
+ 37: fValues = new String[valuesList.size()];
+ 38: for (int i = 0; i < valuesList.size(); i++) {
+ 39: fValues[i] = valuesList.get(i);
+ 40: }
+ 41: }
+ 42: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADropFrameCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADropFrameCommand.java
index 1a1f4cc8f92..d68c173dd52 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADropFrameCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDADropFrameCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -23,6 +24,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
*
*/
+@Immutable
public class PDADropFrameCommand extends AbstractPDACommand {
public PDADropFrameCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEvalCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEvalCommand.java
index 082362e7415..10a4d707132 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEvalCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEvalCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -25,6 +26,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
*
* Where event_name could be unimpinstr or nosuchlabel.
*/
+@Immutable
public class PDAEvalCommand extends AbstractPDACommand {
public PDAEvalCommand(PDAProgramDMContext context, String operation) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEventStopCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEventStopCommand.java
index 653f2aa945a..d247f829c4b 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEventStopCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAEventStopCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -24,6 +25,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
*
* Where event_name could be unimpinstr or nosuchlabel.
*/
+@Immutable
public class PDAEventStopCommand extends AbstractPDACommand {
public enum Event { UNIMPINSTR, NOSUCHLABEL };
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAExitCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAExitCommand.java
index 0514aa675f5..7b7222b7b27 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAExitCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAExitCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: ok
*
*/
+@Immutable
public class PDAExitCommand extends AbstractPDACommand {
public PDAExitCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAFrame.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAFrame.java
index ab2b2c5612a..5ef52dc542a 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAFrame.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAFrame.java
@@ -16,12 +16,14 @@ import java.util.StringTokenizer;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
+import org.eclipse.dd.dsf.concurrent.Immutable;
/**
* Object representing a frame in the stack command results.
*
* @see PDAStackCommand
*/
+@Immutable
public class PDAFrame {
final public IPath fFilePath;
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPopDataCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPopDataCommand.java
index 952e53cd17c..de6649b785b 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPopDataCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPopDataCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: ok
*
*/
+@Immutable
public class PDAPopDataCommand extends AbstractPDACommand {
public PDAPopDataCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPushDataCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPushDataCommand.java
index 7226c765518..d201e9b05ec 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPushDataCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAPushDataCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: ok
*
*/
+@Immutable
public class PDAPushDataCommand extends AbstractPDACommand {
public PDAPushDataCommand(PDAProgramDMContext context, int value) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java
index 35b83c35a13..6a7e46f1a29 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -21,6 +22,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: resumed client
*
*/
+@Immutable
public class PDAResumeCommand extends AbstractPDACommand {
public PDAResumeCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java.html b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java.html
new file mode 100644
index 00000000000..ae563692a2f
--- /dev/null
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAResumeCommand.java.html
@@ -0,0 +1,47 @@
+
+
+
+PDAResumeCommand.java
+
+
+
+
+
+ 1: /*******************************************************************************
+ 2: * Copyright (c) 2008 Wind River Systems and others.
+ 3: * All rights reserved. This program and the accompanying materials
+ 4: * are made available under the terms of the Eclipse Public License v1.0
+ 5: * which accompanies this distribution, and is available at
+ 6: * http://www.eclipse.org/legal/epl-v10.html
+ 7: *
+ 8: * Contributors:
+ 9: * Wind River Systems - initial API and implementation
+ 10: *******************************************************************************/
+ 11: package org.eclipse.dd.examples.pda.service.commands;
+
+ 13: import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
+
+ 15: /**
+ 16: * Resumes the execution
+ 17: *
+ 18: * <pre>
+ 19: * C: resume
+ 20: * R: ok
+ 21: * E: resumed client
+ 22: * </pre>
+ 23: */
+ 24: public class PDAResumeCommand extends AbstractPDACommand<PDACommandResult> {
+
+ 26: public PDAResumeCommand(PDAProgramDMContext context) {
+ 27: super(context, "resume");
+ 28: }
+ 29:
+ 30: @Override
+ 31: public PDACommandResult createResult(String resultText) {
+ 32: return new PDACommandResult(resultText);
+ 33: }
+ 34: }
+
+
+
+
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetBreakpointCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetBreakpointCommand.java
index 7dd14c6456a..4bfd3370df6 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetBreakpointCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetBreakpointCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -23,6 +24,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: suspended breakpoint line_number
*
*/
+@Immutable
public class PDASetBreakpointCommand extends AbstractPDACommand {
public PDASetBreakpointCommand(PDAProgramDMContext context, int line) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetDataCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetDataCommand.java
index b66772f8688..706700c8f7f 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetDataCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetDataCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: ok
*
*/
+@Immutable
public class PDASetDataCommand extends AbstractPDACommand {
public PDASetDataCommand(PDAProgramDMContext context, int index, String value) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetVarCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetVarCommand.java
index 5fcf7d77b49..f18340e20d4 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetVarCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASetVarCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: ok
*
*/
+@Immutable
public class PDASetVarCommand extends AbstractPDACommand {
public PDASetVarCommand(PDAProgramDMContext context, int frame, String variable, String value) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommand.java
index cd26fa07ff5..aef4d4aa795 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: {file}|{line}|{function}|{var_1}|{var_2}|...#{file}|{line}|{function}|{var_1}|{var_2}|...#...
*
*/
+@Immutable
public class PDAStackCommand extends AbstractPDACommand {
public PDAStackCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommandResult.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommandResult.java
index 5cc1bf1fc71..7bd9877cd19 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommandResult.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStackCommandResult.java
@@ -14,10 +14,13 @@ import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
+import org.eclipse.dd.dsf.concurrent.Immutable;
+
/**
* @see PDAStackCommand
*/
+@Immutable
public class PDAStackCommandResult extends PDACommandResult {
/**
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepCommand.java
index a50713acc8b..ce50cf5c228 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepCommand.java
@@ -10,10 +10,11 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
- * Executes next instruciton
+ * Executes next instruction
*
*
* C: step
@@ -22,6 +23,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: suspended step
*
*/
+@Immutable
public class PDAStepCommand extends AbstractPDACommand {
public PDAStepCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepReturnCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepReturnCommand.java
index 8ba0dedfb3b..8b9d7c8a675 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepReturnCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAStepReturnCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -22,6 +23,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: suspended step
*
*/
+@Immutable
public class PDAStepReturnCommand extends AbstractPDACommand {
public PDAStepReturnCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASuspendCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASuspendCommand.java
index f1c7e548b85..5abde431178 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASuspendCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDASuspendCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -21,6 +22,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: suspended client
*
*/
+@Immutable
public class PDASuspendCommand extends AbstractPDACommand {
public PDASuspendCommand(PDAProgramDMContext context) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAVarCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAVarCommand.java
index 745fa86a491..cc57a527161 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAVarCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAVarCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -20,6 +21,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* R: {variable_value}
*
*/
+@Immutable
public class PDAVarCommand extends AbstractPDACommand {
public PDAVarCommand(PDAProgramDMContext context, int frameId, String name) {
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAWatchCommand.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAWatchCommand.java
index 91d54e942a0..f6bf1982545 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAWatchCommand.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/service/commands/PDAWatchCommand.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.dd.examples.pda.service.commands;
+import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
/**
@@ -23,6 +24,7 @@ import org.eclipse.dd.examples.pda.service.PDAProgramDMContext;
* E: suspended watch {watch_operation} {function}::{variable_name}
*
*/
+@Immutable
public class PDAWatchCommand extends AbstractPDACommand {
public enum WatchOperation { READ, WRITE, BOTH, NONE };
diff --git a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/sourcelookup/PDASourceLookupDirector.java b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/sourcelookup/PDASourceLookupDirector.java
index d22968d6be9..1c7ec8b518f 100644
--- a/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/sourcelookup/PDASourceLookupDirector.java
+++ b/plugins/org.eclipse.dd.examples.pda/src/org/eclipse/dd/examples/pda/sourcelookup/PDASourceLookupDirector.java
@@ -19,7 +19,7 @@ import org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector;
*/
public class PDASourceLookupDirector extends AbstractSourceLookupDirector {
public void initializeParticipants() {
- // No need to add participants here, the surce display adapter will
+ // No need to add participants here, the source display adapter will
// add the participant with the correct session ID.
}
}