debug/org.eclipse.ptp.debug.core/pdi/org/eclipse/ptp/debug/internal/core/pdi/model/Thread.java - ptp/org.eclipse.ptp - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 The Regents of the University of California.
  * This material was produced under U.S. Government contract W-7405-ENG-36
  * for Los Alamos National Laboratory, which is operated by the University
  * of California for the U.S. Department of Energy. The U.S. Government has
  * rights to use, reproduce, and distribute this software. NEITHER THE
  * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
  * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
  * to produce derivative works, such modified software should be clearly marked,
  * so as not to confuse it with the version available from LANL.
  *
  * Additionally, this program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * LA-CC 04-115
  *******************************************************************************/
 package org.eclipse.ptp.debug.internal.core.pdi.model;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.ptp.debug.core.pdi.IPDILocator;
 import org.eclipse.ptp.debug.core.pdi.IPDISession;
 import org.eclipse.ptp.debug.core.pdi.PDIException;
 import org.eclipse.ptp.debug.core.pdi.SessionObject;
 import org.eclipse.ptp.debug.core.pdi.manager.IPDIRegisterManager;
 import org.eclipse.ptp.debug.core.pdi.manager.IPDIVariableManager;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrame;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrameDescriptor;
 import org.eclipse.ptp.debug.core.pdi.model.IPDITarget;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIThread;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorage;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorageDescriptor;
 import org.eclipse.ptp.debug.core.pdi.request.IPDIGetStackInfoDepthRequest;
 import org.eclipse.ptp.debug.core.pdi.request.IPDIListStackFramesRequest;
 import org.eclipse.ptp.debug.core.pdi.request.IPDISetCurrentStackFrameRequest;

 /**
  * @author clement
  *
  */
 public class Thread extends SessionObject implements IPDIThread {
 	private static IPDIStackFrame[] noStack = new IPDIStackFrame[0];
 	private int id;
 	private String name;
 	private IPDIStackFrame currentFrame = null;
 	private List<IPDIStackFrame> currentFrames = null;
 	private int stackdepth = 0;
 	private IPDITarget target = null;

 	public Thread(IPDISession session, IPDITarget target, int threadId) {
 		this(session, target, threadId, null);
 	}

 	public Thread(IPDISession session, IPDITarget target, int threadId, String threadName) {
 		super(session, target.getTasks());
 		this.id = threadId;
 		this.name = threadName;
 		this.target = target;
 	}

 	/**
 	 *
 	 */
 	public void clearState() {
 		stackdepth = 0;
 		currentFrame = null;
 		currentFrames = null;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#createThreadStorage(org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorageDescriptor)
 	 */
 	public IPDIThreadStorage createThreadStorage(IPDIThreadStorageDescriptor varDesc) throws PDIException {
 		if (varDesc instanceof ThreadStorageDescriptor) {
 			IPDIVariableManager varMgr = session.getVariableManager();
 			return varMgr.createThreadStorage((ThreadStorageDescriptor)varDesc);
 		}
 		return null;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#equals(org.eclipse.ptp.debug.core.pdi.model.IPDIThread)
 	 */
 	public boolean equals(IPDIThread thread) {
 		if (thread instanceof Thread) {
 			Thread pthread = (Thread) thread;
 			return id == pthread.getId();
 		}
 		return super.equals(thread);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getCurrentStackFrame()
 	 */
 	public IPDIStackFrame getCurrentStackFrame() throws PDIException {
 		if (currentFrame == null) {
 			IPDIStackFrame[] frames = getStackFrames(0, 0);
 			if (frames.length > 0) {
 				currentFrame = (StackFrame)frames[0];
 			}
 		}
 		return currentFrame;
 	}

 	/**
 	 * @return
 	 */
 	public int getId() {
 		return id;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrameCount()
 	 */
 	public int getStackFrameCount() throws PDIException {
 		if (stackdepth == 0) {
 			Target target = (Target)getTarget();
 			IPDIThread currentThread = (IPDIThread)target.getCurrentThread();
 			target.lockTarget();
 			try {
 				target.setCurrentThread(this, false);
 				IPDIGetStackInfoDepthRequest request = session.getRequestFactory().getGetStackInfoDepthRequest(getTasks());
 				session.getEventRequestManager().addEventRequest(request);
 				stackdepth = request.getDepth(getTasks());
 			}
 			finally {
 				target.setCurrentThread(currentThread, false);
 				target.releaseTarget();
 			}
 		}
 		return stackdepth;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrames()
 	 */
 	public IPDIStackFrame[] getStackFrames() throws PDIException {
 		int depth = getStackFrameCount();

 		// refresh if we have nothing or if we have just a subset get everything.
 		if (currentFrames == null || currentFrames.size() < depth) {
 			currentFrames = new ArrayList<IPDIStackFrame>();
 			Target target = (Target)getTarget();
 			IPDIThread currentThread = (IPDIThread)target.getCurrentThread();
 			target.lockTarget();
 			try {
 				target.setCurrentThread(this, false);
 				IPDIListStackFramesRequest request = session.getRequestFactory().getListStackFramesRequest(session, getTasks());
 				session.getEventRequestManager().addEventRequest(request);
 				IPDIStackFrameDescriptor[] frames = request.getStackFrames(getTasks());
 				for (IPDIStackFrameDescriptor frame : frames) {
 					IPDILocator locator = frame.getLocator();
 					currentFrames.add(session.getModelFactory().newStackFrame(session, this, depth - frame.getLevel(),
 							locator.getFile(), locator.getFunction(), locator.getLineNumber(), locator.getAddress()));
 				}
 			} finally {
 				target.setCurrentThread(currentThread, false);
 				target.releaseTarget();
 			}
 			// assign the currentFrame if it was not done yet.
 			if (currentFrame == null) {
 				for (int i = 0; i < currentFrames.size(); i++) {
 					IPDIStackFrame stack = (IPDIStackFrame) currentFrames.get(i);
 					if (stack.getLevel() == depth) {
 						currentFrame = (StackFrame)stack;
 					}
 				}
 			}
 		}
 		return (IPDIStackFrame[]) currentFrames.toArray(noStack);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrames(int, int)
 	 */
 	public IPDIStackFrame[] getStackFrames(int low, int high) throws PDIException {
 		if (currentFrames == null || currentFrames.size() < high) {
 			currentFrames = new ArrayList<IPDIStackFrame>();
 			Target target = (Target)getTarget();
 			IPDIThread currentThread = target.getCurrentThread();
 			target.lockTarget();
 			try {
 				target.setCurrentThread(this, false);
 				int depth = getStackFrameCount();
 				int upperBound;
 				if (high < depth) {
 					upperBound = Math.min(depth, STACKFRAME_DEFAULT_DEPTH);
 				}
 				else {
 					upperBound = depth;
 				}
 				IPDIListStackFramesRequest request = session.getRequestFactory().getListStackFramesRequest(session,
 						getTasks(), 0, upperBound);
 				session.getEventRequestManager().addEventRequest(request);
 				IPDIStackFrameDescriptor[] frames = request.getStackFrames(getTasks());
 				for (IPDIStackFrameDescriptor frame : frames) {
 					IPDILocator locator = frame.getLocator();
 					currentFrames.add(session.getModelFactory().newStackFrame(session, this, depth - frame.getLevel(),
 							locator.getFile(), locator.getFunction(), locator.getLineNumber(), locator.getAddress()));
 				}
 			} finally {
 				target.setCurrentThread(currentThread, false);
 				target.releaseTarget();
 			}
 			if (currentFrame == null) {
 				for (int i=0; i<currentFrames.size(); i++) {
 					StackFrame f = (StackFrame)currentFrames.get(i);
 					if (f.getLevel() == 0) {
 						currentFrame = f;
 					}
 				}
 			}
 		}
 		List<IPDIStackFrame> list = ((high - low + 1) <= currentFrames.size()) ? currentFrames.subList(low, high + 1) : currentFrames;
 		return (IPDIStackFrame[])list.toArray(noStack);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getTarget()
 	 */
 	public IPDITarget getTarget() {
 		return target;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getThreadStorageDescriptors()
 	 */
 	public IPDIThreadStorageDescriptor[] getThreadStorageDescriptors() throws PDIException {
 		IPDIVariableManager varMgr = session.getVariableManager();
 		return varMgr.getThreadStorageDescriptors(this);
 	}

 	public void setCurrentStackFrame(IPDIStackFrame stackframe) throws PDIException {
 		currentFrame = stackframe;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#setCurrentStackFrame(org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrame, boolean)
 	 */
 	public void setCurrentStackFrame(IPDIStackFrame stackframe, boolean doUpdate) throws PDIException {
 		int frameLevel = 0;
 		if (stackframe != null) {
 			frameLevel = stackframe.getLevel();
 		}
 		// Check to see if we are already at this level
 		if (currentFrame != null && currentFrame.getLevel() == frameLevel) {
 			if (stackframe != null) {
 				Thread aThread = (Thread)stackframe.getThread();
 				if (aThread != null && aThread.getId() == getId()) {
 					return;
 				}
 			}
 		}
 		Target target = (Target)getTarget();
 		int level = getStackFrameCount() - frameLevel;
 		target.lockTarget();
 		try {
 			target.setCurrentThread(this, doUpdate);
 			IPDISetCurrentStackFrameRequest request = session.getRequestFactory().getSetCurrentStackFrameRequest(getTasks(), level);
 			session.getEventRequestManager().addEventRequest(request);
 			request.waitUntilCompleted(getTasks());
 			currentFrame = stackframe;
 			if (doUpdate) {
 				IPDIRegisterManager regMgr = session.getRegisterManager();
 				if (regMgr.isAutoUpdate()) {
 					regMgr.update(target.getTasks());
 				}
 				IPDIVariableManager varMgr = session.getVariableManager();
 				if (varMgr.isAutoUpdate()) {
 					varMgr.update(target.getTasks());
 				}
 			}
 		}
 		finally {
 			target.releaseTarget();
 		}
 	}

 	/* (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString() {
 		String str = Integer.toString(id);
 		if (name != null) {
 			str += " " + name;
 		}
 		return str;
 	}

 	/**
 	 *
 	 */
 	public void updateState() {
 		try {
 			getCurrentStackFrame();
 		} catch (PDIException e) {}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005 The Regents of the University of California.
	* This material was produced under U.S. Government contract W-7405-ENG-36
	* for Los Alamos National Laboratory, which is operated by the University
	* of California for the U.S. Department of Energy. The U.S. Government has
	* rights to use, reproduce, and distribute this software. NEITHER THE
	* GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
	* ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
	* to produce derivative works, such modified software should be clearly marked,
	* so as not to confuse it with the version available from LANL.
	*
	* Additionally, this program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* LA-CC 04-115
	*******************************************************************************/
	package org.eclipse.ptp.debug.internal.core.pdi.model;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.ptp.debug.core.pdi.IPDILocator;
	import org.eclipse.ptp.debug.core.pdi.IPDISession;
	import org.eclipse.ptp.debug.core.pdi.PDIException;
	import org.eclipse.ptp.debug.core.pdi.SessionObject;
	import org.eclipse.ptp.debug.core.pdi.manager.IPDIRegisterManager;
	import org.eclipse.ptp.debug.core.pdi.manager.IPDIVariableManager;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrame;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrameDescriptor;
	import org.eclipse.ptp.debug.core.pdi.model.IPDITarget;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIThread;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorage;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorageDescriptor;
	import org.eclipse.ptp.debug.core.pdi.request.IPDIGetStackInfoDepthRequest;
	import org.eclipse.ptp.debug.core.pdi.request.IPDIListStackFramesRequest;
	import org.eclipse.ptp.debug.core.pdi.request.IPDISetCurrentStackFrameRequest;

	/**
	* @author clement
	*
	*/
	public class Thread extends SessionObject implements IPDIThread {
	private static IPDIStackFrame[] noStack = new IPDIStackFrame[0];
	private int id;
	private String name;
	private IPDIStackFrame currentFrame = null;
	private List<IPDIStackFrame> currentFrames = null;
	private int stackdepth = 0;
	private IPDITarget target = null;

	public Thread(IPDISession session, IPDITarget target, int threadId) {
	this(session, target, threadId, null);
	}

	public Thread(IPDISession session, IPDITarget target, int threadId, String threadName) {
	super(session, target.getTasks());
	this.id = threadId;
	this.name = threadName;
	this.target = target;
	}

	/**
	*
	*/
	public void clearState() {
	stackdepth = 0;
	currentFrame = null;
	currentFrames = null;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#createThreadStorage(org.eclipse.ptp.debug.core.pdi.model.IPDIThreadStorageDescriptor)
	*/
	public IPDIThreadStorage createThreadStorage(IPDIThreadStorageDescriptor varDesc) throws PDIException {
	if (varDesc instanceof ThreadStorageDescriptor) {
	IPDIVariableManager varMgr = session.getVariableManager();
	return varMgr.createThreadStorage((ThreadStorageDescriptor)varDesc);
	}
	return null;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#equals(org.eclipse.ptp.debug.core.pdi.model.IPDIThread)
	*/
	public boolean equals(IPDIThread thread) {
	if (thread instanceof Thread) {
	Thread pthread = (Thread) thread;
	return id == pthread.getId();
	}
	return super.equals(thread);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getCurrentStackFrame()
	*/
	public IPDIStackFrame getCurrentStackFrame() throws PDIException {
	if (currentFrame == null) {
	IPDIStackFrame[] frames = getStackFrames(0, 0);
	if (frames.length > 0) {
	currentFrame = (StackFrame)frames[0];
	}
	}
	return currentFrame;
	}

	/**
	* @return
	*/
	public int getId() {
	return id;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrameCount()
	*/
	public int getStackFrameCount() throws PDIException {
	if (stackdepth == 0) {
	Target target = (Target)getTarget();
	IPDIThread currentThread = (IPDIThread)target.getCurrentThread();
	target.lockTarget();
	try {
	target.setCurrentThread(this, false);
	IPDIGetStackInfoDepthRequest request = session.getRequestFactory().getGetStackInfoDepthRequest(getTasks());
	session.getEventRequestManager().addEventRequest(request);
	stackdepth = request.getDepth(getTasks());
	}
	finally {
	target.setCurrentThread(currentThread, false);
	target.releaseTarget();
	}
	}
	return stackdepth;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrames()
	*/
	public IPDIStackFrame[] getStackFrames() throws PDIException {
	int depth = getStackFrameCount();

	// refresh if we have nothing or if we have just a subset get everything.
	if (currentFrames == null \|\| currentFrames.size() < depth) {
	currentFrames = new ArrayList<IPDIStackFrame>();
	Target target = (Target)getTarget();
	IPDIThread currentThread = (IPDIThread)target.getCurrentThread();
	target.lockTarget();
	try {
	target.setCurrentThread(this, false);
	IPDIListStackFramesRequest request = session.getRequestFactory().getListStackFramesRequest(session, getTasks());
	session.getEventRequestManager().addEventRequest(request);
	IPDIStackFrameDescriptor[] frames = request.getStackFrames(getTasks());
	for (IPDIStackFrameDescriptor frame : frames) {
	IPDILocator locator = frame.getLocator();
	currentFrames.add(session.getModelFactory().newStackFrame(session, this, depth - frame.getLevel(),
	locator.getFile(), locator.getFunction(), locator.getLineNumber(), locator.getAddress()));
	}
	} finally {
	target.setCurrentThread(currentThread, false);
	target.releaseTarget();
	}
	// assign the currentFrame if it was not done yet.
	if (currentFrame == null) {
	for (int i = 0; i < currentFrames.size(); i++) {
	IPDIStackFrame stack = (IPDIStackFrame) currentFrames.get(i);
	if (stack.getLevel() == depth) {
	currentFrame = (StackFrame)stack;
	}
	}
	}
	}
	return (IPDIStackFrame[]) currentFrames.toArray(noStack);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getStackFrames(int, int)
	*/
	public IPDIStackFrame[] getStackFrames(int low, int high) throws PDIException {
	if (currentFrames == null \|\| currentFrames.size() < high) {
	currentFrames = new ArrayList<IPDIStackFrame>();
	Target target = (Target)getTarget();
	IPDIThread currentThread = target.getCurrentThread();
	target.lockTarget();
	try {
	target.setCurrentThread(this, false);
	int depth = getStackFrameCount();
	int upperBound;
	if (high < depth) {
	upperBound = Math.min(depth, STACKFRAME_DEFAULT_DEPTH);
	}
	else {
	upperBound = depth;
	}
	IPDIListStackFramesRequest request = session.getRequestFactory().getListStackFramesRequest(session,
	getTasks(), 0, upperBound);
	session.getEventRequestManager().addEventRequest(request);
	IPDIStackFrameDescriptor[] frames = request.getStackFrames(getTasks());
	for (IPDIStackFrameDescriptor frame : frames) {
	IPDILocator locator = frame.getLocator();
	currentFrames.add(session.getModelFactory().newStackFrame(session, this, depth - frame.getLevel(),
	locator.getFile(), locator.getFunction(), locator.getLineNumber(), locator.getAddress()));
	}
	} finally {
	target.setCurrentThread(currentThread, false);
	target.releaseTarget();
	}
	if (currentFrame == null) {
	for (int i=0; i<currentFrames.size(); i++) {
	StackFrame f = (StackFrame)currentFrames.get(i);
	if (f.getLevel() == 0) {
	currentFrame = f;
	}
	}
	}
	}
	List<IPDIStackFrame> list = ((high - low + 1) <= currentFrames.size()) ? currentFrames.subList(low, high + 1) : currentFrames;
	return (IPDIStackFrame[])list.toArray(noStack);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getTarget()
	*/
	public IPDITarget getTarget() {
	return target;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#getThreadStorageDescriptors()
	*/
	public IPDIThreadStorageDescriptor[] getThreadStorageDescriptors() throws PDIException {
	IPDIVariableManager varMgr = session.getVariableManager();
	return varMgr.getThreadStorageDescriptors(this);
	}

	public void setCurrentStackFrame(IPDIStackFrame stackframe) throws PDIException {
	currentFrame = stackframe;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.model.IPDIThread#setCurrentStackFrame(org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrame, boolean)
	*/
	public void setCurrentStackFrame(IPDIStackFrame stackframe, boolean doUpdate) throws PDIException {
	int frameLevel = 0;
	if (stackframe != null) {
	frameLevel = stackframe.getLevel();
	}
	// Check to see if we are already at this level
	if (currentFrame != null && currentFrame.getLevel() == frameLevel) {
	if (stackframe != null) {
	Thread aThread = (Thread)stackframe.getThread();
	if (aThread != null && aThread.getId() == getId()) {
	return;
	}
	}
	}
	Target target = (Target)getTarget();
	int level = getStackFrameCount() - frameLevel;
	target.lockTarget();
	try {
	target.setCurrentThread(this, doUpdate);
	IPDISetCurrentStackFrameRequest request = session.getRequestFactory().getSetCurrentStackFrameRequest(getTasks(), level);
	session.getEventRequestManager().addEventRequest(request);
	request.waitUntilCompleted(getTasks());
	currentFrame = stackframe;
	if (doUpdate) {
	IPDIRegisterManager regMgr = session.getRegisterManager();
	if (regMgr.isAutoUpdate()) {
	regMgr.update(target.getTasks());
	}
	IPDIVariableManager varMgr = session.getVariableManager();
	if (varMgr.isAutoUpdate()) {
	varMgr.update(target.getTasks());
	}
	}
	}
	finally {
	target.releaseTarget();
	}
	}

	/* (non-Javadoc)
	* @see java.lang.Object#toString()
	*/
	public String toString() {
	String str = Integer.toString(id);
	if (name != null) {
	str += " " + name;
	}
	return str;
	}

	/**
	*
	*/
	public void updateState() {
	try {
	getCurrentStackFrame();
	} catch (PDIException e) {}
	}
	}