9e5dfb8f09c8e5bacca93c2f7ec598c6fbf31699
[phpeclipse.git] / net.sourceforge.phpeclipse.debug.core / src / net / sourceforge / phpdt / internal / debug / core / model / PHPDebugTarget.java
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 org.eclipse.core.resources.IMarkerDelta;
15 import org.eclipse.debug.core.DebugEvent;
16 import org.eclipse.debug.core.DebugException;
17 import org.eclipse.debug.core.DebugPlugin;
18 import org.eclipse.debug.core.IBreakpointManager;
19 import org.eclipse.debug.core.IDebugEventSetListener;
20 import org.eclipse.debug.core.ILaunch;
21 import org.eclipse.debug.core.ILaunchListener;
22 import org.eclipse.debug.core.model.IDebugTarget;
23 import org.eclipse.debug.core.model.IBreakpoint;
24 import org.eclipse.debug.core.model.IMemoryBlock;
25 import org.eclipse.debug.core.model.IProcess;
26 import org.eclipse.debug.core.model.IThread;
27
28 import net.sourceforge.phpdt.internal.debug.core.PHPDebugCorePlugin;
29 import net.sourceforge.phpdt.internal.debug.core.PHPDBGProxy;
30
31 /**
32  * Debug target for PHP debug model.
33  */
34 public class PHPDebugTarget implements IPHPDebugTarget, ILaunchListener, IDebugEventSetListener {
35                 
36         private IProcess process;
37         private boolean isTerminated;
38         private boolean isSuspended;
39         private ILaunch launch;
40         private PHPThread[] threads;
41         private PHPDBGProxy phpDBGProxy;
42
43         public PHPDebugTarget(ILaunch launch, IProcess process) {
44                 this.isSuspended = false;
45                 this.launch = launch;
46                 this.process = process;
47                 this.threads = new PHPThread[0];
48                 IBreakpointManager manager= DebugPlugin.getDefault().getBreakpointManager();
49                 manager.addBreakpointListener(this);
50                 DebugPlugin.getDefault().addDebugEventListener(this);
51                 initialize();
52         }
53
54         protected synchronized void initialize() {
55                 DebugEvent ev = new DebugEvent(this, DebugEvent.CREATE);
56                 DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { ev });    
57         }
58
59         public void addThread(PHPThread phpThread) {
60                 int i;
61                 PHPThread[] updatedThreads = new PHPThread[threads.length + 1];
62                 
63                 for(i=0; i < threads.length; i++) {
64                         updatedThreads[i] = threads[i];
65                 }
66                 updatedThreads[i] = phpThread;
67                 threads = updatedThreads;
68
69                 fireChangeEvent();
70         }
71
72         private void fireChangeEvent() {
73                 DebugEvent ev = new DebugEvent(this, DebugEvent.CHANGE);
74                 DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { ev });
75         }
76
77         protected PHPThread getThreadById(int id) {
78                 for (int i = 0; i < threads.length; i++) {
79                         if (threads[i].getId() == id) {
80                                 return threads[i];
81                         }
82                 }
83                 return null;
84         }
85
86         public IThread[] getThreads() {
87                 return threads;
88         }
89
90         public boolean hasThreads() throws DebugException {
91                 return threads.length > 0;
92         }
93
94         public String getName() throws DebugException {
95                 return "PHP Debugger at localhost:" + getPHPDBGProxy().getPort();
96         }
97
98         public boolean supportsBreakpoint(IBreakpoint arg0) {
99                 return false;
100         }
101
102         public String getModelIdentifier() {
103                 return PHPDebugCorePlugin.PLUGIN_ID;
104         }
105
106         public IDebugTarget getDebugTarget() {
107                 return this;
108         }
109
110         public ILaunch getLaunch() {
111                 return launch;
112         }
113
114         public boolean canTerminate() {
115                 return !isTerminated;
116         }
117
118         public boolean isTerminated() {
119                 return isTerminated;
120         }
121
122         public void terminate() {
123                 phpDBGProxy.stop();
124                 this.threads = new PHPThread[0];
125                 isTerminated = true;
126                 fireChangeEvent();
127         }
128
129         public boolean canResume() {
130                 if(isTerminated) return false;
131                 return isSuspended;
132         }
133
134         public boolean canSuspend() {
135                 if(isTerminated) return false;
136                 return !isSuspended;
137         }
138
139         public boolean isSuspended() {
140                 return isSuspended;
141         }
142
143         public void resume() throws DebugException {
144                 this.getPHPDBGProxy().resume();
145                 isSuspended= false;
146         }
147
148         public void suspend() throws DebugException {
149                 this.getPHPDBGProxy().pause();
150                 isSuspended= true;
151         }
152
153         public void breakpointAdded(IBreakpoint breakpoint) {
154                 this.getPHPDBGProxy().addBreakpoint(breakpoint) ;
155         }
156
157         public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta arg1) {
158                 this.getPHPDBGProxy().removeBreakpoint(breakpoint) ;            
159         }
160
161         public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta arg1) {
162                 // is called e.g. after a line has been inserted before a breakpoint
163                 // but then the debugger is out of sync with the file anyway, so debugging
164                 // should be stopped here.
165         }
166
167         public boolean canDisconnect() {
168                 return false;
169         }
170
171         public void disconnect() throws DebugException {
172         }
173
174         public boolean isDisconnected() {
175                 return false;
176         }
177
178         public boolean supportsStorageRetrieval() {
179                 return false;
180         }
181
182         public IMemoryBlock getMemoryBlock(long arg0, long arg1) throws DebugException {
183                 return null;
184         }
185
186         public Object getAdapter(Class arg0) {
187                 return null;
188         }
189
190         public IProcess getProcess() {
191                 return process;
192         }
193
194         public void setProcess(IProcess process) {
195                 this.process = process;
196         }
197
198         public PHPDBGProxy getPHPDBGProxy() {
199                 return phpDBGProxy;
200         }
201
202         public void setPHPDBGProxy(PHPDBGProxy phpDBGProxy) {
203                 this.phpDBGProxy = phpDBGProxy;
204         }
205         
206         /**
207          * @see ILaunchListener#launchRemoved(ILaunch)
208          */
209         public void launchRemoved(ILaunch launch) {
210                 if (!isTerminated()) {
211                         return;
212                 }
213                 if (launch.equals(getLaunch())) {
214                         // This target has been deregistered, but it hasn't successfully terminated.
215                         // Update internal state to reflect that it is disconnected
216                         terminate();
217                 }
218         }
219         
220         /**
221          * @see ILaunchListener#launchAdded(ILaunch)
222          */
223         public void launchAdded(ILaunch launch) {
224         }
225         
226         /**
227          * @see ILaunchListener#launchChanged(ILaunch)
228          */
229         public void launchChanged(ILaunch launch) {
230         }
231         
232         /**
233          * When a debug target or process terminates, terminate DBG Proxy.
234          * 
235          * @see IDebugEventSetListener#handleDebugEvents(DebugEvent[])
236          */
237         public void handleDebugEvents(DebugEvent[] events) {
238                 for (int i = 0; i < events.length; i++) {
239                         DebugEvent event = events[i];
240                         if (event.getKind() == DebugEvent.TERMINATE) {
241                                 Object source = event.getSource();
242                                 if (source instanceof PHPDebugTarget || source instanceof IDebugTarget) {
243                                         getPHPDBGProxy().stop();
244                                 } else if(source instanceof IProcess) {
245                                         if(getDebugTarget().getProcess() == (IProcess)source) {
246                                                 getPHPDBGProxy().stop();
247                                         }
248                                 }
249                         } else if (event.getKind() == DebugEvent.SUSPEND) {
250                                 getPHPDBGProxy().pause();
251                         }
252                 }
253         }
254 }
255