--- /dev/null
+/**
+ *
+ */
+package net.sourceforge.phpeclipse.xdebug.php.model;
+
+import net.sourceforge.phpeclipse.xdebug.core.Base64;
+import net.sourceforge.phpeclipse.xdebug.core.DebugConnection;
+import net.sourceforge.phpeclipse.xdebug.core.PHPDebugUtils;
+import net.sourceforge.phpeclipse.xdebug.core.XDebugCorePlugin;
+import net.sourceforge.phpeclipse.xdebug.core.DebugConnection.DebugResponse;
+import net.sourceforge.phpeclipse.xdebug.php.launching.IXDebugConstants;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IMarkerDelta;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.DebugEvent;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.IDebugEventSetListener;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.ILineBreakpoint;
+import org.eclipse.debug.core.model.IMemoryBlock;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.debug.core.model.IStackFrame;
+import org.eclipse.debug.core.model.IThread;
+import org.eclipse.debug.core.model.IValue;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * @author Christian
+ *
+ */
+public class XDebugTarget extends XDebugElement implements IDebugTarget,
+ IDebugEventSetListener {
+ // associated system process (VM)
+ private IProcess fProcess;
+
+ // containing launch object
+ private ILaunch fLaunch;
+
+ // debugPort
+ private int fDebugPort;
+
+ // program name
+ // private String fName;
+
+ // suspend state
+ private boolean fSuspended = true;
+
+ // terminated state
+ private boolean fTerminated = false;
+
+ // threads
+ private XDebugThread fThread;
+
+ private IThread[] fThreads;
+
+ // event dispatch job
+ // private EventDispatchJob fEventDispatch;
+
+ private DebugConnection fDebugConnection;
+
+ // private DebugResponse lastResponse;
+
+ /**
+ * Constructs a new debug target in the given launch for the associated PDA
+ * VM process.
+ *
+ * @param launch
+ * containing launch
+ * @param debugPort
+ * port to read events from
+ * @exception CoreException
+ * if unable to connect to host
+ */
+ public XDebugTarget(ILaunch launch, IProcess process, int debugPort)
+ throws CoreException {
+ super(null);
+ fLaunch = launch;
+ fProcess = process;
+ fTarget = this;
+ fDebugConnection = new DebugConnection(this, debugPort);
+ fThread = new XDebugThread(this);
+ fThreads = new IThread[] { fThread };
+ DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(
+ this);
+ DebugPlugin.getDefault().addDebugEventListener(this);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugTarget#getProcess()
+ */
+ public IProcess getProcess() {
+ return fProcess;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugTarget#getThreads()
+ */
+ public IThread[] getThreads() throws DebugException {
+ return fThreads;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugTarget#hasThreads()
+ */
+ public boolean hasThreads() throws DebugException {
+ return (fThreads.length > 0);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugTarget#getName()
+ */
+ public String getName() throws DebugException {
+ return "PHP XDebug Client at localhost:" + fDebugPort;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugTarget#supportsBreakpoint(org.eclipse.debug.core.model.IBreakpoint)
+ */
+ public boolean supportsBreakpoint(IBreakpoint breakpoint) {
+ if (breakpoint.getModelIdentifier().equals(
+ IXDebugConstants.ID_PHP_DEBUG_MODEL)) {
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
+ */
+ public IDebugTarget getDebugTarget() {
+ return this;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
+ */
+ public ILaunch getLaunch() {
+ return fLaunch;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ITerminate#canTerminate()
+ */
+ public boolean canTerminate() {
+ return getProcess().canTerminate();
+ // return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ITerminate#isTerminated()
+ */
+ public boolean isTerminated() {
+ // return getProcess().isTerminated();
+ return fTerminated;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ITerminate#terminate()
+ */
+ public void terminate() throws DebugException {
+ fDebugConnection.sendRequest("stop");
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ISuspendResume#canResume()
+ */
+ public boolean canResume() {
+ return !isTerminated() && isSuspended();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ISuspendResume#canSuspend()
+ */
+ public boolean canSuspend() {
+ return !isTerminated() && !isSuspended();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ISuspendResume#isSuspended()
+ */
+ public boolean isSuspended() {
+ return fSuspended;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ISuspendResume#resume()
+ */
+ public void resume() throws DebugException {
+ fDebugConnection.sendRequest("run");
+ }
+
+ /**
+ * Notification the target has resumed for the given reason
+ *
+ * @param detail
+ * reason for the resume
+ */
+ private void resumed(int detail) {
+ fSuspended = false;
+ fThread.fireResumeEvent(detail);
+ }
+
+ /**
+ * Notification the target has suspended for the given reason
+ *
+ * @param detail
+ * reason for the suspend
+ */
+ public void suspended(int detail) {
+ fSuspended = true;
+ fThread.fireSuspendEvent(detail);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.ISuspendResume#suspend()
+ */
+ public void suspend() throws DebugException {
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.IBreakpointListener#breakpointAdded(org.eclipse.debug.core.model.IBreakpoint)
+ */
+ public void breakpointAdded(IBreakpoint breakpoint) {
+
+ if (supportsBreakpoint(breakpoint)) {
+ try {
+ if (breakpoint.isEnabled()) {
+ IMarker marker = breakpoint.getMarker();
+ if (marker != null) {
+ try {
+ String fileName = PHPDebugUtils.escapeString(marker
+ .getResource().getLocation().toString());
+ String arg = "-t line -f file:///"
+ + fileName
+ + " -n "
+ + ((ILineBreakpoint) breakpoint)
+ .getLineNumber();
+ int id = fDebugConnection.sendRequest(
+ "breakpoint_set", arg);
+ // set the marker Attribute to make later
+ // idetification possible
+ // TODO: make sure that attribute is set before
+ // response from debugger is beeing prosessed
+ marker.setAttribute(
+ XDebugLineBreakpoint.BREAKPOINT_ID, id);
+
+ } catch (CoreException e) {
+ }
+ }
+ }
+ } catch (CoreException e) {
+
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint,
+ * org.eclipse.core.resources.IMarkerDelta)
+ */
+ public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
+ if (supportsBreakpoint(breakpoint)) {
+ try {
+ int id = ((XDebugLineBreakpoint) breakpoint).getID();
+ if (id > 0)
+ fDebugConnection.sendRequest("breakpoint_remove", "-d "
+ + id);
+ } catch (CoreException e) {
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint,
+ * org.eclipse.core.resources.IMarkerDelta)
+ */
+ public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
+ // if (supportsBreakpoint(breakpoint)) {
+ // try {
+ // if (breakpoint.isEnabled()) {
+ // breakpointAdded(breakpoint);
+ // } else {
+ // breakpointRemoved(breakpoint, null);
+ // }
+ // } catch (CoreException e) {
+ // }
+ // }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDisconnect#canDisconnect()
+ */
+ public boolean canDisconnect() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDisconnect#disconnect()
+ */
+ public void disconnect() throws DebugException {
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IDisconnect#isDisconnected()
+ */
+ public boolean isDisconnected() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#supportsStorageRetrieval()
+ */
+ public boolean supportsStorageRetrieval() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#getMemoryBlock(long,
+ * long)
+ */
+ public IMemoryBlock getMemoryBlock(long startAddress, long length)
+ throws DebugException {
+ return null;
+ }
+
+ /**
+ * Notification we have connected to the PHP debugger and it has started.
+ * Resume the the debugger.
+ */
+ public void started() {
+
+ fThread.setBreakpoints(null);
+ fThread.setStepping(false);
+
+ installDeferredBreakpoints();
+ try {
+ resume();
+ // step();
+ } catch (DebugException e) {
+ }
+ }
+
+ /**
+ * Install breakpoints that are already registered with the breakpoint
+ * manager.
+ */
+ private void installDeferredBreakpoints() {
+ IBreakpoint[] breakpoints = XDebugCorePlugin.getBreakpoints();
+ for (int i = 0; i < breakpoints.length; i++) {
+ breakpointAdded(breakpoints[i]);
+ }
+ }
+
+ /**
+ * Called when this debug target terminates.
+ */
+ public void terminated() {
+ fTerminated = true;
+ fSuspended = false;
+ XDebugCorePlugin.getBreakpointManager().removeBreakpointListener(this);
+ fireTerminateEvent();
+ DebugPlugin.getDefault().removeDebugEventListener(this);
+ fThread.removeEventListeners();
+ }
+
+ /**
+ * Returns the current stack frames in the target.
+ *
+ * @return the current stack frames in the target
+ * @throws DebugException
+ * if unable to perform the request
+ */
+ protected IStackFrame[] getStackFrames() throws DebugException {
+ int id = fDebugConnection.sendRequest("stack_get");
+ DebugResponse lastResponse = fDebugConnection.waitforTransID(id);
+ if (lastResponse.isError())
+ return new IStackFrame[0];
+ Node response = lastResponse.getParentNode();
+ NodeList frames = response.getChildNodes();
+ IStackFrame[] theFrames = new IStackFrame[frames.getLength()];
+ for (int i = 0; i < frames.getLength(); i++) {
+ Node stackNode = frames.item(i);
+ theFrames[i] = new XDebugStackFrame(fThread, stackNode, i);
+ }
+ return theFrames;
+ }
+
+ /**
+ * Single step the interpreter.
+ *
+ * @throws DebugException
+ * if the request fails
+ */
+ protected void step_over() throws DebugException {
+ fThread.setStepping(true);
+ resumed(DebugEvent.STEP_OVER);
+ fDebugConnection.sendRequest("step_over");
+ }
+
+ /**
+ * Single step the interpreter.
+ *
+ * @throws DebugException
+ * if the request fails
+ */
+ protected void step_into() throws DebugException {
+ fThread.setStepping(true);
+ resumed(DebugEvent.STEP_INTO);
+ fDebugConnection.sendRequest("step_into");
+ }
+
+ /**
+ * Single step the interpreter.
+ *
+ * @throws DebugException
+ * if the request fails
+ */
+ protected void step_out() throws DebugException {
+ fThread.setStepping(true);
+ resumed(DebugEvent.STEP_RETURN);
+ fDebugConnection.sendRequest("step_out");
+ }
+
+ /**
+ * Returns the current value of the given variable.
+ *
+ * @param variable
+ * @return variable value
+ * @throws DebugException
+ * if the request fails
+ */
+ protected IValue getVariableValue(XDebugVariable variable)
+ throws DebugException {
+ // synchronized (fDebugSocket) {
+ // fDebugConnection.sendRequest("var","" +
+ // variable.getStackFrame().getIdentifier() + " " + variable.getName());
+ // try {
+ // String value = fDebugReader.readLine();
+ // //return new XDebugValue(this, value);
+ //
+ // } catch (IOException e) {
+ // abort(MessageFormat.format("Unable to retrieve value for variable
+ // {0}", new String[]{variable.getName()}), e);
+ // }
+ // }
+ return null;
+ }
+
+ /**
+ * Returns the values on the data stack (top down)
+ *
+ * @return the values on the data stack (top down)
+ */
+ public IValue[] getDataStack() throws DebugException {
+ // synchronized (fDebugSocket) {
+ // fDebugConnection.sendRequest ("data");
+ // try {
+ // String valueString = fDebugReader.readLine();
+ // if (valueString != null && valueString.length() > 0) {
+ // String[] values = valueString.split("\\|");
+ // IValue[] theValues = new IValue[values.length];
+ // for (int i = 0; i < values.length; i++) {
+ // String value = values[values.length - i - 1];
+ // // theValues[i] = new XDebugValue(this, value);
+ // }
+ // return theValues;
+ // }
+ // } catch (IOException e) {
+ // abort("Unable to retrieve data stack", e);
+ // }
+ // }
+ return new IValue[0];
+ }
+
+ public boolean setVarValue(String name, String value) {
+ int id = -1;
+ String str = Base64.encodeBytes(value.getBytes());
+ int len = str.length();
+
+ try {
+ id = fDebugConnection.sendRequest("property_set", "-n " + name
+ + " -l " + len + " -- " + str);
+ } catch (DebugException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ DebugResponse dr = getResponse(id);
+ if ((dr.getAttributeValue("success")).equals("1"))
+ return true;
+
+ return false;
+ }
+
+ public DebugResponse getResponse(int id) {
+ return fDebugConnection.waitforTransID(id);
+ }
+
+ /**
+ * Sends a request to the Debugengine and waits for an OK.
+ *
+ * @param command
+ * debug command
+ * @throws DebugException
+ * if the request fails
+ */
+
+ public int sendRequest(String command) throws DebugException {
+ return fDebugConnection.sendRequest(command, "");
+ }
+
+ /**
+ * Sends a request to the Debugengine and waits for an OK.
+ *
+ * @param command
+ * debug command
+ * @arguments arguments for the command
+ * @throws DebugException
+ * if the request fails
+ */
+
+ public int sendRequest(String command, String arguments)
+ throws DebugException {
+ return fDebugConnection.sendRequest(command, arguments);
+ }
+
+ /**
+ * Notification a breakpoint was encountered. Determine which breakpoint was
+ * hit and fire a suspend event.
+ *
+ * @param event
+ * debug event
+ */
+ public void breakpointHit(Node node) {
+ // determine which breakpoint was hit, and set the thread's breakpoint
+ Node child = node.getFirstChild();
+ if (child.getNodeName().equals("stack")) {
+ int lineNumber = Integer.parseInt(PHPDebugUtils.getAttributeValue(
+ child, "lineno"));
+ String filename = PHPDebugUtils
+ .getAttributeValue(child, "filename").substring(8); // remove
+ // file:///
+ IBreakpoint[] breakpoints = XDebugCorePlugin.getBreakpoints();
+ for (int i = 0; i < breakpoints.length; i++) {
+ IBreakpoint breakpoint = breakpoints[i];
+ if (supportsBreakpoint(breakpoint)) {
+ if (breakpoint instanceof ILineBreakpoint) {
+ ILineBreakpoint lineBreakpoint = (ILineBreakpoint) breakpoint;
+ try {
+ if (breakpoint.isEnabled()) {
+ IMarker marker = breakpoint.getMarker();
+ if (marker != null) {
+
+ String name = marker.getResource()
+ .getLocation().toOSString();
+ if (name.equals(PHPDebugUtils
+ .unescapeString(filename))
+ && (lineBreakpoint.getLineNumber() == lineNumber)) {
+ fThread
+ .setBreakpoints(new IBreakpoint[] { breakpoint });
+ break;
+ }
+ }
+
+ }
+ } catch (CoreException e) {
+ }
+ }
+ }
+ }
+ }
+ suspended(DebugEvent.BREAKPOINT);
+ }
+
+ public void handleDebugEvents(DebugEvent[] events) {
+ for (int i = 0; i < events.length; i++) {
+ DebugEvent event = events[i];
+ if ((event.getKind() == DebugEvent.CREATE)
+ && (event.getSource() instanceof XDebugElement)) {
+ if (((XDebugElement) event.getSource()).getModelIdentifier() == IXDebugConstants.ID_PHP_DEBUG_MODEL) {
+ if (event.getKind() == DebugEvent.CREATE)
+ started();
+ }
+ }
+ }
+
+ }
+}
\ No newline at end of file
git://git.phpeclipse.com / phpeclipse.git / blobdiff