/**

 * 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;

			}