/**

  * Debugger

  *

  * @author Roman Blazevic

  * @version 970326

  */

 package xelfi.debugger;

 import java.io.IOException;

 import java.util.*;

 import java.awt.Color;

 import java.awt.Panel;

 import xelfi.util.EnhProperties;

 import xelfi.top.*;

 import xelfi.editor.*;

 import xelfi.xedit.JavaEditorFrame;

 import xelfi.compiler.Output;

 import xelfi.execution.RunOptions;

 //import symantec.tools.debug.*; // doesn't need TCP/IP

 /**

  * This is a main class of the Xelfi debugger.

  * It is also a document on which several views can exist

  * (LocalsView, CallStackView and ThreadsView).

  */

 public class Debugger implements DebuggerCallback, BackgroundCallback, XFColorCallback, XelfiOptions

 {

 	private DebuggerOptions options;

 	private Vector remoteDebuggers;

 	private boolean debuggingSession; // just debugging

 	private RemoteDebugger remoteDebugger;

 	private RemoteThreadGroup currentThreadGroup;

 	private RemoteThread currentThread;

 	private Watches watches;

 	private Breakpoints breakpoints;

 	private LocalsView localsView;

 	private CallStackView callStackView;

 	private ThreadsView threadsView;

 	private Position currentPosition = null; //some position on the current line

 	private Breakpoint temporaryBreakpoint = null; //used "while going to cursor"

 	// bude se delat trochu jinak

 	private Color currentLineBackgroundColor;

 	private Color breakpointLineBackgroundColor;

 	private Color currentLineForegroundColor;

 	private Color breakpointLineForegroundColor;

 	private Color foregroundColor; // filled in getBackground()

 	private boolean canEnableGoFlag = true;

 	private boolean canEnableGoToCursorFlag = true;

 	/**

 	 * Debugger constructor.

 	 */

 	public Debugger()

 	{

 		options = new DebuggerOptions();

 		remoteDebuggers = new Vector();

 		watches = new Watches(this);

 		breakpoints = new Breakpoints(this);

 		localsView = new LocalsView(this);

 		callStackView = new CallStackView(this);

 		threadsView = new ThreadsView(this);

 		remoteDebugger = null;

 		currentThreadGroup = null;

 		currentThread = null;

 		debuggingSession = false;

 		XFColor.addCallback(this);

 		TopLevel.addOption(this);

 	}

 	/**

 	 * Implementation of the breakpointEvent from the DebuggerCallback

 	 */

 	public void breakpointEvent(RemoteThread t) throws Exception

 	{

 		canEnableGoFlag = true;

 		canEnableGoToCursorFlag = true;

 		TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugTraceInto);

 		RemoteStackFrame[] stack = t.dumpStack();

 		if (stack.length > 0)

 		{

 			//TopLevel.getOutput().println(stack[0].toString());

 			currentThread = t;

 		}

 		else

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("invalid thread specified in breakpoint");

 		}

 		if (getCurrentStackFrameIndex() == stack.length-1)

 		{

 			internalFinishDebugging(); // nebo vyber dalsi thread, ktery je na breakpointu;

 			return;

 		}

 		String className = new String();

 		try

 		{

 			// try to find out the class name and the line number on which we has stopped

 			StringTokenizer st = new StringTokenizer(stack[0].toString(), ".()");

 			int lineNumber = -1;

 			int nTokens = st.countTokens();

 			for(int i = 3; i < nTokens; i++) // n-3 times

 				className = className+st.nextToken()+".";

 			className += st.nextToken();

 			st.nextToken();

 			st.nextToken(":");

 			lineNumber = Integer.valueOf(st.nextToken(":)")).intValue();

 			// decide if we have stopped on the temporary breakpoint

 			if (temporaryBreakpoint != null)

 				if (lineNumber == temporaryBreakpoint.getLineNumber()

 					&& className.equals(temporaryBreakpoint.getClassName()))

 				{

 					// destroy the temporary breakpoint

 					int numberOfBreakpoints = breakpoints.getNumberOfBreakpoints();

 					boolean canDestroy = true;

 					for(int i = 0; i < numberOfBreakpoints; i++)

 					{

 						Breakpoint breakpoint = breakpoints.getBreakpoint(i);

 						if (breakpoint.getLineNumber() == temporaryBreakpoint.getLineNumber()

 							&& breakpoint.getClassName() == temporaryBreakpoint.getClassName()

 							&& breakpoint.isEnabled() && breakpoint.isValid())

 							canDestroy = false;

 					}

 					if (canDestroy)

 					{

 						boolean success = true; // breakpoint was successfully removed from the remoteDebugger (if exists)

 						try

 						{

 							RemoteClass rc = remoteDebugger.findClass(className);

 									String result;

 							if (rc != null)

 							{

 								result = rc.clearBreakpointLine(lineNumber);

 										if (!result.equals(""))

 											success = false;

 							}

 							else

 								success = false;

 						}

 						catch(Exception e)

 						{

 							e.printStackTrace();

 							success = false;

 						}

 						// if the breakpoint was succesfully removed from the debugger, we must also remove breakpoint

 						// line (if exists)

 						if (!success)

 						{

 							TopLevel.getOutput().show();

 							TopLevel.getOutput().println("temporary breakpoint \""+className+":"+lineNumber+"\" cannot be removed");

 						}

 						else

 							temporaryBreakpoint = null;

 					}

 				}

 			// get a source and a position on which we have stopped

 			Source s = null;

 			s = new Source(className, false);

 			//JARDA - az Jaroslav opravi editor, nebude se mazat current line

 			//Position oldPosition = currentPosition;

 			currentPosition = TopLevel.getCurrentSnapshot().getPosition(s, lineNumber-1).beginOfLine();

 			JavaEditorFrame jef = TopLevel.showEditor(s, currentPosition, true);

 			//if (oldPosition != null)

 			//	Block.line(oldPosition).redraw();

 			Block.line(currentPosition).redraw();

 		}

 		catch (IOException e)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("class '"+className+"' not found");

 		}

 		catch (NoSuchElementException e)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("cannot get debug info for the class '"+className+"'");

 			TopLevel.getOutput().println("    ( is the class compiled with the -g option? )");

 		}

 		watches.updateContent();

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 		threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 		//threadsView.highlightThread(t);

 	}

 	/**

 	 * Implementation of the exceptionEvent from the DebuggerCallback

 	 */

 	public void exceptionEvent(RemoteThread t, String s) throws Exception

 	{

 		Output output = TopLevel.getOutput();

 		output.show();

 		output.println("exception in thread \""+t.getName()+"\": "+s);

 	}

 	/**

 	 * Implementation of the threadDeathEvent from the DebuggerCallback

 	 */

 	public void threadDeathEvent(RemoteThread t)

 	{

 		if (t == currentThread)

 			internalFinishDebugging();

 		else

 			threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Implementation of the quitEvent from the DebuggerCallback

 	 */

 	public void quitEvent()

 	{

 		internalFinishDebugging();

 	}

 	/**

 	 * Implementation of the printToConsole from the DebuggerCallback

 	 */

 	public synchronized void printToConsole(String s)

 	{

 		TopLevel.getOutput().println(s);

 	}

 	/**

 	 * Implementation of the getForeground method from the BackgroundCallback

 	 */

 	public Color getForeground()

 	{

 		return foregroundColor;

 	}

 	/**

 	 * Implementation of the getBackground method from the BackgroundCallback

 	 */

 	// musi se delat efektivneji - nejlepe hashovat , zatim se to dela v O(n) !!!

 	public Color getBackground(Position p)

 	{

 		if (debuggingSession)

 			if (currentPosition != null)

 				if (p.sameLine(currentPosition))

 				{

 					foregroundColor = currentLineForegroundColor;

 					return currentLineBackgroundColor;

 				}

 		// jeste se musime podivat, zda to neni breakpoint line

 		PositionInfo pInfo = TopLevel.getCurrentSnapshot().getPositionInfo(p);

 		String className = pInfo.getSource().getName();

 		int lineNumber = pInfo.getLine();

 		int numberOfBreakpoints = breakpoints.getNumberOfBreakpoints();

 		for(int i = 0; i < numberOfBreakpoints; i++)

 			if (breakpoints.getBreakpoint(i).getLineNumber()-1 == lineNumber)

 				if (breakpoints.getBreakpoint(i).getClassName().compareTo(className) == 0)

 					if (breakpoints.getBreakpoint(i).isValid() && breakpoints.getBreakpoint(i).isEnabled())

 					{

 						foregroundColor = breakpointLineForegroundColor;

 						return breakpointLineBackgroundColor;

 					}

 		return null;

 	}

 	/**

 	 * Implementation of the colorsChanged from the XFColorCallback

 	 */

 	public void colorsChanged()

 	{

 	   currentLineBackgroundColor = XFColor.getBgColor(XFColor.CurrentLine);

 		currentLineForegroundColor = XFColor.getFgColor(XFColor.CurrentLine);

 		breakpointLineBackgroundColor = XFColor.getBgColor(XFColor.BreakpointLine);

 		breakpointLineForegroundColor = XFColor.getFgColor(XFColor.BreakpointLine);

 	}

 	/**

 	 * Implementation of the loadProperies from the XelfiOptions

 	 */

 	public void loadProperties(EnhProperties properties)

 	{

 		options.getProperties(properties);

 		watches.getProperties(properties);

 		breakpoints.getProperties(properties);

 	}

 	/**

 	 * Implementation of the storeProperties from the XelfiOptions

 	 */

 	public void storeProperties(EnhProperties properties)

 	{

 		options.putProperties(properties);

 		watches.putProperties(properties);

 		breakpoints.putProperties(properties);

 	}

 	/**

 	 * Implementation of the getPanel from the XelfiOptions

 	 */

 	public Panel getPanel()

 	{

 		return new DebuggerOptionsPanel(options);

 	}

 	/**

 	 * Implementation of the getTabName from the XelfiOptions

 	 */

 	public String getTabName()

 	{

 		return "Debug";

 	}

 	/**

 	 * Implementation of the onOK from the XelfiOptions

 	 */

 	public void onOK(Panel p)

 	{

 		options = ((DebuggerOptionsPanel)p).getDebuggerOptions();

 		watches.updateContent();

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Handles Debug|Go command.

 	 */

 	public void go()

 	{

 		canEnableGoFlag = false;

 		canEnableGoToCursorFlag = false;

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceInto);

 		if (!debuggingSession)

 		{

 			try

 			{

 				if (!initDebuggingSession())

 				{

 					finishDebugging();

 					/*canEnableGoFlag = false;

 					canEnableGoToCursorFlag = false;

 					TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 					TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);*/

 					return;

 				}

 				if (remoteDebugger.listBreakpoints().length == 0)

 					if (!setDefaultBreakpoint())

 					{

 						finishDebugging();

 						/*canEnableGoFlag = false;

 						canEnableGoToCursorFlag = false;

 						TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 						TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);*/

 						return;

 					}

                             StringTokenizer st = new StringTokenizer(RunOptions.getArguments());

                             int nTokens = st.countTokens();

                             String args[] = new String[1+nTokens];

                             args[0] = new String(getClassToDebug());

                             for(int i = 1; i <= nTokens; i++)

                                 args[i] = st.nextToken();

                             currentThreadGroup = remoteDebugger.run(1+nTokens, args);

 			    // setThread(1);

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 			};

 		}

 		else

 		{

 			if (currentThread == null)

 			{

 				System.err.println("nothing suspended");

 				return;

 			}

 			try

 			{

 				currentThread.cont();

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 			};

 			currentThread.resetCurrentFrameIndex();

 		}

 		// JARDA - dokud Jarda neopravi, bude se to delat az v breakpointEvent

 		// decolor the current line

 		if (currentPosition != null)

 		{

 			Position oldPosition = currentPosition;

 			currentPosition = null;

 			Block.line(oldPosition).redraw();

 		}

 	}

 	/**

 	 * Handles Debug|GoToCursor command.

 	 */

 	public void goToCursor(Source s, Position p)

 	{

 		canEnableGoFlag = false;

 		canEnableGoToCursorFlag = false;

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceInto);

 		if (!debuggingSession)

 		{

 			try

 			{

 				if (!initDebuggingSession())

 				{

 					canEnableGoFlag = false;

 					canEnableGoToCursorFlag = false;

 					TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 					TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);

 					return;

 				}

 				setTemporaryBreakpoint(s, p);

                             StringTokenizer st = new StringTokenizer(RunOptions.getArguments());

                             int nTokens = st.countTokens();

                             String args[] = new String[1+nTokens];

                             args[0] = new String(getClassToDebug());

                             for(int i = 1; i <= nTokens; i++)

                                 args[i] = st.nextToken();

                             currentThreadGroup = remoteDebugger.run(1+nTokens, args);

                             // setThread(1);

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 			};

 		}

 		else

 		{

 			if (currentThread == null)

 			{

 				System.err.println("nothing suspended");

 				return;

 			}

 			try

 			{

 				setTemporaryBreakpoint(s, p);

 				currentThread.cont();

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 			};

 			currentThread.resetCurrentFrameIndex();

 		}

 		// JARDA - dokud Jarda neopravi, bude se to delat az v breakpointEvent

 		// decolor the current line

 		if (currentPosition != null)

 		{

 			Position oldPosition = currentPosition;

 			currentPosition = null;

 			Block.line(oldPosition).redraw();

 		}

 	}

 	void internalFinishDebugging()

 	{

 		canEnableGoFlag = true;

 		canEnableGoToCursorFlag = true;

 		Position oldPosition = currentPosition;

 		doneDebuggingSession(false);

 		currentPosition = null;

 		if (oldPosition != null)

 			Block.line(oldPosition).redraw();

 		watches.updateContent();

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 		threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Handles Debug|FinishDebugging command.

 	 */

 	public void finishDebugging()

 	{

 		canEnableGoFlag = true;

 		canEnableGoToCursorFlag = true;

 		Position oldPosition = currentPosition;

 		doneDebuggingSession(true);

 		currentPosition = null;

 		if (oldPosition != null)

 			Block.line(oldPosition).redraw();

 		watches.updateContent();

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 		threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Handles Debug|RestartDebugging command.

 	 */

 	public void restartDebugging()

 	{

 		try

 		{

 			finishDebugging();

 			go();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		}

 	}

 	/**

 	 * Handles Debug|TraceOver command.

 	 */

 	public void traceOver()

 	{

 		canEnableGoFlag = false;

 		canEnableGoToCursorFlag = false;

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceInto);

 		if (currentThread == null)

 		{

 			System.err.println("nothing suspended");

 			return;

 		}

 		try

 		{

 			currentThread.next();

 		}

 		catch(IllegalAccessError e)

 		{

 			//"Current thread is not at breakpoint."

 			e.printStackTrace();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		}

 	// JARDA - dokud Jarda neopravi, bude se to delat az v breakpointEvent

 		// decolor the current line

 		if (currentPosition != null)

 		{

 			Position oldPosition = currentPosition;

 			currentPosition = null;

 			Block.line(oldPosition).redraw();

 		}

 	}

 	/**

 	 * Handles Debug|TraceInto command.

 	 */

 	public void traceInto()

 	{

 		canEnableGoFlag = false;

 		canEnableGoToCursorFlag = false;

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().disableItem(MainMenu.miDebugTraceInto);

 		if (currentThread == null)

 		{

 			System.err.println("nothing suspended");

 			return;

 		}

 		try

 		{

 			currentThread.step(true);

 		}

 		catch(IllegalAccessError e)

 		{

 			//"Current thread is not at breakpoint."

 			e.printStackTrace();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		}

 		// JARDA - dokud Jarda neopravi, bude se to delat az v breakpointEvent

 		// decolor the current line

 		if (currentPosition != null)

 		{

 			Position oldPosition = currentPosition;

 			currentPosition = null;

 			Block.line(oldPosition).redraw();

 		}

 	}

 	/**

 	 * Handles Debug|ToggleBreakpoint command.

 	 */

 	public void toggleBreakpoint(Source s, Position p)

 	{

 		PositionInfo pInfo = TopLevel.getCurrentSnapshot().getPositionInfo(p);

 		String className = pInfo.getSource().getName();

 		int lineNumber = pInfo.getLine()+1;

 		int numberOfBreakpoints = breakpoints.getNumberOfBreakpoints();

 		int index = -1;

 		for(int i = 0; i < numberOfBreakpoints; i++)

 		{

 			Breakpoint breakpoint = breakpoints.getBreakpoint(i);

 			if (className.equals(breakpoint.getClassName()) &&

 				lineNumber == breakpoint.getLineNumber())

 			{

 				index = i;

 				break; // breakpoint is already set

 			}

 		}

 		if (index == -1)

 			breakpoints.addBreakpoint(new Breakpoint(className, lineNumber));

 		else

 			breakpoints.removeBreakpoint(index);

 	}

 	/**

 	 * Handles Debug|AddWatch command.

 	 */

 	public void addWatch()

 	{

 		watches.getView().addWatch();

 	}

 	/**

 	 * Initializes the debugging session.

 	 * Returns false if it is not possible to continue (don't know which class to start).

 	 */

 	boolean initDebuggingSession() throws Exception

 	{

 		TopLevel.getOutput().clear();

 		if (getClassToDebug().equals(""))

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("don't know which class to start");

 			return false;

 		}

 		TopLevel.getMenu().enableItem(MainMenu.miDebugFinish);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugRestart);

 		try

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("debugger session is starting ...");

 			remoteDebugger = new RemoteDebugger("", this, false);

 			remoteDebuggers.addElement(remoteDebugger);

 			TopLevel.getOutput().clear();

 			TopLevel.getOutput().println("debugger session has started");

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		}

 		int numberOfBreakpoints = breakpoints.getNumberOfBreakpoints();

 		debuggingSession = true;

 		for(int i = 0; i < numberOfBreakpoints; i++)

 		{

 			Breakpoint breakpoint = breakpoints.getBreakpoint(i);

 			if (breakpoint.isEnabled())

 				addBreakpoint(breakpoint);

 		}

 		breakpoints.updateContent();

 		return true;

 	}

 	/**

 	 * Closes the debugging session.

 	 */

 	void doneDebuggingSession(boolean closeDebugger)

 	{

 		try

 		{

 			if (remoteDebugger != null)

 			{

 				// stop all threads

 				RemoteThreadGroup[] rtg = getThreadGroups();

 				if (rtg != null)

 					for(int i = 0; i < rtg.length; i++)

 					{

 						try

 						{

 							//without system thread group

 							if (rtg[i].getName().equals("system"))

 								continue;

 							RemoteThread rt[] = rtg[i].listThreads(true);

 							if (rt == null)

 								continue;

 							for(int j = 0; j < rt.length; j++)

 								if (rt[j] != null)

 									rt[j].stop();

 						}

 						catch(Exception e)

 						{

 							//e.printStackTrace();

 						}

 					}

              if (closeDebugger)

              {

                  remoteDebugger.close();

                  remoteDebuggers.removeElement(remoteDebugger);

              }

              else

                  remoteDebuggers.removeElement(remoteDebugger);

 				if (debuggingSession)

 				{

 					debuggingSession = false;

 					TopLevel.getOutput().show();

 					TopLevel.getOutput().println("debugger session has finished");

 				}

 				currentThread = null;

 				currentThreadGroup = null;

 				remoteDebugger = null;

 			}

 			TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 			TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);

 			TopLevel.getMenu().disableItem(MainMenu.miDebugFinish);

 			TopLevel.getMenu().disableItem(MainMenu.miDebugRestart);

 			TopLevel.getMenu().disableItem(MainMenu.miDebugTraceOver);

 			TopLevel.getMenu().disableItem(MainMenu.miDebugTraceInto);

 		}

 		catch(Exception e)

 		{ }

 	}

 	/**

 	 * This method is called by the CallStackView when

 	 * a stack frame is chosen.

 	 */

 	void stackFrameChosen(RemoteStackFrame rsf)

 	{

 		String className = null;

 		try

 		{

 			RemoteStackFrame.Name rc = rsf.getRemoteClass();

 			if (rc == null)

 				System.out.println("invalid stack frame");

 			try

 			{

 				className = rc.getName();

 			}

 			catch(Exception e)

 			{

 				className = null;

 				e.printStackTrace();

 			}

 			int lineNumber = rsf.getLineNumber();

 			if (className == null)

 				System.out.println("invalid class name");

 			// get a source and a position

     		Source s = new Source(className, false);

 			Position p = TopLevel.getCurrentSnapshot().getPosition(s, lineNumber-1).beginOfLine();

 			TopLevel.showEditor(s, p, true);

 		}

 		catch (IOException e)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("source code for class '"+className+"' not found");

 		}

 	}

 	/**

 	 * Called when final clean up is neccessary.

 	 */

 	public void shutdown()

 	{

 		for(int i = 0; i < remoteDebuggers.size(); i++)

 		{

 			try

 			{

 				remoteDebugger = (RemoteDebugger)remoteDebuggers.elementAt(i);

 				// stop all threads

 				RemoteThreadGroup[] rtg = getThreadGroups();

 				if (rtg != null)

 					for(int k = 0; k < rtg.length; k++)

 					{

 						try

 						{

 							//without system thread group

 							if (rtg[k].getName().equals("system"))

 								continue;

 							RemoteThread rt[] = rtg[k].listThreads(true);

 							if (rt == null)

 								continue;

 							for(int j = 0; j < rt.length; j++)

 								if (rt[j] != null)

 									rt[j].stop();

 						}

 						catch(Exception e)

 						{

 							e.printStackTrace();

 						}

 					}

             remoteDebugger.close();

             remoteDebuggers.removeElement(remoteDebugger);

 				//((RemoteDebugger)remoteDebuggers.elementAt(i)).close();

 			}

 			catch(Exception e)

 			{

 				//e.printStackTrace();

 				//because some RemoteDebuggers are already closed

          }

 		}

 	}

 	/**

 	 * Sets the default breakpoint (on method <main class>.main).

 	 */

 	boolean setDefaultBreakpoint()

 	{

 		boolean success = true; // breakpoint was successfully added into the remoteDebugger (if exists)

 		try

 		{

 			RemoteClass rc = remoteDebugger.findClass(getClassToDebug());

 			String result;

 			if (rc != null)

 			{

 				RemoteField rf = rc.getMethod("main");

 				if (rf != null)

 				{

 					result = rc.setBreakpointMethod(rf);;

 					if (!result.equals(""))

 						success = false;

 				}

 				else

 					success = false;

 			}

 			else

 				success = false;

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 			success = false;

 		}

 		if (!success)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("default breakpoint \""+getClassToDebug()+".main\" cannot be set");

 			TopLevel.getOutput().println("    ( is the class compiled with the -g option? )");

 			return false;

 		}

 		else

 			return true;

 	}

 	/**

 	 * Sets the temporary breakpoint.

 	 */

 	void setTemporaryBreakpoint(Source s, Position p)

 	{

 		PositionInfo pInfo = TopLevel.getCurrentSnapshot().getPositionInfo(p);

 		String className = pInfo.getSource().getName();

 		int lineNumber = pInfo.getLine()+1;

 		boolean success = true; // breakpoint was successfully added into the remoteDebugger (if exists)

 		try

 		{

 			RemoteClass rc = remoteDebugger.findClass(className);

 			String result;

 		if (rc != null)

 		{

 			result = rc.setBreakpointLine(lineNumber);

 			if (!result.equals(""))

 			{

 				rc.clearBreakpointLine(lineNumber);

 				success = false;

 			}

 		}

 		else

 			success = false;

 		}

 	catch(Exception e)

 	{

 		e.printStackTrace();

 		success = false;

 	}

 	if (!success)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("temporary breakpoint \""+className+":"+lineNumber+"\" cannot be set");

 			temporaryBreakpoint = null;

 		}

 		else

 			temporaryBreakpoint = new Breakpoint(className, lineNumber);

 	}

 	/**

 	 * Returns true if the debugger allows to enable the Debug|Go command.

 	 */

 	public boolean canEnableGo()

 	{

 		return canEnableGoFlag;

 	}

 	/**

 	 * Returns true if the debugger allows to enable the Debug|GoToCursor command.

 	 */

 	public boolean canEnableGoToCursor()

 	{

 		return canEnableGoToCursorFlag;

 	}

 	/**

 	 * Called by the LocalsView class after its instance has been shown.

 	 */

 	void localsViewShown()

 	{

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Called by the CallStackView class after its instance has been shown.

 	 */

 	void callStackViewShown()

 	{

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Called by the ThreadsView class after its instance has been shown.

 	 */

 	void threadsViewShown()

 	{

 		threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 	}

 	/**

 	 * Returns the current value of the variable specified by the name variableName

 	 */

 	String getCurrentValue(String variableName)

 	{

 		if (!debuggingSession)

 			return "is not defined";

 		if (currentThread == null)

 			return "is not defined";

 		try

 		{

 			StringTokenizer st = new StringTokenizer(variableName, ".[]", true);

 			if (!st.hasMoreTokens())

 				return "invalid expression";

   			String token = st.nextToken();

 			RemoteStackVariable rsv = currentThread.getStackVariable(token);

 			if (rsv == null)

 				return "is not defined";

 			if (!rsv.inScope())

 				return "is not in scope.";

 			RemoteValue obj = rsv.getValue();

 			if (obj == null)

 				return "null"; // is it correct?

 			while (st.hasMoreTokens())

 			{

 				token = st.nextToken();

 				if (token.equals("["))

 				{

 					if (!st.hasMoreTokens())

 						return "index missing";

 					token = st.nextToken();

 					if (!st.hasMoreTokens())

 						return "invalid expression";

 					if (!st.nextToken().equals("]"))

 						return "invalid expression";

 					int index;

 					try

 					{

 						try

 						{

 							index = Integer.valueOf(token).intValue();

 						}

 						catch (NumberFormatException e)

 						{

 							index = Integer.valueOf(getCurrentValue(token)).intValue();

 						}

 						obj = ((RemoteArray)obj).getElement(index);

 						if (obj == null)

 							return "null"; // is it correct?

 					}

 					catch (NumberFormatException e)

 					{

 						return "invalid index";

 					}

 					catch (ArrayIndexOutOfBoundsException e)

 					{

 						return "out of bounds";

 					}

 					catch (ClassCastException e)

 					{

 						return "is not an array element";

 					}

 				}

 				if (token.equals("."))

 				{

 					if (!st.hasMoreTokens())

 						return "field missing";

 					token = st.nextToken();

 					try

 					{

 						obj = ((RemoteObject)obj).getFieldValue(token);

 						if (obj == null)

 							return "null"; // is it correct?

 					}

 					catch (ClassCastException e)

 					{

 						return "is not a class field";

 					}

 				}

 			}

 			return getCurrentValue(obj, options.getDepthOfRecursiveWatching());

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 			return "";

 		}

 	}

 	/**

 	 * Returns the string containing a value of the RemoteValue instance.

 	 * Depth - how deep we can scan the value (it must be 0 at least).

 	 */

 	String getCurrentValue(RemoteValue obj, int depth)

 	{

 		if (obj == null)

 			return "null";

 		if (obj instanceof RemoteChar)

 			return "'"+obj.toString()+"'";

 		if (obj instanceof RemoteString)

 			return "\""+obj.toString()+"\"";

 		if (obj instanceof RemoteArray)

 		{

 			if (depth == 0)

 				return "[...]"; // don't continue in recursive watching

 			RemoteValue elements[];

 			try

 			{

 				elements = ((RemoteArray)obj).getElements();

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 				return "?";

 			}

 			String returnValue = "[";

 			for(int i = 0; i < elements.length-1; i++)

 				if (options.showArrayIndexes())

 					returnValue += i+": "+getCurrentValue(elements[i], depth-1)+", ";

 				else

 					returnValue += getCurrentValue(elements[i], depth-1)+", ";

 			if (elements.length > 0)

 				if (options.showArrayIndexes())

 					returnValue += (elements.length-1)+": "+getCurrentValue(elements[elements.length-1], depth-1)+"]";

 				else

 					returnValue += getCurrentValue(elements[elements.length-1], depth-1)+"]";

 			else

 				returnValue += "]";

 			return returnValue;

 		}

 		if (obj instanceof RemoteObject)

 		{

 			if (depth == 0)

 				return "{...}"; // don't continue in recursive watching

 			RemoteObject ro = (RemoteObject)obj;

 			RemoteField fields[];

 			try

 			{

 				fields = ro.getFields();

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 				return "?";

 			}

 			String returnValue = "{";

 			String fieldName;

 			RemoteValue fieldValue;

 			if (fields.length == 0)

 				return returnValue+"}";

 			for(int i = 0; i < fields.length-1; i++)

 			{

 				fieldName = fields[i].getName();

 				try

 				{

 					fieldValue = ro.getFieldValue(fieldName);

 					returnValue += fieldName+": "+getCurrentValue(fieldValue, depth-1)+", ";

 				}

 				catch(Exception e)

 				{

 					returnValue += fieldName+": ?, ";

 				}

 			}

 			fieldName = fields[fields.length-1].getName();

 			try

 			{

 				fieldValue = ro.getFieldValue(fieldName);

 				returnValue = returnValue+fieldName+": "+getCurrentValue(fieldValue, depth-1)+"}";

 			}

 			catch(Exception e)

 			{

 				returnValue = returnValue+fieldName+": ?}";

 			}

 			return returnValue;

 		}

 		// process the RemoteThread and RemoteTreadGroup instances

 		// ...

 		return obj.toString();

 	}

 	/**

 	 * Returns the name of the class which will be started in the debugger

 	 * (or "").

 	 */

 	String getClassToDebug()

         {

 		String returnValue = RunOptions.getMainClass();

 		if (returnValue != null)

 			return returnValue;

 		else

 			return "";

 	}

 	/**

 	 * This method is called by the Breakpoints class after a breakpoint

 	 * has been added into the breakpoints document or after a breakpoint

 	 * has been successfully enabled in the breakpoints document.

 	 * This method can change the breakpoint state from valid to invalid

 	 * if it can not be added into the remote debugger.

 	 * This method is also called by the Debugger class while the debugging session is starting.

 	 */

 	void addBreakpoint(Breakpoint breakpoint)

 	{

 		boolean success = true; // breakpoint was successfully added into the remoteDebugger (if exists)

 		if (debuggingSession)

 		{

 			try

 			{

 				RemoteClass rc = remoteDebugger.findClass(breakpoint.getClassName());

 				String result;

 				if (rc != null)

 				{

 					result = rc.setBreakpointLine(breakpoint.getLineNumber());

 					if (!result.equals(""))

 					{

 						rc.clearBreakpointLine(breakpoint.getLineNumber());

 						success = false;

 					}

 				}

 				else

 					success = false;

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 				success = false;

 			}

 		}

 		// if the breakpoint was succesfully enabled or added into the remote debugger,

 		// we must also add breakpoint line (if possible)

 		if (!success)

 		{

 			breakpoint.setInvalid();

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("breakpoint \""+breakpoint.getClassName()+":"+breakpoint.getLineNumber()+"\" cannot be set");

 			try

 			{

 				Position breakpointPosition;

 				JavaEditorFrame jef = TopLevel.findEditor(breakpoint.getClassName());

 				if (jef != null)

 				{

 					breakpointPosition = TopLevel.getCurrentSnapshot().getPosition(jef.getSource(), breakpoint.getLineNumber()-1);

 					Block.line(breakpointPosition).redraw();

 				}

 			}

 			catch (Exception e)

 			{

 				// mozna by se vyjimka mela jenom sezrat

 				e.printStackTrace();

 			}

 		}

 		else

 		{

 			breakpoint.setValid();

 			try

 			{

 				Position breakpointPosition;

 				JavaEditorFrame jef = TopLevel.findEditor(breakpoint.getClassName());

 				if (jef != null)

 				{

 					breakpointPosition = TopLevel.getCurrentSnapshot().getPosition(jef.getSource(), breakpoint.getLineNumber()-1);

 					Block.line(breakpointPosition).redraw();

 				}

 			}

 			catch (Exception e)

 			{

 				// mozna by se vyjimka mela jenom sezrat

 				e.printStackTrace();

 			}

 		}

 	}

 	/**

 	 * This method is called by the Breakpoints class after a breakpoint

 	 * has been removed or disabled in the breakpoints document.

 	 */

 	void removeBreakpoint(String className, int lineNumber)

 	{

 		boolean success = true; // breakpoint was successfully removed from the remoteDebugger (if exists)

 		if (debuggingSession)

 		{

 			try

 			{

 				RemoteClass rc = remoteDebugger.findClass(className);

 				String result;

 				if (rc != null)

 				{

 					result = rc.clearBreakpointLine(lineNumber);

 					if (!result.equals(""))

 						success = false;

 				}

 				else

 					success = false;

 			}

 			catch(Exception e)

 			{

 				e.printStackTrace();

 				success = false;

 			}

 		}

 		// if the breakpoint was succesfully removed from the debugger, we must also remove breakpoint

 		// line (if exists)

 		if (success)

 		{

 			try

 			{

 				Position breakpointPosition;

 				JavaEditorFrame jef = TopLevel.findEditor(className);

 				if (jef != null)

 				{

 					breakpointPosition = TopLevel.getCurrentSnapshot().getPosition(jef.getSource(), lineNumber-1);

 					Block.line(breakpointPosition).redraw();

 				}

 			}

 			catch (Exception e)

 			{

 				// mozna by se vyjimka mela jenom sezrat

 				e.printStackTrace();

 			}

 		}

 	}

 	/**

 	 * Returns the stack frames of the current thread

 	 */

 	RemoteStackFrame[] getCurrentStackFrames()

 	{

 		RemoteStackFrame[] rsf = null;

 		if (currentThread == null)

 			return null;

 		try

 		{

 			rsf = currentThread.dumpStack();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		}

 		return rsf;

 	}

 	/**

 	 * Returns the stack frame index of the current thread

 	 */

 	int getCurrentStackFrameIndex()

 	{

 		if (currentThread == null)

 			return -1;

 		return currentThread.getCurrentFrameIndex();

 	}

 	/**

 	 * Returns the stack variables of the current thread

 	 */

 	RemoteStackVariable[] getStackVariables()

 	{

 		RemoteStackVariable[] rsv = null;

 		if (currentThread == null)

 			return null;

 		try

 		{

 			rsv = currentThread.getStackVariables();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		};

 		return rsv;

 	}

 	/**

 	 * Returns the current stack frame of the current thread

 	 */

 	RemoteStackFrame getCurrentStackFrame()

 	{

 		RemoteStackFrame rsf = null;

 		if (currentThread == null)

 			return null;

 		try

 		{

 			 rsf = currentThread.getCurrentFrame();

 		}

 		catch(Exception e)

 		{

 			 e.printStackTrace();

 		};

 		return rsf;

 	}

 	/**

 	 * Returns the thread groups

 	 */

 	RemoteThreadGroup[] getThreadGroups()

 	{

 		RemoteThreadGroup[] rtg = null;

 		if (remoteDebugger == null)

 			return null;

 		try

 		{

 			rtg = remoteDebugger.listThreadGroups(null);

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 		};

 		return rtg;

 	}

 	/**

 	 * Returns the current thread

 	 */

 	RemoteThread getCurrentThread()

 	{

 		return currentThread;

 	}

 	/**

 	 * Returns the Watches document

 	 */

 	public Watches getWatches()

 	{

 		return watches;

 	}

 	/**

 	 * Returns the Breakpoints document

 	 */

 	public Breakpoints getBreakpoints()

 	{

 		return breakpoints;

 	}

 	/**

 	 * Returns the LocalsView on the Debugger

 	 */

 	public LocalsView getLocalsView()

 	{

 		return localsView;

 	}

 	/**

 	 * Returns the CallStackView on the Debugger

 	 */

 	public CallStackView getCallStackView()

 	{

 		return callStackView;

 	}

 	/**

 	 * Returns the ThreadsView on the Debugger

 	 */

 	public ThreadsView getThreadsView()

 	{

 		return threadsView;

 	}

 	////////////////////////////////////////////////////////////////

 	/*	void threadChosen(RemoteThreadGroup tg, RemoteThread t)

 	{

 		canEnableGoFlag = true;

 		canEnableGoToCursorFlag = true;

 		TopLevel.getMenu().enableItem(MainMenu.miDebugGo);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugGoCursor);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugTraceOver);

 		TopLevel.getMenu().enableItem(MainMenu.miDebugTraceInto);

 		RemoteStackFrame[] stack;

 		try

 		{

 			stack = t.dumpStack();

 		}

 		catch(Exception e)

 		{

 			e.printStackTrace();

 			return;

 		}

 		currentThreadGroup = tg;

 		if (stack.length > 0)

 		{

 			for(int i = 0; i < stack.length; i++)

 			{

 				System.out.println(i+"   "+stack[i].toString());

 			}

 			currentThread = t;

 		}

 		else

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("invalid thread specified in breakpoint");

 		}

 		StringTokenizer st = new StringTokenizer(stack[getCurrentStackFrameIndex()].toString(), ".()");

 		String className = new String();

 		int lineNumber = -1;

 		int nTokens = st.countTokens();

 		for(int i = 3; i < nTokens; i++) // n-3 times

 			className = className+st.nextToken()+".";

 		className += st.nextToken();

 		st.nextToken();

 		st.nextToken(":");

 		lineNumber = Integer.valueOf(st.nextToken(":)")).intValue();

 		try

 		{

 			// get a source and a position on which we stopped

 			Source s = null;

 			s = new Source(className, false);

 	// JARDA - az Jaroslav opravi editor, nebude se mazat current line

 			Position oldPosition = currentPosition;

 			currentPosition = TopLevel.getCurrentSnapshot().getPosition(s, lineNumber-1).beginOfLine();

 			JavaEditorFrame jef = TopLevel.showEditor(s, currentPosition, true);

 			if (oldPosition != null)

 				Block.line(oldPosition).redraw();

 			Block.line(currentPosition).redraw();

 		}

 		catch (IOException e)

 		{

 			TopLevel.getOutput().show();

 			TopLevel.getOutput().println("class '"+className+"' not found");

 		}

 		watches.updateContent();

 		localsView.update(LocalsView.HINT_COMPLETE_UPDATE, -1);

 		callStackView.update(CallStackView.HINT_COMPLETE_UPDATE, -1);

 		threadsView.update(ThreadsView.HINT_COMPLETE_UPDATE, -1);

 		//	threadsView.highlightThread(t);

 	}

 	/**

 	 * Returns the current value of the variable specified by the name variableName

 	 * The argument i indexes the current stack frame of the current thread.

 	 */

 	/*	    String getCurrentValue(String variableName, int i)

 	{

 		String returnValue;

 		if (currentThread == null)

 			return "is not defined";

 		int currentIndex = currentThread.getCurrentFrameIndex();

 		currentThread.resetCurrentFrameIndex();

 		currentThread.setCurrentFrameIndex(currentIndex);

 		returnValue = getCurrentValue(variableName);

 		currentThread.setCurrentFrameIndex(currentIndex);

 		currentThread.resetCurrentFrameIndex();

 		return returnValue;

 	}*/

 	public void currentSnapshotHasChanged(Snapshot oldSnapshot)

 	{

 		int numberOfBreakpoints = breakpoints.getNumberOfBreakpoints();

 		for(int i = 0; i < numberOfBreakpoints; i++)

 		{

 			try

 			{

 				Breakpoint breakpoint = breakpoints.getBreakpoint(i);

 				Source s = new Source(breakpoint.getClassName());

 				Position position = oldSnapshot.getPosition(s, breakpoint.getLineNumber()-1).beginOfLine();

 				PositionInfo pi = TopLevel.getCurrentSnapshot().getPositionInfo(position);

 				breakpoint.setLineNumber(pi.getLine()+1);

 			}

 			catch(Exception e)

 			{

 				//e.printStackTrace();

 			}

 		}

 		breakpoints.updateContent();

 	}

 }