How to write a DSF-based debugger

push 6
call Fibonacci      function call with one argument on the data stack
output              print result to stdout
halt
#
# f(n) = f(n-1) + f(n-2)
# f(0) = 1
# f(1) = 1
#
:fibonacci
var n               define variable n on control stack
pop $n              get n from data stack
push $n
branch_not_zero gt0
push 1              f(0) = 1

return              return with one value on data stack
:gt0 
push $n
dec
branch_not_zero gt1
push 1              f(1) = 1
return              return with one value on data stack
:gt1
push $n             stack: n
dec                 stack: n-1
call fibonacci      stack: f(n-1)

push $n             stack: f(n-1) n
dec                 stack: f(n-1) n-1
dec                 stack: f(n-1) n-2
call Fibonacci      stack: f(n-1) f(n-2)
add                 stack: f(n-1)+f(n-2)
return              return with one value on data stack

 51:  public ILaunch getLaunch(ILaunchConfiguration configuration, String mode) throws CoreException {

 52:      // Need to configure the source locator before creating the launch
 53:      // because once the launch is created and added to launch manager,
 54:      // the adapters will be created for the whole session, including 
 55:      // the source lookup adapter.
 56:      ISourceLocator locator = getSourceLocator(configuration);

 58:      return new PDALaunch(configuration, mode, locator);
 59:  }

 65:     public PDALaunch(ILaunchConfiguration launchConfiguration, String mode, ISourceLocator locator) {
 66:         super(launchConfiguration, mode, locator);

 68:         // Create the dispatch queue to be used by debugger control and services 
 69:         // that belong to this launch
 70:         final DefaultDsfExecutor dsfExecutor = new DefaultDsfExecutor(PDAPlugin.ID_PDA_DEBUG_MODEL);
 71:         dsfExecutor.prestartCoreThread();
 72:         fExecutor = dsfExecutor;
 73:         fSession = DsfSession.startSession(fExecutor, PDAPlugin.ID_PDA_DEBUG_MODEL);
 74:     }

 90:     @ConfinedToDsfExecutor("getSession().getExecutor()")
 91:     public void initializeServices(String program, int requestPort, int eventPort, final RequestMonitor rm)
 92:     {
 93:         // Double-check that we're being called in the correct thread.
 94:         assert fExecutor.isInExecutorThread();

 96:         // Check if shutdownServices() was called already, which would be 
 97:         // highly unusual, but if so we don't need to do anything except set 
 98:         // the initialized flag.
 99:         synchronized(this) {
100:             if (fShutDown) {
101:                 fInitialized = true;
102:                 return;
103:             }
104:         }

106:         // Register the launch as listener for services events.
107:         fSession.addServiceEventListener(PDALaunch.this, null);

109:         // The initialization sequence is stored in a field to allow it to be 
110:         // canceled if shutdownServices() is called before the sequence 
111:         // completes.
112:         fInitializationSequence = new PDAServicesInitSequence(
113:             getSession(), program, requestPort, eventPort, 
114:             new RequestMonitor(ImmediateExecutor.getInstance(), rm) {
115:                 @Override
116:                 protected void handleCompleted() {
117:                     // Set the initialized flag and check whether the 
118:                     // shutdown flag is set.  Access the flags in a 
119:                     // synchronized section as these flags can be accessed
120:                     // on any thread.
121:                     boolean doShutdown = false;
122:                     synchronized (this) { 
123:                         fInitialized = true;
124:                         fInitializationSequence = null;
125:                         if (fShutDown) {
126:                             doShutdown = true;
127:                         }
128:                     }

130:                     if (doShutdown) {
131:                         // If shutdownServices() was already called, start the 
132:                         // shutdown sequence now.
133:                         doShutdown(rm);
134:                     } else {
135:                         // If there was an error in the startup sequence, 
136:                         // report the error to the client.
137:                         if (getStatus().getSeverity() == IStatus.ERROR) {
138:                             rm.setStatus(getStatus());
139:                         }
140:                         rm.done();
141:                     }
142:                     fireChanged();
143:                 }
144:             });

146:         // Finally, execute the sequence. 
147:         getSession().getExecutor().execute(fInitializationSequence);
148:     }

202:     @ConfinedToDsfExecutor("getSession().getExecutor()")
203:     public void shutdownServices(final RequestMonitor rm) {
204:         // Check initialize and shutdown flags to determine if the shutdown
205:         // sequence can be called yet.
206:         boolean doShutdown = false;
207:         synchronized (this) {
208:             if (!fInitialized && fInitializationSequence != null) {
209:                 // Launch has not yet initialized, try to cancel the 
210:                 // shutdown sequence.
211:                 fInitializationSequence.cancel(false);
212:             } else {
213:                 doShutdown = !fShutDown && fInitialized;
214:             }
215:             fShutDown = true;
216:         }

218:         if (doShutdown) {
219:             doShutdown(rm);
220:         } else {
221:             rm.done();
222:         }
223:     }

225:     @ConfinedToDsfExecutor("getSession().getExecutor()")
226:     private void doShutdown(final RequestMonitor rm) {
227:         fExecutor.execute( new PDAServicesShutdownSequence(
228:             fExecutor, fSession.getId(),
229:             new RequestMonitor(fSession.getExecutor(), rm) { 
230:                 @Override
231:                 public void handleCompleted() {
232:                     fSession.removeServiceEventListener(PDALaunch.this);
233:                     if (!getStatus().isOK()) {
234:                         PDAPlugin.getDefault().getLog().log(new MultiStatus(
235:                             PDAPlugin.PLUGIN_ID, -1, new IStatus[]{getStatus()}, "Session shutdown failed", null)); //$NON-NLS-1$
236:                     }
237:                     // Last order of business, shutdown the dispatch queue.
238:                     DsfSession.endSession(fSession);
239:                     // endSession takes a full dispatch to distribute the 
240:                     // session-ended event, finish step only after the dispatch.
241:                     fExecutor.shutdown();
242:                     fireTerminate();

244:                     rm.setStatus(getStatus());
245:                     rm.done();
246:                 }
247:             }) );
248:     }

 38:     Step[] fSteps = new Step[] {
 39:         new Step() 
 40:         { 
 41:             @Override
 42:             public void execute(RequestMonitor requestMonitor) {
 43:                 // Create the connection to PDA debugger.
 44:                 fCommandControl = new PDACommandControl(fSession, fProgram, fRequestPort, fEventPort);
 45:                 fCommandControl.initialize(requestMonitor);
 46:             }
 47:         },
 48:         new Step() { 
 49:             @Override
 50:             public void execute(RequestMonitor requestMonitor) {
 51:                 // Start the run control service.
 52:                 fRunControl = new PDARunControl(fSession);
 53:                 fRunControl.initialize(requestMonitor);
 54:             }
 55:         },
 56:         new Step() { 
 57:             @Override
 58:             public void execute(RequestMonitor requestMonitor) {
 59:                 // Start the service to manage step actions.
 60:                 new StepQueueManager(fSession).initialize(requestMonitor);
 61:             }
 62:         },
 ...

 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;

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:     }

 15: /**
 16:  * Retrieves data stack information 
 17:  * 
 18:  * <pre>
 19:  *    C: data
 20:  *    R: {value 1}|{value 2}|{value 3}|...|
 21:  * </pre>
 22:  */
 23: @Immutable
 24: public class PDADataCommand extends AbstractPDACommand<PDADataCommandResult> {
 25:
 26:     public PDADataCommand(PDAProgramDMContext context) {
 27:         super(context, "data");
 28:     }
 29:     
 30:     @Override
 31:     public PDADataCommandResult createResult(String resultText) {
 32:         return new PDADataCommandResult(resultText);
 33:     }
 34: }

 20: @Immutable
 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: }

   <extension
         point="org.eclipse.core.runtime.adapters">
      <factory
            class="org.eclipse.dd.examples.pda.ui.PDAAdapterFactory"
            adaptableType="org.eclipse.dd.examples.pda.launch.PDALaunch">
         <adapter type="org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider"/>
         <adapter type="org.eclipse.debug.internal.ui.viewers.model.provisional.IModelProxyFactory"/>
      </factory>
   </extension>

157:     public Object getAdapter(Object adaptableObject, Class adapterType) {
158:         if (!(adaptableObject instanceof PDALaunch)) return null; 

160:         PDALaunch launch = (PDALaunch)adaptableObject;

162:         // Find the correct set of adapters based on the launch.  If not found
163:         // it means that we have a new launch, and we have to create a 
164:         // new set of adapters. 
165:         LaunchAdapterSet adapterSet;
166:         synchronized(fLaunchAdapterSets) {
167:             adapterSet = fLaunchAdapterSets.get(launch);
168:             if (adapterSet == null) {
169:                 adapterSet = new LaunchAdapterSet(launch);
170:                 fLaunchAdapterSets.put(launch, adapterSet);
171:             }
172:         }
173:         
174:         // Returns the adapter type for the launch object.
175:         if (adapterType.equals(IElementContentProvider.class)) return adapterSet.fViewModelAdapter;
176:         else if (adapterType.equals(IModelProxyFactory.class)) return adapterSet.fViewModelAdapter;
177:         else return null;
178:     }

 85:         LaunchAdapterSet(PDALaunch launch) {
 86:             // Initialize launch and session.
 87:             fLaunch = launch;
 88:             DsfSession session = launch.getSession();
 89:             
 90:             // Initialize VM
 91:             fViewModelAdapter = new PDAVMAdapter(session);

 93:             // Initialize source lookup
 94:             fSourceDisplayAdapter = new MISourceDisplayAdapter(session, (ISourceLookupDirector)launch.getSourceLocator());
 95:             session.registerModelAdapter(ISourceDisplay.class, fSourceDisplayAdapter);
 96:             
 97:             // Initialize retargetable command handler.
 98:             fStepIntoCommand = new DsfStepIntoCommand(session);
 99:             fStepOverCommand = new DsfStepOverCommand(session);
100:             fStepReturnCommand = new DsfStepReturnCommand(session);
101:             fSuspendCommand = new DsfSuspendCommand(session);
102:             fResumeCommand = new DsfResumeCommand(session);
103:             fTerminateCommand = new PDATerminateCommand(session);
104:             session.registerModelAdapter(IStepIntoHandler.class, fStepIntoCommand);
105:             session.registerModelAdapter(IStepOverHandler.class, fStepOverCommand);
106:             session.registerModelAdapter(IStepReturnHandler.class, fStepReturnCommand);
107:             session.registerModelAdapter(ISuspendHandler.class, fSuspendCommand);
108:             session.registerModelAdapter(IResumeHandler.class, fResumeCommand);
109:             session.registerModelAdapter(ITerminateHandler.class, fTerminateCommand);

111:             // Initialize debug model provider
112:             fDebugModelProvider = new IDebugModelProvider() {
113:                 public String[] getModelIdentifiers() {
114:                     return new String[] { PDAPlugin.ID_PDA_DEBUG_MODEL };
115:                 }
116:             };
117:             session.registerModelAdapter(IDebugModelProvider.class, fDebugModelProvider);
118:             
119:             // Register the launch as an adapter This ensures that the launch, 
120:             // and debug model ID will be associated with all DMContexts from this 
121:             // session.  
122:             session.registerModelAdapter(ILaunch.class, fLaunch);
123:         }

185:     public void launchesRemoved(ILaunch[] launches) {
186:         // Dispose the set of adapters for a launch only after the launch is 
187:         // removed from the view.  If the launch is terminated, the adapters
188:         // are still needed to populate the contents of the view.
189:         for (ILaunch launch : launches) {
190:             if (launch instanceof PDALaunch) {
191:                 PDALaunch pdaLaunch = (PDALaunch)launch;
192:                 synchronized(fLaunchAdapterSets) {
193:                     if ( fLaunchAdapterSets.containsKey(pdaLaunch) ) {
194:                         fLaunchAdapterSets.remove(pdaLaunch).dispose();
195:                     }
196:                 }
197:             }                
198:         }
199:     }

 43:     protected AbstractDMVMProvider createViewModelProvider(IPresentationContext context) {
 44:         if ( IDebugUIConstants.ID_DEBUG_VIEW.equals(context.getId()) ) {
 45:             return new PDALaunchVMProvider(this, context, getSession()); 
 46:         } else if (IDebugUIConstants.ID_VARIABLE_VIEW.equals(context.getId()) ) {
 47:             return new VariableVMProvider(this, context, getSession());
 48:         } else if (IDebugUIConstants.ID_EXPRESSION_VIEW.equals(context.getId()) ) {
 49:             return new ExpressionVMProvider(this, context, getSession());
 50:         } 
 51:         return null;
 52:     }    

 50:     public PDALaunchVMProvider(AbstractVMAdapter adapter, IPresentationContext presentationContext, DsfSession session) 
 51:     {
 52:         super(adapter, presentationContext, session);
 53:         
 54:         IRootVMNode launchNode = new LaunchRootVMNode(this);
 55:         setRootNode(launchNode);

 57:         // Launch node is a parent to the processes and program nodes.
 58:         IVMNode pdaProgramNode = new PDAProgramVMNode(this, getSession());
 59:         IVMNode processesNode = new StandardProcessVMNode(this);
 60:         addChildNodes(launchNode, new IVMNode[] { pdaProgramNode, processesNode});
 61:         
 62:         // Stack frames node is under the PDA program node.
 63:         IVMNode stackFramesNode = new StackFramesVMNode(this, getSession());
 64:         addChildNodes(pdaProgramNode, new IVMNode[] { stackFramesNode });

 66:         // Register the LaunchVM provider as a listener to debug and launch 
 67:         // events.  These events are used by the launch and processes nodes.
 68:         DebugPlugin.getDefault().addDebugEventListener(this);
 69:         DebugPlugin.getDefault().getLaunchManager().addLaunchListener(this);
 70:     }

119:     @Override
120:     public void update(IChildrenUpdate[] updates) {
121:         for (IChildrenUpdate update : updates) {
122:             PDALaunch launch = findLaunchInPath(update.getElementPath());
123:             if (launch != null && launch.isInitialized() && launch.isShutDown()) {
124:                 // If the debug session has been shut down, add a dummy 
125:                 // VM context representing the PDA thread.
126:                 update.setChild(new TerminatedProgramVMContext(getVMProvider().getVMAdapter(), this), 0);
127:                 update.done();
128:             } else {
129:                 super.update(new IChildrenUpdate[] { update });
130:             }
131:         }
132:     }
133:     
134:     @Override
135:     protected void updateElementsInSessionThread(final IChildrenUpdate update) {
136:         // Get the instance of the service.  Note that there is no race condition
137:         // in getting the service since this method is called only in the 
138:         // service executor thread.
139:         final PDACommandControl commandControl = getServicesTracker().getService(PDACommandControl.class);

141:         // Check if the service is available.  If it is not, no elements are 
142:         // updated.
143:         if (commandControl == null) {
144:             handleFailedUpdate(update);
145:             return;
146:         }
147:         
148:         update.setChild(createVMContext(commandControl.getProgramDMContext()), 0);
149:         update.done();
150:     }

152:     public void update(final ILabelUpdate[] updates) {
153:         for (final ILabelUpdate update : updates) {
154:             if (update.getElement() instanceof TerminatedProgramVMContext) {
155:                 // If the element is a terminated program, update the label 
156:                 // in the View Model thread.
157:                 updateTerminatedThreadLabel(update);
158:             } else {
159:                 // If the element is the PDA Program context, try to switch
160:                 // to the DSF session thread before updating the label.
161:                 try {
162:                     getSession().getExecutor().execute(new DsfRunnable() {
163:                         public void run() {
164:                             updateProgramLabelInSessionThread(update);
165:                         }});
166:                 } catch (RejectedExecutionException e) {
167:                     // Acceptable race condition: DSF session terminated.
168:                     handleFailedUpdate(update);
169:                 }
170:             }
171:         }
172:     }

174:     @ConfinedToDsfExecutor("getSession().getExecutor()")
175:     private void updateProgramLabelInSessionThread(final ILabelUpdate update) {
176:         // Get a reference to the run control service.
177:         final IRunControl runControl = getServicesTracker().getService(IRunControl.class);
178:         if (runControl == null) {
179:             handleFailedUpdate(update);
180:             return;
181:         }
182:         
183:         // Find the PDA program context.
184:         final PDAProgramDMContext programCtx = 
185:             findDmcInPath(update.getViewerInput(), update.getElementPath(), PDAProgramDMContext.class);

187:         // Call service to get current program state
188:         final boolean isSuspended = runControl.isSuspended(programCtx);

190:         // Set the program icon based on the running state of the program.
191:         String imageKey = null;
192:         if (isSuspended) {
193:             imageKey = IDebugUIConstants.IMG_OBJS_THREAD_SUSPENDED;
194:         } else {
195:             imageKey = IDebugUIConstants.IMG_OBJS_THREAD_RUNNING;
196:         }
197:         update.setImageDescriptor(DebugUITools.getImageDescriptor(imageKey), 0);

199:         // Retrieve the last state change reason 
200:         runControl.getExecutionData(
201:             programCtx, 
202:             new DataRequestMonitor<IExecutionDMData>(ImmediateExecutor.getInstance(), null) 
203:             { 
204:                 @Override
205:                 public void handleCompleted(){
206:                     // If the request failed, fail the udpate. 
207:                     if (!getStatus().isOK()) {
208:                         handleFailedUpdate(update);
209:                         return;
210:                     }
211:     
212:                     // Compose the thread name string.
213:                     final StringBuilder builder = new StringBuilder(); 
214:     
215:                     builder.append("PDA [");
216:                     builder.append(programCtx.getProgram());
217:                     builder.append("]");
218:                     
219:                     if(isSuspended) {
220:                         builder.append(" (Suspended"); 
221:                     } else {
222:                         builder.append(" (Running"); 
223:                     }
224:                     // Reason will be null before ContainerSuspendEvent is fired
225:                     if(getData().getStateChangeReason() != null) {
226:                         builder.append(" : "); 
227:                         builder.append(getData().getStateChangeReason());
228:                     }
229:                     builder.append(")"); 
230:                     update.setLabel(builder.toString(), 0);
231:                     update.done();
232:                 }
233:             });        
234:     }

 73:     public void handleDebugEvents(final DebugEvent[] events) {
 74:         if (isDisposed()) return;
 75:         
 76:         // This method may be called on any thread.  Switch to the 
 77:         // view model executor thread before processing.
 78:         try {
 79:             getExecutor().execute(new Runnable() {
 80:                 public void run() {
 81:                     if (isDisposed()) return;
 82:     
 83:                     for (final DebugEvent event : events) {
 84:                         handleEvent(event);
 85:                     }
 86:                 }});
 87:         } catch (RejectedExecutionException e) {
 88:             // Ignore.  This exception could be thrown if the view model is being 
 89:             // shut down.  
 90:         }
 91:     }

265:     public int getDeltaFlags(Object e) {
266:         if(e instanceof IResumedDMEvent || e instanceof ISuspendedDMEvent) {
267:             return IModelDelta.STATE;
268:         } 
269:         if (e instanceof PDAStartedEvent) {
270:             return IModelDelta.EXPAND | IModelDelta.SELECT;
271:         }
272:         return IModelDelta.NO_CHANGE;
273:     }
274:
275:     public void buildDelta(Object e, VMDelta parentDelta, int nodeOffset, RequestMonitor rm) {
276:         if(e instanceof IResumedDMEvent || e instanceof ISuspendedDMEvent) {
277:             // If a suspended/resumed event is received, just update the 
278:             // state of the program.  StackFramesVMNode will take care of 
279:             // refreshing the stack frames.
280:             parentDelta.addNode(createVMContext(((IDMEvent<?>)e).getDMContext()), IModelDelta.STATE);
281:         } 
282:         if (e instanceof PDAStartedEvent) {
283:             // When debug session is started expand and select the program.
284:             // If the program hits a breakpoint, the top stack frame will then
285:             // be selected.
286:             parentDelta.addNode(createVMContext(((PDAStartedEvent)e).getDMContext()), IModelDelta.EXPAND | IModelDelta.SELECT);            
287:         }
288:         rm.done();
289:     }
290: }

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:     }    
208:
209:
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:     }

222:     public boolean canResume(IExecutionDMContext context) {
223:         return isSuspended(context) && !fResumePending;
224:     }

238:     public void resume(IExecutionDMContext context, final RequestMonitor rm) {
239:         assert context != null;
240:
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:                         super.handleErrorOrCancel();
252:                     }
253:                 }
254:             );
255:         } else {
256:             PDAPlugin.failRequest(rm, INVALID_STATE, "Given context: " + context + ", is already running.");
257:         }
258:     }

 50:     private static class BreakpointDMContext extends AbstractDMContext implements IBreakpointDMContext {
 51:
 52:         final Integer fLine;
 53:
 54:         public BreakpointDMContext(String sessionId, PDAProgramDMContext commandControlCtx, Integer line) {
 55:             super(sessionId, new IDMContext[] { commandControlCtx });
 56:             fLine = line;
 57:         }
 58:
 59:         @Override
 60:         public boolean equals(Object obj) {
 61:             return baseEquals(obj) && (fLine.equals(((BreakpointDMContext) obj).fLine));
 62:         }
 63:
 64:         @Override
 65:         public int hashCode() {
 66:             return baseHashCode() + fLine.hashCode();
 67:         }
 68:
 69:         @Override
 70:         public String toString() {
 71:             return baseToString() + ".breakpoint(" + fLine + ")";  //$NON-NLS-1$//$NON-NLS-2$*/
 72:         }
 73:     }

180:         public void insertBreakpoint(IBreakpointsTargetDMContext context, Map<String, Object> attributes, 
181:             DataRequestMonitor<IBreakpointDMContext> rm) 
182:         {
183:             Boolean enabled = (Boolean)attributes.get(IBreakpoint.ENABLED);
184:             if (enabled != null && !enabled.booleanValue()) {
185:                 // If the breakpoint is disabled, just fail the request. 
186:                 PDAPlugin.failRequest(rm, REQUEST_FAILED, "Breakpoint is disabled");
187:             } else {
188:                 String type = (String) attributes.get(ATTR_BREAKPOINT_TYPE);
189:     
190:                 if (PDA_LINE_BREAKPOINT.equals(type)) {
191:                     // Retrieve the PDA program context from the context given in the 
192:                     // argument.  This service is typically only called by the 
193:                     // breakpoints mediator, which was called with the program context
194:                     // in the services initialization sequence.  So checking if 
195:                     // programCtx != null is mostly a formality.
196:                     PDAProgramDMContext programCtx = DMContexts.getAncestorOfType(context, PDAProgramDMContext.class);
197:                     if (programCtx != null) {
198:                         doInsertBreakpoint(programCtx, attributes, rm);
199:                     } else {
200:                         PDAPlugin.failRequest(rm, INVALID_HANDLE, "Unknown breakpoint type");
201:                     }
202:                 }
203:                 else if (PDA_WATCHPOINT.equals(type)) {
204:                     doInsertWatchpoint(attributes, rm);
205:                 }
206:                 else {
207:                     PDAPlugin.failRequest(rm, REQUEST_FAILED, "Unknown breakpoint type");
208:                 }
209:             }
210:         }

212:     private void doInsertBreakpoint(PDAProgramDMContext programCtx, final Map<String, Object> attributes, final DataRequestMonitor<IBreakpointDMContext> rm) 
213:     {
214:         // Compare the program path in the breakpoint with the path in the PDA 
215:         // program context. Only insert the breakpoint if the program matches. 
216:         String program = (String)attributes.get(ATTR_PROGRAM_PATH);
217:         if (!programCtx.getProgram().equals(program)) {
218:             PDAPlugin.failRequest(rm, REQUEST_FAILED, "Invalid file name");
219:             return;
220:         }

222:         // Retrieve the line.
223:         Integer line = (Integer)attributes.get(IMarker.LINE_NUMBER);
224:         if (line == null) {
225:             PDAPlugin.failRequest(rm, REQUEST_FAILED, "No breakpoint line specified");
226:             return;
227:         }

229:         // Create a new breakpoint context object and check that it's not 
230:         // installed already. PDA can only track a single breakpoint at a 
231:         // given line, attempting to set the second breakpoint should fail.
232:         final BreakpointDMContext breakpointCtx = 
233:             new BreakpointDMContext(getSession().getId(), fCommandControl.getProgramDMContext(), line);
234:         if (fBreakpoints.contains(breakpointCtx)) {
235:             PDAPlugin.failRequest(rm, REQUEST_FAILED, "Breakpoint already set");
236:             return;
237:         }

239:         // Add the new breakpoint context to the list of known breakpoints.  
240:         // Adding it here, before the set command is completed will prevent 
241:         // a possibility of a second breakpoint being installed in the same 
242:         // location while this breakpoint is being processed.  It will also
243:         // allow the breakpoint to be removed or updated even while it is 
244:         // still being processed here.
245:         fBreakpoints.add(breakpointCtx);
246:         fCommandControl.queueCommand(
247:             new PDASetBreakpointCommand(fCommandControl.getProgramDMContext(), line), 
248:             new DataRequestMonitor<PDACommandResult>(getExecutor(), rm) {
249:                 @Override
250:                 protected void handleOK() {
251:                     rm.setData(breakpointCtx);
252:                     rm.done();
253:                 }

255:                 @Override
256:                 protected void handleErrorOrCancel() {
257:                     // If inserting of the breakpoint failed, remove it from
258:                     // the set of installed breakpoints.
259:                     fBreakpoints.remove(breakpointCtx);
260:                     super.handleErrorOrCancel();
261:                 }
262:             });
263:     }

367:     public void updateBreakpoint(final IBreakpointDMContext bpCtx, Map<String, Object> attributes, final RequestMonitor rm) {
368:         if (!fBreakpoints.contains(bpCtx)) {
369:             PDAPlugin.failRequest(rm, REQUEST_FAILED, "Breakpoint not installed");
370:             return;
371:         }

373:         if (bpCtx instanceof BreakpointDMContext) {
374:             PDAPlugin.failRequest(rm, NOT_SUPPORTED, "Modifying PDA breakpoints is not supported");
375:         } else if (bpCtx instanceof WatchpointDMContext) {
376:             WatchpointDMContext wpCtx = (WatchpointDMContext)bpCtx;
377:             if (!wpCtx.fFunction.equals(attributes.get(PDAWatchpoint.FUNCTION_NAME)) || 
378:                 !wpCtx.fVariable.equals(attributes.get(PDAWatchpoint.VAR_NAME)) )
379:             {
380:                 PDAPlugin.failRequest(rm, REQUEST_FAILED, "Cannot modify watchpoint function or variable");
381:                 return;
382:             }
383:             
384:             // PDA debugger can only track one watchpoint in the same location, 
385:             // so we can simply remove the existing context from the set and 
386:             // call insert again.  
387:             fBreakpoints.remove(bpCtx);
388:             doInsertWatchpoint(
389:                 attributes, 
390:                 new DataRequestMonitor<IBreakpointDMContext>(getExecutor(), rm) {
391:                     @Override
392:                     protected void handleOK() {
393:                         // The inserted watchpoint context will equal the 
394:                         // current context.
395:                         assert bpCtx.equals(getData());
396:                         rm.done();
397:                     }
398:                 });
399:         } else {
400:             PDAPlugin.failRequest(rm, INVALID_HANDLE, "Invalid breakpoint");
401:         }
402:     }

 65:     public List<Map<String, Object>> getBreakpointAttributes(IBreakpoint bp, boolean bpManagerEnabled) 
 66:         throws CoreException 
 67:     {
 68:         Map<String, Object> attrs = new HashMap<String, Object>(); 

 70:         // Check that the marker exists and retrieve its attributes.  
 71:         // Due to accepted race conditions, the breakpiont marker may become null 
 72:         // while this method is being invoked.  In this case throw an exception
 73:         // and let the caller handle it.
 74:         IMarker marker = bp.getMarker();
 75:         if (marker == null || !marker.exists()) {
 76:             throw new DebugException(new Status(IStatus.ERROR, PDAPlugin.PLUGIN_ID, DebugException.REQUEST_FAILED, "Breakpoint marker does not exist", null)); 
 77:         }
 78:         // Suppress cast warning: platform is still on Java 1.3
 79:         @SuppressWarnings("unchecked")
 80:         Map<String, Object> platformBpAttrs = marker.getAttributes();

 82:         // Copy breakpoint attributes.
 83:         if (bp instanceof PDAWatchpoint) {
 84:             attrs.put(PDABreakpoints.ATTR_BREAKPOINT_TYPE, PDABreakpoints.PDA_WATCHPOINT);

 86:             copyAttributes(platformBpAttrs, attrs, fgPDAWatchpointAttributes);
 87:         } else if (bp instanceof PDALineBreakpoint) {
 88:             attrs.put(PDABreakpoints.ATTR_BREAKPOINT_TYPE, PDABreakpoints.PDA_LINE_BREAKPOINT);
 89:             attrs.put(PDABreakpoints.ATTR_PROGRAM_PATH, marker.getResource().getFullPath().toString()); 

 91:             copyAttributes(platformBpAttrs, attrs, fgPDALineBreakpointAttributes);
 92:         }

 94:         // If the breakpoint manager is disabled, override the enabled attribute.
 95:         if (!bpManagerEnabled) {
 96:             attrs.put(IBreakpoint.ENABLED, false);
 97:         }

 99:         // The breakpoint mediator allows for multiple target-side breakpoints 
100:         // to be created for each IDE breakpoint.  Although in case of PDA this 
101:         // feature is never used, we still have to return a list of attributes.
102:         List<Map<String, Object>> retVal = new ArrayList<Map<String, Object>>(1);
103:         retVal.add(attrs);
104:         return retVal;
105:     }

107:     private void copyAttributes(Map<String, Object> srcMap, Map<String, Object> destMap, String[] attrs) {
108:         for (String attr : attrs) {
109:             if (srcMap.containsKey(attr)) {
110:                 destMap.put(attr, srcMap.get(attr));
111:             }
112:         }
113:     }

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:     }

 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:     }

 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:     }

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:     }

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:     }

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:     }

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:     }