c86bbbe381105c490594c441390e5d1e75a5921c
[phpeclipse.git] /
1 /**********************************************************************
2  Copyright (c) 2000, 2002 IBM Corp. and others.
3  All rights reserved. This program and the accompanying materials
4  are made available under the terms of the Common Public License v1.0
5  which accompanies this distribution, and is available at
6  http://www.eclipse.org/legal/cpl-v10.html
7
8  Contributors:
9  IBM Corporation - Initial implementation
10  Vicente Fernando - www.alfersoft.com.ar
11  **********************************************************************/
12 package net.sourceforge.phpdt.internal.debug.core.model;
13
14 import net.sourceforge.phpdt.internal.debug.core.PHPDBGProxy;
15 import net.sourceforge.phpdt.internal.debug.core.PHPDebugCorePlugin;
16 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
17
18 import org.eclipse.core.resources.IMarkerDelta;
19 import org.eclipse.debug.core.DebugEvent;
20 import org.eclipse.debug.core.DebugException;
21 import org.eclipse.debug.core.DebugPlugin;
22 import org.eclipse.debug.core.IBreakpointManager;
23 import org.eclipse.debug.core.IDebugEventSetListener;
24 import org.eclipse.debug.core.ILaunch;
25 import org.eclipse.debug.core.ILaunchListener;
26 import org.eclipse.debug.core.model.IBreakpoint;
27 import org.eclipse.debug.core.model.IDebugTarget;
28 import org.eclipse.debug.core.model.IMemoryBlock;
29 import org.eclipse.debug.core.model.IProcess;
30 import org.eclipse.debug.core.model.IThread;
31 import org.eclipse.jface.resource.ImageDescriptor;
32 import org.eclipse.ui.model.IWorkbenchAdapter;
33
34 /**
35  * Debug target for PHP debug model.
36  */
37 public class PHPDebugTarget implements IPHPDebugTarget, ILaunchListener,
38                 IDebugEventSetListener {
39
40         private IProcess process;
41
42         private ILaunch launch;
43
44         private PHPThread[] threads = new PHPThread[0];
45
46         private PHPDBGProxy phpDBGProxy;
47
48         private class State {
49                 private boolean isTerminated = false;
50
51                 private boolean isSuspended = false;
52
53                 boolean isTerminated() {
54                         return isTerminated;
55                 }
56
57                 boolean isSuspended() {
58                         return isSuspended;
59                 }
60
61                 void setTerminated(boolean terminated) {
62                         this.isTerminated = terminated;
63                 }
64
65                 void setSuspended(boolean suspended) {
66                         if (isTerminated())
67                                 throw new IllegalStateException();
68                         this.isSuspended = suspended;
69                 }
70         }
71
72         private final State state = new State();
73
74         public PHPDebugTarget(ILaunch launch, IProcess process) {
75                 if (null == launch && null == process)
76                         throw new IllegalArgumentException();
77                 this.launch = launch;
78                 this.process = process;
79                 // TODO XXX remove breakpoint listener at termination to avoid live leak
80                 IBreakpointManager manager = DebugPlugin.getDefault()
81                                 .getBreakpointManager();
82                 manager.addBreakpointListener(this);
83                 DebugPlugin.getDefault().addDebugEventListener(this);
84                 initialize();
85         }
86
87         protected synchronized void initialize() {
88                 DebugEvent ev = new DebugEvent(this, DebugEvent.CREATE);
89                 DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { ev });
90         }
91
92         public void addThread(PHPThread phpThread) {
93                 int i;
94                 PHPThread[] updatedThreads = new PHPThread[threads.length + 1];
95
96                 for (i = 0; i < threads.length; i++) {
97                         updatedThreads[i] = threads[i];
98                 }
99                 updatedThreads[i] = phpThread;
100                 threads = updatedThreads;
101
102                 fireChangeEvent();
103                 fireThreadCreateEvent(phpThread);
104         }
105
106         private void fireChangeEvent() {
107                 DebugEvent ev = new DebugEvent(this, DebugEvent.CHANGE);
108                 DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { ev });
109         }
110
111         private void fireThreadCreateEvent(PHPThread phpThread) {
112                 DebugEvent ev = new DebugEvent(phpThread, DebugEvent.CREATE);
113                 DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { ev });
114         }
115
116         protected PHPThread getThreadById(int id) {
117                 for (int i = 0; i < threads.length; i++) {
118                         if (threads[i].getId() == id) {
119                                 return threads[i];
120                         }
121                 }
122                 return null;
123         }
124
125         public IThread[] getThreads() {
126                 return threads;
127         }
128
129         public boolean hasThreads() throws DebugException {
130                 return threads.length > 0;
131         }
132
133         public String getName() throws DebugException {
134                 return "PHP Debugger at localhost:" + getPHPDBGProxy().getPort();
135         }
136
137         public boolean supportsBreakpoint(IBreakpoint arg0) {
138                 if (arg0.getModelIdentifier().equals(PHPDebugCorePlugin.PLUGIN_ID)) {
139                         return true;
140                 }
141                 return false;
142         }
143
144         public String getModelIdentifier() {
145                 return PHPDebugCorePlugin.PLUGIN_ID;
146         }
147
148         public IDebugTarget getDebugTarget() {
149                 return this;
150         }
151
152         public ILaunch getLaunch() {
153                 return launch;
154         }
155
156         public synchronized boolean canTerminate() {
157                 return !isTerminated();
158         }
159
160         public synchronized boolean isTerminated() {
161                 return state.isTerminated();
162         }
163
164         public synchronized void terminate() {
165                 // This method is synchronized to control a race condition between the
166                 // UI thread that terminates the debugging session, and the slave
167                 // thread that executes PHPLoop.run
168                 if (isTerminated())
169                         // Avoid terminating twice...
170                         return;
171                 state.setTerminated(true);
172                 phpDBGProxy.stop();
173                 this.threads = new PHPThread[0];
174                 fireChangeEvent();
175                 IBreakpointManager manager = DebugPlugin.getDefault()
176                                 .getBreakpointManager();
177                 manager.removeBreakpointListener(this);
178                 DebugPlugin.getDefault().removeDebugEventListener(this);
179         }
180
181         public synchronized boolean canResume() {
182                 if (isTerminated())
183                         return false;
184                 return isSuspended();
185         }
186
187         public synchronized boolean canSuspend() {
188                 if (isTerminated())
189                         return false;
190                 return !isSuspended();
191         }
192
193         public synchronized boolean isSuspended() {
194                 return state.isSuspended();
195         }
196
197         public synchronized void resume() throws DebugException {
198                 if (!isSuspended())
199                         return;
200                 state.setSuspended(false);
201                 this.getPHPDBGProxy().resume();
202                 IThread[] threads = getThreads();
203                 for (int i = 0; i < threads.length; ++i)
204                         threads[i].resume();
205         }
206
207         public synchronized void suspend() throws DebugException {
208                 if (isSuspended())
209                         return;
210                 this.getPHPDBGProxy().pause();
211                 state.setSuspended(true);
212                 IThread[] threads = getThreads();
213                 for (int i = 0; i < threads.length; ++i)
214                         threads[i].suspend();
215         }
216
217         public void breakpointAdded(IBreakpoint breakpoint) {
218                 this.getPHPDBGProxy().addBreakpoint(breakpoint);
219         }
220
221         public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta arg1) {
222                 this.getPHPDBGProxy().removeBreakpoint(breakpoint);
223         }
224
225         public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta arg1) {
226                 // is called e.g. after a line has been inserted before a breakpoint
227                 // but then the debugger is out of sync with the file anyway, so
228                 // debugging
229                 // should be stopped here.
230         }
231
232         public boolean canDisconnect() {
233                 return false;
234         }
235
236         public void disconnect() throws DebugException {
237         }
238
239         public boolean isDisconnected() {
240                 return false;
241         }
242
243         public boolean supportsStorageRetrieval() {
244                 return false;
245         }
246
247         public IMemoryBlock getMemoryBlock(long arg0, long arg1)
248                         throws DebugException {
249                 return null;
250         }
251
252         public Object getAdapter(Class arg0) {
253                 if (IWorkbenchAdapter.class.equals(arg0)) {
254                         return new IWorkbenchAdapter() {
255                                 public Object[] getChildren(Object o) {
256                                         Object[] children = null;
257                                         IThread[] threads = getThreads();
258                                         if (null != threads) {
259                                                 children = new Object[threads.length];
260                                                 for (int i = 0; i < threads.length; ++i)
261                                                         children[i] = threads[i];
262                                         }
263                                         return children;
264                                 }
265
266                                 public ImageDescriptor getImageDescriptor(Object object) {
267                                         return null;
268                                 }
269
270                                 public String getLabel(Object o) {
271                                         String label = "(Unable to look up name... check error log)";
272                                         try {
273                                                 label = getName();
274                                         } catch (DebugException x) {
275                                                 PHPeclipsePlugin.log(label, x);
276                                         }
277                                         return label;
278                                 }
279
280                                 public Object getParent(Object o) {
281                                         return PHPDebugTarget.this.getLaunch();
282                                 }
283                         };
284                 }
285                 return null;
286         }
287
288         public IProcess getProcess() {
289                 return process;
290         }
291
292         public void setProcess(IProcess process) {
293                 this.process = process;
294         }
295
296         public PHPDBGProxy getPHPDBGProxy() {
297                 return phpDBGProxy;
298         }
299
300         public void setPHPDBGProxy(PHPDBGProxy phpDBGProxy) {
301                 this.phpDBGProxy = phpDBGProxy;
302         }
303
304         /**
305          * @see ILaunchListener#launchRemoved(ILaunch)
306          */
307         public void launchRemoved(ILaunch launch) {
308                 if (!isTerminated()) {
309                         return;
310                 }
311                 if (launch.equals(getLaunch())) {
312                         // This target has been deregistered, but it hasn't successfully
313                         // terminated.
314                         // Update internal state to reflect that it is disconnected
315                         terminate();
316                 }
317         }
318
319         /**
320          * @see ILaunchListener#launchAdded(ILaunch)
321          */
322         public void launchAdded(ILaunch launch) {
323         }
324
325         /**
326          * @see ILaunchListener#launchChanged(ILaunch)
327          */
328         public void launchChanged(ILaunch launch) {
329         }
330
331         /**
332          * When a debug target or process terminates, terminate DBG Proxy.
333          * 
334          * @see IDebugEventSetListener#handleDebugEvents(DebugEvent[])
335          */
336         public void handleDebugEvents(DebugEvent[] events) {
337                 for (int i = 0; i < events.length; i++) {
338                         DebugEvent event = events[i];
339                         if (event.getKind() == DebugEvent.TERMINATE) {
340                                 Object source = event.getSource();
341                                 if (source instanceof PHPDebugTarget
342                                                 || source instanceof IDebugTarget) {
343                                         getPHPDBGProxy().stop();
344                                 } else if (source instanceof IProcess) {
345                                         if (getDebugTarget().getProcess() == (IProcess) source) {
346                                                 getPHPDBGProxy().stop();
347                                         }
348                                 }
349                         } else if (event.getKind() == DebugEvent.SUSPEND) {
350                                 getPHPDBGProxy().pause();
351                         }
352                 }
353         }
354 }