flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aha...@apache.org
Subject [14/27] fdb with worker support
Date Sat, 26 Apr 2014 03:39:35 GMT
http://git-wip-us.apache.org/repos/asf/flex-sdk/blob/a3765ae5/modules/fdbworkers/src/flex/tools/debugger/cli/DebugCLI.java
----------------------------------------------------------------------
diff --git a/modules/fdbworkers/src/flex/tools/debugger/cli/DebugCLI.java b/modules/fdbworkers/src/flex/tools/debugger/cli/DebugCLI.java
new file mode 100644
index 0000000..588a977
--- /dev/null
+++ b/modules/fdbworkers/src/flex/tools/debugger/cli/DebugCLI.java
@@ -0,0 +1,7567 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package flex.tools.debugger.cli;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.LineNumberReader;
+import java.io.PrintStream;
+import java.io.StringReader;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Properties;
+import java.util.Set;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+import flash.localization.LocalizationManager;
+import flash.tools.debugger.Bootstrap;
+import flash.tools.debugger.DebuggerLocalizer;
+import flash.tools.debugger.Frame;
+import flash.tools.debugger.InProgressException;
+import flash.tools.debugger.Isolate;
+import flash.tools.debugger.IsolateSession;
+import flash.tools.debugger.Location;
+import flash.tools.debugger.NoResponseException;
+import flash.tools.debugger.NotConnectedException;
+import flash.tools.debugger.NotSupportedException;
+import flash.tools.debugger.NotSuspendedException;
+import flash.tools.debugger.PlayerDebugException;
+import flash.tools.debugger.Session;
+import flash.tools.debugger.SessionManager;
+import flash.tools.debugger.SourceFile;
+import flash.tools.debugger.SourceLocator;
+import flash.tools.debugger.SuspendReason;
+import flash.tools.debugger.SuspendedException;
+import flash.tools.debugger.SwfInfo;
+import flash.tools.debugger.Value;
+import flash.tools.debugger.Variable;
+import flash.tools.debugger.VariableAttribute;
+import flash.tools.debugger.VariableType;
+import flash.tools.debugger.VersionException;
+import flash.tools.debugger.Watch;
+import flash.tools.debugger.WatchKind;
+import flash.tools.debugger.concrete.DProtocol;
+import flash.tools.debugger.events.BreakEvent;
+import flash.tools.debugger.events.ConsoleErrorFault;
+import flash.tools.debugger.events.DebugEvent;
+import flash.tools.debugger.events.ExceptionFault;
+import flash.tools.debugger.events.FaultEvent;
+import flash.tools.debugger.events.FileListModifiedEvent;
+import flash.tools.debugger.events.FunctionMetaDataAvailableEvent;
+import flash.tools.debugger.events.IsolateCreateEvent;
+import flash.tools.debugger.events.IsolateExitEvent;
+import flash.tools.debugger.events.SwfLoadedEvent;
+import flash.tools.debugger.events.SwfUnloadedEvent;
+import flash.tools.debugger.events.TraceEvent;
+import flash.tools.debugger.expression.ECMA;
+import flash.tools.debugger.expression.NoSuchVariableException;
+import flash.tools.debugger.expression.PlayerFaultException;
+import flash.tools.debugger.expression.ValueExp;
+import flash.util.FieldFormat;
+import flash.util.Trace;
+import flex.tools.debugger.cli.ExpressionCache.EvaluationResult;
+import flex.tools.debugger.cli.FaultActions.FaultActionsBuilder;
+
+/**
+ * This is a front end command line interface to the Flash Debugger
+ * Player.
+ *<p>
+ * This tool utilizes the Debugger Java API (DJAPI) for Flash 
+ * Player that exists in flash.tools.debuggger.
+ *<p> 
+ * This tool is not completely compliant with the API, since
+ * some commands expose implementation specific information for
+ * debugging purposes.  Instances where this occurs are kept to a
+ * minimum and are isolated in a special class called Extensions.  
+ * If you wish to build a version that is completely API 
+ * compatible.  Replace Extensions with ExtensionsDisabled in 
+ * the static method calls at the end of this file. 
+ */
+public class DebugCLI implements Runnable, SourceLocator
+{
+	public static final String VERSION			= "82"; //$NON-NLS-1$
+
+	public static final int CMD_UNKNOWN			= 0;
+	public static final int CMD_QUIT			= 1;
+	public static final int CMD_CONTINUE		= 2;
+	public static final int CMD_STEP			= 3;
+	public static final int CMD_NEXT			= 4;
+	public static final int CMD_FINISH			= 5;
+	public static final int CMD_BREAK			= 6;
+	public static final int CMD_SET				= 7;
+	public static final int CMD_LIST			= 8;
+	public static final int CMD_PRINT			= 9;
+	public static final int CMD_TUTORIAL		= 10;
+	public static final int CMD_INFO			= 11;
+	public static final int CMD_HOME			= 12;
+	public static final int CMD_RUN				= 13;
+	public static final int CMD_FILE			= 14;
+	public static final int CMD_DELETE			= 15;
+	public static final int CMD_SOURCE			= 16;
+	public static final int CMD_COMMENT			= 17;
+	public static final int CMD_CLEAR			= 18;
+	public static final int CMD_HELP			= 19;
+	public static final int CMD_SHOW			= 20;
+	public static final int CMD_KILL			= 21;
+	public static final int CMD_HANDLE			= 22;
+	public static final int CMD_ENABLE			= 23;
+	public static final int CMD_DISABLE			= 24;
+	public static final int CMD_DISPLAY			= 25;
+	public static final int CMD_UNDISPLAY		= 26;
+ 	public static final int CMD_COMMANDS		= 27;
+    public static final int CMD_PWD             = 28;
+    public static final int CMD_CF              = 29;
+    public static final int CMD_CONDITION		= 30;
+	public static final int CMD_AWATCH			= 31;
+	public static final int CMD_WATCH			= 32;
+	public static final int CMD_RWATCH			= 33;
+	public static final int CMD_WHAT			= 34;
+	public static final int CMD_DISASSEMBLE		= 35;
+	public static final int CMD_HALT			= 36;
+	public static final int CMD_MCTREE			= 37;
+	public static final int CMD_VIEW_SWF		= 38;
+	public static final int CMD_DOWN			= 39;
+	public static final int CMD_UP				= 40;
+	public static final int CMD_FRAME			= 41;
+	public static final int CMD_DIRECTORY		= 42;
+	public static final int CMD_CATCH			= 43;
+	public static final int CMD_CONNECT			= 44;
+	public static final int CMD_WORKER			= 45;
+
+	/* info sub commands */
+	public static final int INFO_UNKNOWN_CMD	= 100;
+	public static final int INFO_ARGS_CMD		= 101;
+	public static final int INFO_BREAK_CMD		= 102;
+	public static final int INFO_FILES_CMD		= 103;
+	public static final int INFO_HANDLE_CMD		= 104;
+	public static final int INFO_FUNCTIONS_CMD	= 105;
+	public static final int INFO_LOCALS_CMD		= 106;
+	public static final int INFO_SCOPECHAIN_CMD	= 107;
+	public static final int INFO_SOURCES_CMD	= 108;
+	public static final int INFO_STACK_CMD		= 109;
+	public static final int INFO_VARIABLES_CMD	= 110;
+	public static final int INFO_DISPLAY_CMD	= 111;
+    public static final int INFO_TARGETS_CMD    = 112;
+    public static final int INFO_SWFS_CMD		= 113;
+    public static final int INFO_WORKERS_CMD	= 114;
+
+	/* show subcommands */
+	public static final int SHOW_UNKNOWN_CMD	= 200;
+	public static final int SHOW_NET_CMD		= 201;
+	public static final int SHOW_FUNC_CMD		= 202;
+	public static final int SHOW_URI_CMD		= 203;
+	public static final int SHOW_PROPERTIES_CMD	= 204;
+	public static final int SHOW_FILES_CMD		= 205;
+	public static final int SHOW_BREAK_CMD		= 206;
+	public static final int SHOW_VAR_CMD		= 207;
+	public static final int SHOW_MEM_CMD		= 208;
+	public static final int SHOW_LOC_CMD		= 209;
+	public static final int SHOW_DIRS_CMD		= 210;
+
+	/* misc subcommands */
+	public static final int ENABLE_ONCE_CMD		= 301;
+
+    // default metadata retry count 8 attempts per waitForMetadata() call * 5 calls
+    public static final int METADATA_RETRIES    = 8*5;
+    
+    /* Enum for the state of the initial prompt shown when a swf is loaded */
+    public static enum InitialPromptState { NEVER_SHOWN, SHOWN_ONCE, DONE }  
+
+	Stack<LineNumberReader> m_readerStack = new Stack<LineNumberReader>();
+	public PrintStream m_err;
+	public PrintStream m_out;
+	Session		m_session;
+	String		m_launchURI;
+	boolean		m_fullnameOption; // emacs mode
+	String		m_cdPath;
+	String		m_mruURI;
+	String m_connectPort;
+	public final static String m_newline = System.getProperty("line.separator"); //$NON-NLS-1$
+
+	private final static LocalizationManager m_localizationManager = new LocalizationManager();
+	private final static FaultActionsBuilder faultActionsBuilder = new FaultActionsBuilder(m_localizationManager);
+	
+	List<String>	m_sourceDirectories; // List of String
+	int				m_sourceDirectoriesChangeCount;
+	private File	m_flexHomeDirectory; // <application.home>/frameworks/projects/*/src always goes in m_sourceDirectories
+	private boolean	m_initializedFlexHomeDirectory;
+
+	// context information for our current session
+	FileInfoCache	m_fileInfo;
+	FaultActions	m_faultTable;
+	Vector<Integer> m_breakIsolates;
+	ExpressionCache m_exprCache;
+	Vector<BreakAction>	        m_breakpoints;
+	Vector<WatchAction>			m_watchpoints;
+	Vector<CatchAction>			m_catchpoints;
+	ArrayList<DisplayAction>	m_displays;
+//	boolean			m_requestResume;
+//	boolean			m_requestHalt;
+//	boolean			m_stepResume;
+	int m_activeIsolate;
+	DebugCLIIsolateState m_mainState;
+	
+	/* This indicates the isolate for which we have been showing prompts for setting 
+	 * breakpoints( so that we don't switch worker while the user is setting breakpoints) */
+	int m_lastPromptIsolate;
+	
+	private HashMap<Integer, DebugCLIIsolateState> m_isolateState;
+	
+	class DebugCLIIsolateState
+	{
+//		public FileInfoCache	m_fileInfo;
+//		public ExpressionCache m_exprCache;
+		public boolean			m_requestResume;
+		public boolean			m_requestHalt;
+		public boolean			m_stepResume;
+		/* Indicates whether the prompt for setting initial breakpoints has been displayed for this isolate */
+		public InitialPromptState			m_promptState;
+//		public Vector<BreakAction>	        m_breakpoints;
+//		public Vector<WatchAction>			m_watchpoints;
+//		public Vector<CatchAction>			m_catchpoints;
+//		public ArrayList<DisplayAction>	m_displays;
+
+		
+		public DebugCLIIsolateState(DebugCLI debugcli) {
+//			m_exprCache = new ExpressionCache(debugcli);
+			m_faultTable = faultActionsBuilder.build();//new FaultActions();
+//			m_breakpoints = new Vector<BreakAction>();
+//			m_watchpoints = new Vector<WatchAction>();
+//			m_catchpoints = new Vector<CatchAction>();
+//			m_displays = new ArrayList<DisplayAction>();
+		}
+	}
+	
+	private DebugCLIIsolateState getIsolateState(int isolateId) {
+		if (isolateId == Isolate.DEFAULT_ID)
+			return m_mainState;
+		DebugCLIIsolateState isolateState = null;
+		if (!m_isolateState.containsKey(isolateId)) {
+			isolateState = new DebugCLIIsolateState(this);
+			m_isolateState.put(isolateId, isolateState);
+		}
+		else
+			isolateState = m_isolateState.get(isolateId);
+		return isolateState;
+	}
+	
+	public int getActiveIsolateId() {
+		return m_activeIsolate;
+	}
+	
+	private boolean getRequestResume(int isolateId) {
+		return getIsolateState(isolateId).m_requestResume;
+	}
+	
+	private void setRequestResume(boolean value, int isolateId) {
+		getIsolateState(isolateId).m_requestResume = value;
+	}
+	
+	private boolean getStepResume(int isolateId) {
+		return getIsolateState(isolateId).m_stepResume;
+	}
+	
+	private void setStepResume(boolean value, int isolateId) {
+		getIsolateState(isolateId).m_stepResume = value;
+	}
+	
+	private boolean getRequestHalt(int isolateId) {
+		return getIsolateState(isolateId).m_requestHalt;
+	}
+	
+	private void setRequestHalt(boolean value, int isolateId) {
+		getIsolateState(isolateId).m_requestHalt = value;
+	}
+	
+	private InitialPromptState getPromptState(int isolateId) {
+		return getIsolateState(isolateId).m_promptState;
+	}
+	
+	private void setPromptState(InitialPromptState value, int isolateId) {
+		getIsolateState(isolateId).m_promptState = value;
+	}
+
+	/* our current input processing context */
+	LineNumberReader	m_in;
+	public LineNumberReader	m_keyboardStream;
+	Vector<String>		m_keyboardInput;
+	boolean				m_keyboardReadRequest;
+	StringTokenizer		m_currentTokenizer;
+	String				m_currentToken;
+	String				m_currentLine;
+	public String		m_repeatLine;	
+
+	/**
+	 * The module that the next "list" command should display if no
+	 * module is explicitly specified.
+	 */
+	public static final String LIST_MODULE = "$listmodule"; //$NON-NLS-1$
+
+	/**
+	 * The line number at which the next "list" command should begin if no
+	 * line number is explicitly specified.
+	 */
+	public static final String LIST_LINE = "$listline"; //$NON-NLS-1$
+	
+	public static final String LIST_WORKER = "$listworker"; //$NON-NLS-1$
+
+	/**
+	 * The number of lines displayed by the "list" command.
+	 */
+	private static final String LIST_SIZE = "$listsize"; //$NON-NLS-1$
+
+	private static final String COLUMN_WIDTH = "$columnwidth"; //$NON-NLS-1$
+
+	private static final String UPDATE_DELAY = "$updatedelay"; //$NON-NLS-1$
+
+	private static final String HALT_TIMEOUT = "$halttimeout"; //$NON-NLS-1$
+
+	/**
+	 * Current breakpoint number.
+	 */
+	private static final String BPNUM = "$bpnum"; //$NON-NLS-1$
+
+	/**
+	 * Used to determine how much context information should be displayed.
+	 */
+	private static final String LAST_FRAME_DEPTH = "$lastframedepth"; //$NON-NLS-1$
+
+	/**
+	 * Used to determine how much context information should be displayed.
+	 */
+	private static final String CURRENT_FRAME_DEPTH = "$currentframedepth"; //$NON-NLS-1$
+
+	/**
+	 * The current frame we are viewing -- controlled by the "up", "down", and "frame" commands.
+	 */
+	public static final String DISPLAY_FRAME_NUMBER = "$displayframenumber"; //$NON-NLS-1$
+
+	private static final String FILE_LIST_WRAP = "$filelistwrap"; //$NON-NLS-1$
+
+	private static final String NO_WAITING = "$nowaiting"; //$NON-NLS-1$
+
+	/**
+	 * Show this pointer for info stack.
+	 */
+	private static final String INFO_STACK_SHOW_THIS = "$infostackshowthis"; //$NON-NLS-1$
+
+	/**
+	 * Number of milliseconds to wait for metadata.
+	 */
+	private static final String METADATA_ATTEMPTS_PERIOD = "$metadataattemptsperiod"; //$NON-NLS-1$
+
+	private static final String METADATA_NOT_AVAILABLE = "$metadatanotavailable"; //$NON-NLS-1$
+
+	/**
+	 * How many times we should try to get metadata.
+	 */
+	private static final String METADATA_ATTEMPTS = "$metadataattempts"; //$NON-NLS-1$
+
+	private static final String PLAYER_FULL_SUPPORT = "$playerfullsupport"; //$NON-NLS-1$
+
+	/**
+	 * Whether the "print" command will display attributes of members.
+	 */
+	public static final String DISPLAY_ATTRIBUTES = "$displayattributes"; //$NON-NLS-1$
+	
+	/* class's static init */
+	static
+	{
+        // set up for localizing messages
+        m_localizationManager.addLocalizer( new DebuggerLocalizer("flex.tools.debugger.cli.fdb.") ); //$NON-NLS-1$
+	}
+
+	public static void main(String[] args)
+	{
+		DebugCLI cli = new DebugCLI();
+
+		/* attach our 'main' input method and out/err*/
+		cli.m_err = System.err;
+		cli.m_out = System.out;
+
+		// get the default <application.home>/projects/frameworks/*/src entries into the source path
+		cli.initSourceDirectoriesList();
+
+		// a big of wrangling for our keyboard input stream since its special
+		cli.m_keyboardStream = new LineNumberReader(new InputStreamReader(System.in));
+		cli.pushStream(cli.m_keyboardStream);
+
+		/* iterate through the args list */
+		cli.processArgs(args);
+
+		/* figure out $HOME and the current directory */
+		String userHome = System.getProperty("user.home"); //$NON-NLS-1$
+		String userDir = System.getProperty("user.dir"); //$NON-NLS-1$
+
+		/*
+		 * If the current directory is not $HOME, and a .fdbinit file exists in the current directory,
+		 * then push it onto the stack of files to read.
+		 * 
+		 * Note, we want ./.fdbinit to be read AFTER $HOME/.fdbinit, but we push them in reverse
+		 * order, because they're going onto a stack.  If we push them in reverse order, then they
+		 * will be read in the correct order (last one pushed is the first one read).
+		 */
+		if (userDir != null && !userDir.equals(userHome))
+		{
+			try
+			{
+				FileReader sr = new FileReader(new File(userDir, ".fdbinit")); //$NON-NLS-1$
+				cli.pushStream( new LineNumberReader(sr) );
+			}
+			catch(FileNotFoundException fnf) {}
+		}
+
+		/*
+		 * If a .fdbinit file exists in the $HOME directory, then push it onto the stack of files
+		 * to read.
+		 * 
+		 * Note, we want ./.fdbinit to be read AFTER $HOME/.fdbinit, but we push them in reverse
+		 * order, because they're going onto a stack.  If we push them in reverse order, then they
+		 * will be read in the correct order (last one pushed is the first one read).
+		 */
+		if (userHome != null)
+		{
+			try
+			{
+				FileReader sr = new FileReader(new File(userHome, ".fdbinit")); //$NON-NLS-1$
+				cli.pushStream( new LineNumberReader(sr) );
+			}
+			catch(FileNotFoundException fnf) {}
+		}
+
+		cli.execute();
+	}
+
+	public DebugCLI()
+	{
+		m_fullnameOption = false;
+		m_faultTable = faultActionsBuilder.build();
+		m_exprCache = new ExpressionCache(this);
+		m_breakpoints = new Vector<BreakAction>();
+		m_watchpoints = new Vector<WatchAction>();
+		m_catchpoints = new Vector<CatchAction>();
+		m_displays = new ArrayList<DisplayAction>();
+		m_keyboardInput = new Vector<String>();
+		m_mruURI = null;
+		m_sourceDirectories = new LinkedList<String>();
+		
+		initProperties();
+		m_mainState = new DebugCLIIsolateState(this);
+		m_lastPromptIsolate = -1;
+		initIsolateState();
+	}
+
+	public static LocalizationManager getLocalizationManager() { return m_localizationManager; }
+	public Session				getSession()	{ return m_session; }
+	
+	public FileInfoCache getFileCache()	{ 
+			return m_fileInfo;
+	}
+
+	/**
+	 * Convert a module to class name.  This is used
+	 * by the ExpressionCache to find variables
+	 * that live at royale package scope.   That
+	 * is variables such as mx.core.Component.
+	 */
+	public String module2ClassName(int moduleId)
+	{
+		String pkg = null;
+		try
+		{
+			SourceFile file = m_fileInfo.getFile(moduleId);
+			pkg = file.getPackageName();
+		}
+		catch(Exception npe)
+		{
+			// didn't work ignore it.
+		}
+		return pkg;
+	}
+
+	LineNumberReader	popStream()						{ return m_readerStack.pop(); }
+	public void				pushStream(LineNumberReader r)  { m_readerStack.push(r); }
+	boolean				haveStreams()					{ return !m_readerStack.empty(); }
+
+	public void processArgs(String[] args)
+	{
+		for(int i=0; i<args.length; i++)
+		{
+			String arg = args[i];
+//			System.out.println("arg["+i+"]= '"+arg+"'");
+			if (arg.charAt(0) == '-')
+			{
+				// its an option
+				if (arg.equals("-unit")) // unit-testing mode //$NON-NLS-1$
+				{
+					System.setProperty("fdbunit", ""); //$NON-NLS-1$ //$NON-NLS-2$
+				}
+				else if (arg.equals("-fullname") || arg.equals("-f")) //$NON-NLS-1$ //$NON-NLS-2$
+				{
+					m_fullnameOption = true; // emacs mode
+				}
+				else if (arg.equals("-cd")) //$NON-NLS-1$
+				{
+					// consume the path
+					if (i+1 < args.length)
+						m_cdPath = args[i++];
+				}
+				else if (arg.equals("-p")) //$NON-NLS-1$
+				{
+					// consume the port
+					if (i+1 < args.length)
+						m_connectPort = args[++i];
+				}
+				else
+				{
+					err("Unknown command-line argument: " + arg); //$NON-NLS-1$
+				}
+			}
+			else
+			{
+				// its a URI to run
+				StringReader sr = new StringReader("run "+arg+m_newline); //$NON-NLS-1$
+				pushStream( new LineNumberReader(sr) );
+			}
+		}
+	}
+
+	/**
+	 * Dispose of the current line and read the next from the current stream, if its an empty
+	 * line and we are console then repeat last line.
+	 */
+	protected String readLine() throws IOException
+	{
+		String line = null;
+		if (haveStreams())
+			line = m_in.readLine();
+		else
+			line = keyboardReadLine();
+
+		setCurrentLine(line);
+		return line;
+	}
+
+	/**
+	 * The reader portion of our keyboard input routine
+	 * Block until input arrives.
+	 */
+	synchronized String keyboardReadLine()
+	{
+		// enable a request then block on the queue
+		m_keyboardReadRequest = true;
+		try { wait(); } catch(InterruptedException ie) {}
+
+		// pull from the front of the queue
+		return m_keyboardInput.remove(0);
+	}
+
+	/**
+	 * A seperate thread collects our input so that we can
+	 * block in the doContinue on the main thread and then
+	 * allow the user to interrupt us via keyboard input
+	 * on this thread.
+	 *
+	 * We built the stupid thing in this manner, since readLine()
+	 * will block no matter what and if we 'quit' we can't
+	 * seem to kill this thread.  .close() doesn't work
+	 * and Thread.stop(), etc. all fail to do the job.
+	 *
+	 * Thus we needed to take a request response approach
+	 * so that we only block when requested to do so.
+	 */
+	public void run()
+	{
+		// while we have this stream
+		while(m_keyboardStream != null)
+		{
+			try
+			{
+				// only if someone is requesting us to read do we do so...
+				if (m_keyboardReadRequest)
+				{
+					// block on keyboard input and put it onto the end of the queue
+					String s = m_keyboardStream.readLine();
+					m_keyboardInput.add(s);
+
+					// fullfilled request, now notify blocking thread.
+					m_keyboardReadRequest = false;
+					synchronized(this) { notifyAll(); }
+				}
+				else
+					try { Thread.sleep(50); } catch(InterruptedException ie) {}
+			}
+			catch(IOException io)
+			{
+//				io.printStackTrace();
+			}
+		}
+	}
+
+	public void setCurrentLine(String s)
+	{
+		m_currentLine = s;
+		if (m_currentLine == null)
+			m_currentTokenizer = null;   /* eof */
+		else
+		{
+			m_currentLine = m_currentLine.trim();
+
+			/* if nothing provided on this command then pull our 'repeat' command  */
+			if (m_repeatLine != null && !haveStreams() && m_currentLine.length() == 0)
+				m_currentLine = m_repeatLine;
+
+			m_currentTokenizer = new StringTokenizer(m_currentLine, " \n\r\t"); //$NON-NLS-1$
+		}
+	}
+
+	/* Helpers for extracting tokens from the current line */
+	public boolean		hasMoreTokens()									{ return m_currentTokenizer.hasMoreTokens(); }
+	public String		nextToken()										{ m_currentToken = m_currentTokenizer.nextToken(); return m_currentToken; }
+	public int			nextIntToken() throws NumberFormatException		{ nextToken(); return Integer.parseInt(m_currentToken);	}
+	public long			nextLongToken() throws NumberFormatException	{ nextToken(); return Long.parseLong(m_currentToken);	}
+	public String		restOfLine()									{ return m_currentTokenizer.nextToken("").trim(); } //$NON-NLS-1$
+
+	public void execute()
+	{
+		/* dump console message */
+		displayStartMessage();
+		
+		/* now fire our keyboard input thread */
+		Thread t = new Thread(this, "Keyboard input"); //$NON-NLS-1$
+		t.start();
+
+		/* keep processing streams until we have no more to do */
+		while(haveStreams())
+		{
+			try
+			{
+				m_in = popStream();
+				process();
+			}
+			catch(EOFException eof)
+			{
+				; /* quite allright */
+			}
+			catch(IOException io)
+			{
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("exceptionMessage", io); //$NON-NLS-1$
+				err(getLocalizationManager().getLocalizedTextString("errorWhileProcessingFile", args)); //$NON-NLS-1$
+			}
+		}
+
+		/* we done kill everything */
+		exitSession();
+
+		// clear this thing, which also halts our other thread.
+		m_keyboardStream = null;
+	}
+
+	public PrintStream getOut() { return m_out; }
+
+	private void displayStartMessage()
+	{
+        String build = getLocalizationManager().getLocalizedTextString("defaultBuildName"); //$NON-NLS-1$
+
+        try
+        {
+            Properties p = new Properties();
+            p.load(this.getClass().getResourceAsStream("version.properties")); //$NON-NLS-1$
+            String buildString = p.getProperty("build"); //$NON-NLS-1$
+            if ((buildString != null) && (! buildString.equals(""))) //$NON-NLS-1$
+            {
+                build = buildString;
+            }
+        }
+        catch (Throwable t)
+        {
+            // ignore
+        }
+
+        Map<String, Object> aboutMap = new HashMap<String, Object>(); aboutMap.put("build", build); //$NON-NLS-1$
+        out(getLocalizationManager().getLocalizedTextString("about", aboutMap)); //$NON-NLS-1$
+		out(getLocalizationManager().getLocalizedTextString("copyright")); //$NON-NLS-1$
+	}
+
+	void displayPrompt()
+	{
+		m_out.print("(fdb) "); //$NON-NLS-1$
+	}
+
+	void displayCommandPrompt()
+	{
+		m_out.print(">"); //$NON-NLS-1$
+	}
+
+	// add the given character n times to sb
+	void repeat(StringBuilder sb, char c, int n)
+	{
+		while(n-- > 0)
+			sb.append(c);
+	}
+
+	// Prompt the user to respond to a yes or no type question
+	boolean yesNoQuery(String prompt) throws IOException
+	{
+		boolean result = false;
+		m_out.print(prompt);
+		m_out.print(getLocalizationManager().getLocalizedTextString("yesOrNoAppendedToAllQuestions")); //$NON-NLS-1$
+
+		String in = readLine();
+		if (in != null && in.equals(getLocalizationManager().getLocalizedTextString("singleCharacterUserTypesForYes"))) //$NON-NLS-1$
+			result = true;
+		else if (in != null && in.equals("escape")) //$NON-NLS-1$
+			throw new IllegalArgumentException("escape"); //$NON-NLS-1$
+		else
+			out(getLocalizationManager().getLocalizedTextString("yesNoQueryNotConfirmed")); //$NON-NLS-1$
+		return result;
+	}
+
+	public void err(String s)
+	{
+		// Doesn't make sense to send messages to stderr, because this is
+		// an interactive application; and besides that, sending a combination
+		// of interwoven but related messages to both stdout and stderr causes
+		// the output to be in the wrong order sometimes.
+		out(s);
+	}
+
+	public void out(String s)
+	{
+		if (s.length() > 0 && (s.charAt(s.length()-1) == '\n') )
+			m_out.print(s);
+		else
+			m_out.println(s);
+	}
+
+	static String uft()
+	{
+		Runtime rt = Runtime.getRuntime();
+		long free = rt.freeMemory(), total = rt.totalMemory(), used =  total - free;
+//		long max = rt.maxMemory();
+		java.text.NumberFormat nf = java.text.NumberFormat.getInstance() ;
+//        System.out.println("used: "+nf.format(used)+" free: "+nf.format(free)+" total: "+nf.format(total)+" max: "+nf.format(max));
+        return "Used "+nf.format(used)+" - free "+nf.format(free)+" - total "+nf.format(total); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+	/**
+	 * Add all properties that we know about
+	 */
+	void initProperties()
+	{
+		propertyPut(LIST_SIZE, 10);
+		propertyPut(LIST_LINE, 1);
+		propertyPut(LIST_MODULE, 1);  // default to module #1
+		propertyPut(LIST_WORKER, Isolate.DEFAULT_ID);
+		propertyPut(COLUMN_WIDTH, 70);
+		propertyPut(UPDATE_DELAY, 25);
+		propertyPut(HALT_TIMEOUT, 7000);
+		propertyPut(BPNUM, 0);				// set current breakpoint number as something bad
+		propertyPut(LAST_FRAME_DEPTH, 0);		// used to determine how much context information should be displayed
+		propertyPut(CURRENT_FRAME_DEPTH, 0);   // used to determine how much context information should be displayed
+		propertyPut(DISPLAY_FRAME_NUMBER, 0);  // houses the current frame we are viewing
+		propertyPut(FILE_LIST_WRAP, 999999);   // default 1 file name per line
+		propertyPut(NO_WAITING, 0);
+		propertyPut(INFO_STACK_SHOW_THIS, 1); // show this pointer for info stack
+	}
+
+	// getter/setter for properties; in the expression cache, so that they can be used in expressions!
+	public void propertyPut(String k, int v)  { m_exprCache.put(k,v); }
+	public int  propertyGet(String k)		  { return ((Integer)m_exprCache.get(k)).intValue(); }
+	public Set<String>  propertyKeys()		  { return m_exprCache.keySet(); }
+
+	/**
+	 * Process this reader until its done
+	 */
+	void process() throws IOException
+	{
+		boolean done = false;
+		while(!done)
+		{
+			try
+			{
+				/**
+				 * Now if we are in a session and that session is suspended then we go
+				 * into a state where we wait for some user interaction to get us out
+				 */
+				runningLoop();
+
+				/* if we are in the stdin then put out a prompt */
+				if (!haveStreams())
+					displayPrompt();
+
+				/* now read in the next line */
+				readLine();
+				if (m_currentLine == null)
+					break;
+
+				done = processLine();
+			}
+			catch(NoResponseException nre)
+			{
+				err(getLocalizationManager().getLocalizedTextString("noResponseException")); //$NON-NLS-1$
+			}
+			catch(NotSuspendedException nse)
+			{
+				err(getLocalizationManager().getLocalizedTextString("notSuspendedException")); //$NON-NLS-1$
+			}
+			catch(AmbiguousException ae)
+			{
+				// we already put up a warning for the user
+			}
+			catch(IllegalStateException ise)
+			{
+				err(getLocalizationManager().getLocalizedTextString("illegalStateException")); //$NON-NLS-1$
+			}
+			catch(IllegalMonitorStateException ime)
+			{
+				err(getLocalizationManager().getLocalizedTextString("illegalMonitorStateException")); //$NON-NLS-1$
+			}
+			catch(NoSuchElementException nse)
+			{
+				err(getLocalizationManager().getLocalizedTextString("noSuchElementException")); //$NON-NLS-1$
+			}
+			catch(NumberFormatException nfe)
+			{
+				err(getLocalizationManager().getLocalizedTextString("numberFormatException")); //$NON-NLS-1$
+			}
+			catch(SocketException se)
+			{
+				Map<String, Object> socketArgs = new HashMap<String, Object>();
+				socketArgs.put("message", se.getMessage()); //$NON-NLS-1$
+				err(getLocalizationManager().getLocalizedTextString("socketException", socketArgs)); //$NON-NLS-1$
+			}
+			catch(VersionException ve)
+			{
+				err(getLocalizationManager().getLocalizedTextString("versionException")); //$NON-NLS-1$
+			}
+			catch(NotConnectedException nce)
+			{
+				// handled by isConnectionLost()
+			}
+			catch(Exception e)
+			{
+				err(getLocalizationManager().getLocalizedTextString("unexpectedError")); //$NON-NLS-1$
+				err(getLocalizationManager().getLocalizedTextString("stackTraceFollows")); //$NON-NLS-1$
+				e.printStackTrace();
+			}
+
+			// check for a lost connection and if it is clean-up!
+			if (isConnectionLost())
+			{
+				try
+				{
+					dumpHaltState(false);
+				}
+				catch(PlayerDebugException pde)
+				{
+					err(getLocalizationManager().getLocalizedTextString("sessionEndedAbruptly")); //$NON-NLS-1$
+				}
+			}
+		}
+	}
+
+	// check if we have lost the connect without our help...
+	boolean isConnectionLost()
+	{
+		boolean lost = false;
+
+		if (m_session != null && !m_session.isConnected())
+			lost = true;
+
+		return lost;
+	}
+
+	boolean haveConnection()
+	{
+		boolean have = false;
+
+		if (m_session != null && m_session.isConnected())
+			have = true;
+
+		return have;
+	}
+
+	void doShow() throws AmbiguousException, PlayerDebugException
+	{
+		/* show without any args brings up help */
+		if (!hasMoreTokens())
+			out( getHelpTopic("show") ); //$NON-NLS-1$
+		else
+		{
+			/* otherwise we have a boatload of options */
+			String subCmdString = nextToken();
+			int subCmd = showCommandFor(subCmdString);
+			switch(subCmd)
+			{
+				case SHOW_NET_CMD:
+					doShowStats();
+					break;
+
+				case SHOW_FUNC_CMD:
+					doShowFuncs();
+					break;
+
+				case SHOW_URI_CMD:
+					doShowUri();
+					break;
+
+				case SHOW_PROPERTIES_CMD:
+					doShowProperties();
+					break;
+
+				case SHOW_FILES_CMD:
+					doShowFiles();
+					break;
+
+				case SHOW_BREAK_CMD:
+					doShowBreak();
+					break;
+
+				case SHOW_VAR_CMD:
+					doShowVariable();
+					break;
+
+				case SHOW_MEM_CMD:
+					doShowMemory();
+					break;
+
+				case SHOW_LOC_CMD:
+					doShowLocations();
+					break;
+
+				case SHOW_DIRS_CMD:
+					doShowDirectories();
+					break;
+
+				default:
+					doUnknown("show", subCmdString); //$NON-NLS-1$
+					break;
+			}
+		}
+	}
+
+	void doShowUri()
+	{
+		// dump the URI that the player has sent us
+		try
+		{
+			StringBuilder sb = new StringBuilder();
+			sb.append("URI = "); //$NON-NLS-1$
+			sb.append( m_session.getURI() );
+			out( sb.toString() );
+		}
+		catch(Exception e)
+		{
+			err(getLocalizationManager().getLocalizedTextString("noUriReceived")); //$NON-NLS-1$
+		}
+	}
+
+	/**
+	 * Dump the content of files in a raw format
+	 */
+	void doShowFiles()
+	{
+		try
+		{
+			StringBuilder sb = new StringBuilder();
+			for (Isolate isolate : m_session.getWorkers()) {
+			
+				Iterator itr = m_fileInfo.getAllFiles(isolate.getId());
+
+				while(itr.hasNext())
+				{
+					SourceFile m = (SourceFile) ((Map.Entry)itr.next()).getValue();
+
+					String name = m.getName();
+					int id = m.getId();
+					String path = m.getFullPath();
+
+					sb.append(id);
+					sb.append(' ');
+					sb.append(path);
+					sb.append(", "); //$NON-NLS-1$
+					sb.append(name);
+					sb.append(" ("); //$NON-NLS-1$
+					if (isolate.getId() == Isolate.DEFAULT_ID) {
+						sb.append(getLocalizationManager().getLocalizedTextString("mainThread")); //$NON-NLS-1$
+					}
+					else {
+						HashMap<String, Object> wArgs = new HashMap<String, Object>();
+						wArgs.put("worker", isolate.getId() - 1); //$NON-NLS-1$
+						sb.append(getLocalizationManager().getLocalizedTextString("inWorker", wArgs)); //$NON-NLS-1$
+					}
+					sb.append(")"); //$NON-NLS-1$
+					sb.append(m_newline);
+				}
+			}
+			out( sb.toString() );
+		}
+		catch(NullPointerException npe)
+		{
+			err(getLocalizationManager().getLocalizedTextString("noSourceFilesFound")); //$NON-NLS-1$
+		}
+	}
+
+	void doShowMemory()
+	{
+		out(uft());
+	}
+
+	void doShowLocations()
+	{
+		StringBuilder sb = new StringBuilder();
+		sb.append("Num Type           Disp Enb Address    What"+m_newline); //$NON-NLS-1$
+
+		// our list of breakpoints
+		int count = breakpointCount();
+		for(int i=0; i<count; i++)
+		{
+			BreakAction b = breakpointAt(i);
+			int num = b.getId();
+
+			FieldFormat.formatLong(sb, num, 3);
+			sb.append(" breakpoint     "); //$NON-NLS-1$
+
+			if (b.isAutoDisable())
+				sb.append("dis  "); //$NON-NLS-1$
+			else if (b.isAutoDelete())
+				sb.append("del  "); //$NON-NLS-1$
+			else
+				sb.append("keep "); //$NON-NLS-1$
+
+			if (b.isEnabled())
+				sb.append("y   "); //$NON-NLS-1$
+			else
+				sb.append("n   "); //$NON-NLS-1$
+
+			Iterator<Location> itr = b.getLocations().iterator();
+			while(itr.hasNext())
+			{
+				Location l = itr.next();
+				SourceFile file = l.getFile();
+				String funcName = (file == null)
+						? getLocalizationManager().getLocalizedTextString("unknownBreakpointLocation") //$NON-NLS-1$
+								: file.getFunctionNameForLine(m_session, l.getLine()) ;
+						int offset = adjustOffsetForUnitTests((file == null) ? 0 : file.getOffsetForLine(l.getLine()));
+
+						sb.append("0x"); //$NON-NLS-1$
+						FieldFormat.formatLongToHex(sb, offset, 8);
+						sb.append(' ');
+
+						if (funcName != null)
+						{
+							Map<String, Object> funcArgs = new HashMap<String, Object>();
+							funcArgs.put("functionName", funcName); //$NON-NLS-1$
+							sb.append(getLocalizationManager().getLocalizedTextString("inFunctionAt", funcArgs)); //$NON-NLS-1$
+						}
+
+						sb.append(file.getName());
+						if (file != null)
+						{
+							sb.append("#"); //$NON-NLS-1$
+							sb.append(file.getId());
+						}
+						sb.append(':');
+						sb.append(l.getLine());
+
+						try
+						{
+							SwfInfo info = m_fileInfo.swfForFile(file, l.getIsolateId());
+							Map<String, Object> swfArgs = new HashMap<String, Object>();
+							swfArgs.put("swf", FileInfoCache.shortNameOfSwf(info)); //$NON-NLS-1$
+							sb.append(getLocalizationManager().getLocalizedTextString("inSwf", swfArgs)); //$NON-NLS-1$
+							if (l.getIsolateId() == Isolate.DEFAULT_ID) {
+								sb.append(" ("); //$NON-NLS-1$
+								sb.append(getLocalizationManager().getLocalizedTextString("mainThread")); //$NON-NLS-1$
+								sb.append(")"); //$NON-NLS-1$
+							}
+							else {
+								swfArgs = new HashMap<String, Object>();
+								swfArgs.put("worker", l.getIsolateId() - 1); //$NON-NLS-1$
+								sb.append(" ("); //$NON-NLS-1$
+								sb.append(getLocalizationManager().getLocalizedTextString("inWorker", swfArgs)); //$NON-NLS-1$
+								sb.append(")"); //$NON-NLS-1$
+							}
+						}
+						catch(NullPointerException npe)
+						{
+							// can't find the swf
+							sb.append(getLocalizationManager().getLocalizedTextString("nonRestorable")); //$NON-NLS-1$
+						}
+						sb.append(m_newline);
+						if (itr.hasNext())
+							sb.append("                            "); //$NON-NLS-1$
+			}
+		}
+		out(sb.toString());
+	}
+
+	/**
+	 * When running unit tests, we want byte offsets into the file to
+	 * always be displayed as zero, so that the unit test expected
+	 * results will match up with the actual results.  This is just a
+	 * simple helper function that deals with that.
+	 */
+	private int adjustOffsetForUnitTests(int offset)
+	{
+		if (System.getProperty("fdbunit")==null) //$NON-NLS-1$
+			return offset;
+		else
+			return 0;
+	}
+
+	void doShowDirectories()
+	{
+		out(getLocalizationManager().getLocalizedTextString("sourceDirectoriesSearched")); //$NON-NLS-1$
+		Iterator<String> iter = m_sourceDirectories.iterator();
+		while (iter.hasNext())
+		{
+			String dir = iter.next();
+			out("  " + dir); //$NON-NLS-1$
+		}
+	}
+
+	void doHalt() throws SuspendedException, NotConnectedException, NoResponseException
+	{
+		out(getLocalizationManager().getLocalizedTextString("attemptingToSuspend")); //$NON-NLS-1$
+		IsolateSession session = m_session.getWorkerSession(getActiveIsolateId());
+		if (!session.isSuspended())
+			session.suspend();
+		if (session.isSuspended())
+			out(getLocalizationManager().getLocalizedTextString("playerStopped")); //$NON-NLS-1$
+		else
+			out(getLocalizationManager().getLocalizedTextString("playerRunning")); //$NON-NLS-1$
+	}
+
+	public void appendReason(StringBuilder sb, int reason)
+	{
+		switch(reason)
+		{
+			case SuspendReason.Unknown:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_Unknown")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.Breakpoint:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_HitBreakpoint")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.Watch:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_HitWatchpoint")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.Fault:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_ProgramThrewException")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.StopRequest:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_StopRequest")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.Step:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_ProgramFinishedStepping")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.HaltOpcode:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_HaltOpcode")); //$NON-NLS-1$
+				break;
+
+			case SuspendReason.ScriptLoaded:
+				sb.append(getLocalizationManager().getLocalizedTextString("suspendReason_ScriptHasLoadedIntoFlashPlayer")); //$NON-NLS-1$
+				break;
+		}
+	}
+
+	/**
+	 * The big ticket item, where all your questions are answered.
+	 *
+	 */
+	void doInfo() throws AmbiguousException, PlayerDebugException
+	{
+		/* info without any args brings up help */
+		if (!hasMoreTokens())
+			out( getHelpTopic("info") ); //$NON-NLS-1$
+		else
+		{
+			/* otherwise we have a boatload of options */
+			String subCmdString = nextToken();
+			int subCmd = infoCommandFor(subCmdString);
+			switch(subCmd)
+			{
+				case INFO_ARGS_CMD:
+					doInfoArgs();
+					break;
+
+				case INFO_BREAK_CMD:
+					doInfoBreak();
+					break;
+
+				case INFO_FILES_CMD:
+					doInfoFiles();
+					break;
+
+				case INFO_FUNCTIONS_CMD:
+					doInfoFuncs();
+					break;
+
+				case INFO_HANDLE_CMD:
+					doInfoHandle();
+					break;
+
+				case INFO_LOCALS_CMD:
+					doInfoLocals();
+					break;
+
+				case INFO_SCOPECHAIN_CMD:
+					doInfoScopeChain();
+					break;
+					
+				case INFO_SOURCES_CMD:
+					doInfoSources();
+					break;
+
+				case INFO_STACK_CMD:
+					doInfoStack();
+					break;
+
+				case INFO_VARIABLES_CMD:
+					doInfoVariables();
+					break;
+
+				case INFO_DISPLAY_CMD:
+					doInfoDisplay();
+					break;
+
+                case INFO_TARGETS_CMD:
+                    doInfoTargets();
+                    break;
+
+                case INFO_SWFS_CMD:
+                    doInfoSwfs();
+                    break;
+                    
+                case INFO_WORKERS_CMD:
+                	doInfoWorkers();
+                	break;
+
+				default:
+					doUnknown("info", subCmdString); //$NON-NLS-1$
+					break;
+			}
+		}
+	}
+	
+	void doInfoWorkers() throws NotConnectedException, NotSupportedException, NotSuspendedException, NoResponseException
+	{
+//		waitTilHalted();
+		Isolate[] isolates = m_session.getWorkers();
+		if (isolates == null || isolates.length == 0) {
+			out(getLocalizationManager().getLocalizedTextString("noWorkersRunning")); //$NON-NLS-1$
+			return;
+		}
+		StringBuilder sb = new StringBuilder();
+		for (Isolate t : isolates) {
+			String status = getLocalizationManager().getLocalizedTextString("workerRunning"); //$NON-NLS-1$
+			if (m_session.getWorkerSession(t.getId()).isSuspended()) {
+				status = getLocalizationManager().getLocalizedTextString("workerSuspended"); //$NON-NLS-1$
+			}
+			if (m_activeIsolate == t.getId()) {
+				status += " " + getLocalizationManager().getLocalizedTextString("workerSelected"); //$NON-NLS-1$ //$NON-NLS-2$
+			}
+			if (t.getId() == Isolate.DEFAULT_ID) {
+				sb.append(getLocalizationManager().getLocalizedTextString("mainThread")); //$NON-NLS-1$
+				sb.append(" "); //$NON-NLS-1$
+				sb.append(Isolate.DEFAULT_ID - 1);
+			}
+			else {
+				HashMap<String, Object> workArgs = new HashMap<String, Object>();
+				workArgs.put("worker", (t.getId() - 1)); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString("inWorker", workArgs)); //$NON-NLS-1$
+			}
+			sb.append(" - " + status + m_newline); //$NON-NLS-1$
+		}
+		out(sb.toString());
+	}
+
+
+	void doInfoStack() throws PlayerDebugException
+	{
+		waitTilHalted(m_activeIsolate);
+
+		StringBuilder sb = new StringBuilder();
+		Frame[] stack = m_session.getWorkerSession(m_activeIsolate).getFrames();
+		if (stack == null || stack.length == 0)
+			sb.append(getLocalizationManager().getLocalizedTextString("noStackAvailable")); //$NON-NLS-1$
+		else
+		{
+			boolean showThis = propertyGet(INFO_STACK_SHOW_THIS) == 1;
+			for(int i=0; i<stack.length; i++)
+			{
+				// keep spitting out frames until we can't
+				Frame frame = stack[i];
+				boolean valid = appendFrameInfo(sb, frame, i, showThis, false);
+				sb.append(m_newline);
+                if (!valid)
+                    break;
+			}
+		}
+
+		/* dump it out */
+		out(sb.toString());
+	}
+	
+	/**
+	 * Spit out frame information for a given frame number 
+	 */
+	boolean appendFrameInfo(StringBuilder sb, Frame ctx, int frameNumber, boolean showThis, boolean showFileId) throws PlayerDebugException
+	{
+		boolean validFrame = true;
+
+		// some formatting properties
+		int i = frameNumber;
+
+		Location loc = ctx.getLocation();
+		SourceFile file = loc.getFile();
+		int line = loc.getLine();
+		String name = (file == null) ? "<null>" : file.getName(); //$NON-NLS-1$
+		String sig = ctx.getCallSignature();
+		String func = extractFunctionName(sig);
+
+		// file == null or line < 0 appears to be a terminator for stack info
+		if (file == null && line < 0)
+        {
+            validFrame = false;
+        }
+        else
+		{
+			Variable[] var = ctx.getArguments(m_session);
+			Variable dis = ctx.getThis(m_session);
+			boolean displayArgs = (func != null) || (var != null);
+
+			sb.append('#');
+			FieldFormat.formatLong(sb, i, 3);
+			sb.append(' ');
+
+			if (showThis && dis != null)
+			{
+				ExpressionCache.appendVariable(sb, dis, ctx.getIsolateId());
+				sb.append("."); //$NON-NLS-1$
+			}
+
+			if (func != null)
+				sb.append(func);
+
+			if (displayArgs)
+			{
+				sb.append('(');
+				for (int j=0; j<var.length; j++)
+				{
+					Variable v = var[j];
+					sb.append(v.getName());
+					sb.append('=');
+					ExpressionCache.appendVariableValue(sb, v.getValue(), ctx.getIsolateId());
+					if ((j+1)<var.length)
+						sb.append(", "); //$NON-NLS-1$
+				}
+				sb.append(")"); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString("atFilename")); //$NON-NLS-1$
+			}
+
+			sb.append(name);
+
+			// if this file is currently being filtered put the source file id after it
+			if (file != null && (showFileId || !m_fileInfo.inFileList(file)))
+			{
+				sb.append('#');
+				sb.append( file.getId() );
+
+			}
+			sb.append(':');
+			sb.append(line);
+		}
+        return validFrame;
+	}
+
+	/** extract the function name from a signature */
+	public static String extractFunctionName(String sig)
+	{ 
+		// strip everything after the leading ( 
+		int at = sig.indexOf('(');
+		if (at > -1)
+			sig = sig.substring(0, at);
+
+		// trim the leading [object_name::] since it doesn't seem to add much
+		if (sig != null && (at = sig.indexOf("::")) > -1) //$NON-NLS-1$
+			sig = sig.substring(at+2);
+
+		return sig;
+	}
+
+	void doInfoVariables() throws PlayerDebugException
+	{
+		waitTilHalted(m_activeIsolate);
+
+		// dump a set of locals
+		StringBuilder sb = new StringBuilder();
+
+		// use our expression cache formatting routine
+		try
+		{
+			Variable[] vars = m_session.getWorkerSession(m_activeIsolate).getVariableList();
+			for(int i=0; i<vars.length; i++)
+			{
+				Variable v = vars[i];
+
+				// all non-local and non-arg variables
+				if ( !v.isAttributeSet(VariableAttribute.IS_LOCAL) &&
+					 !v.isAttributeSet(VariableAttribute.IS_ARGUMENT) )
+				{
+					ExpressionCache.appendVariable(sb, vars[i], m_activeIsolate);
+					sb.append(m_newline);
+				}
+			}
+		}
+		catch(NullPointerException npe)
+		{
+			sb.append(getLocalizationManager().getLocalizedTextString("noVariables")); //$NON-NLS-1$
+		}
+
+		out(sb.toString());
+	}
+
+	void doInfoDisplay()
+	{
+		StringBuilder sb = new StringBuilder();
+		sb.append("Num Enb Expression"+m_newline); //$NON-NLS-1$
+
+		// our list of displays
+		int count = displayCount();
+		for(int i=0; i<count; i++)
+		{
+			DisplayAction b = displayAt(i);
+			int num = b.getId();
+			String exp = b.getContent();
+
+			sb.append(':');
+			FieldFormat.formatLong(sb, num, 3);
+
+			if (b.isEnabled())
+				sb.append(" y  "); //$NON-NLS-1$
+			else
+				sb.append(" n  "); //$NON-NLS-1$
+
+			sb.append(exp);
+			sb.append(m_newline);
+		}
+
+		out(sb.toString());
+	}
+
+	void doInfoArgs() throws PlayerDebugException
+	{
+		waitTilHalted(m_activeIsolate);
+
+		// dump a set of locals
+		StringBuilder sb = new StringBuilder();
+
+		// use our expression cache formatting routine
+		try
+		{
+			int num = propertyGet(DISPLAY_FRAME_NUMBER);
+			Frame[] frames = m_session.getWorkerSession(m_activeIsolate).getFrames();
+			Variable[] vars = frames[num].getArguments(m_session);
+			for(int i=0; i<vars.length; i++)
+			{
+				ExpressionCache.appendVariable(sb, vars[i], m_activeIsolate);
+				sb.append(m_newline);
+			}
+		}
+		catch(NullPointerException npe)
+		{
+			sb.append(getLocalizationManager().getLocalizedTextString("noArguments")); //$NON-NLS-1$
+		}
+        catch(ArrayIndexOutOfBoundsException aix)
+        {
+            sb.append(getLocalizationManager().getLocalizedTextString("notInValidFrame")); //$NON-NLS-1$
+        }
+
+		out(sb.toString());
+	}
+
+	void doInfoLocals() throws PlayerDebugException
+	{
+		waitTilHalted(m_activeIsolate);
+
+		// dump a set of locals
+		StringBuilder sb = new StringBuilder();
+
+		// use our expression cache formatting routine
+		try
+		{
+			// get the variables from the requested frame
+			int num = propertyGet(DISPLAY_FRAME_NUMBER);
+			Frame[] ar = m_session.getWorkerSession(m_activeIsolate).getFrames();
+			Frame ctx = ar[num];
+			Variable[] vars = ctx.getLocals(m_session);
+
+			for(int i=0; i<vars.length; i++)
+			{
+				Variable v = vars[i];
+
+				// see if variable is local
+				if ( v.isAttributeSet(VariableAttribute.IS_LOCAL) )
+				{
+					ExpressionCache.appendVariable(sb, v, m_activeIsolate);
+					sb.append(m_newline);
+				}
+			}
+		}
+		catch(NullPointerException npe)
+		{
+			sb.append(getLocalizationManager().getLocalizedTextString("noLocals")); //$NON-NLS-1$
+		}
+        catch(ArrayIndexOutOfBoundsException aix)
+        {
+            sb.append(getLocalizationManager().getLocalizedTextString("notInValidFrame")); //$NON-NLS-1$
+        }
+
+		out(sb.toString());
+	}
+
+	void doInfoScopeChain() throws PlayerDebugException
+	{
+		waitTilHalted(m_activeIsolate);
+
+		// dump the scope chain
+		StringBuilder sb = new StringBuilder();
+
+		// use our expression cache formatting routine
+		try
+		{
+			// get the scope chainfrom the requested frame
+			int num = propertyGet(DISPLAY_FRAME_NUMBER);
+			Frame[] ar = m_session.getWorkerSession(m_activeIsolate).getFrames();
+			Frame ctx = ar[num];
+			Variable[] scopes = ctx.getScopeChain(m_session);
+
+			for(int i=0; i<scopes.length; i++)
+			{
+				Variable scope = scopes[i];
+				ExpressionCache.appendVariable(sb, scope, m_activeIsolate);
+				sb.append(m_newline);
+			}
+		}
+		catch(NullPointerException npe)
+		{
+			sb.append(getLocalizationManager().getLocalizedTextString("noScopeChain")); //$NON-NLS-1$
+		}
+        catch(ArrayIndexOutOfBoundsException aix)
+        {
+            sb.append(getLocalizationManager().getLocalizedTextString("notInValidFrame")); //$NON-NLS-1$
+        }
+
+		out(sb.toString());
+	}
+	
+	void doInfoTargets()
+    {
+        if (!haveConnection())
+		{
+			out(getLocalizationManager().getLocalizedTextString("noActiveSession")); //$NON-NLS-1$
+			if (m_launchURI != null)
+			{
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("uri", m_launchURI); //$NON-NLS-1$
+				out(getLocalizationManager().getLocalizedTextString("runWillLaunchUri", args)); //$NON-NLS-1$
+			}
+		}
+        else
+		{
+			String uri = m_session.getURI();
+			if (uri == null || uri.length() < 1)
+				err(getLocalizationManager().getLocalizedTextString("targetUnknown")); //$NON-NLS-1$
+			else
+				out(uri);
+		}
+    }
+
+	/**
+	 * Dump some stats about our currently loaded swfs.
+	 */
+    void doInfoSwfs()
+    {
+		try
+		{
+			StringBuilder sb = new StringBuilder();
+			SwfInfo[] swfs = m_fileInfo.getSwfs(m_activeIsolate);
+			for(int i=0; i<swfs.length; i++)
+			{
+				SwfInfo e = swfs[i];
+				if (e == null || e.isUnloaded())
+					continue;
+
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("swfName", FileInfoCache.nameOfSwf(e)); //$NON-NLS-1$
+				args.put("size", NumberFormat.getInstance().format(e.getSwfSize())); //$NON-NLS-1$
+
+				try
+				{
+					int size = e.getSwdSize(m_session);
+
+					// our swd is loaded so let's comb through our
+					// list of scripts and locate the range of ids.
+					SourceFile[] files = e.getSourceList(m_session);
+					int max = Integer.MIN_VALUE;
+					int min = Integer.MAX_VALUE;
+					for(int j=0; j<files.length; j++)
+					{
+						SourceFile f = files[j];
+						int id = f.getId();
+						max = (id > max) ? id : max;
+						min = (id < min) ? id : min;
+					}
+
+					args.put("scriptCount", Integer.toString(e.getSourceCount(m_session))); //$NON-NLS-1$
+					args.put("min", Integer.toString(min)); //$NON-NLS-1$
+					args.put("max", Integer.toString(max)); //$NON-NLS-1$
+					args.put("plus", (e.isProcessingComplete()) ? "+" : ""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+					args.put("moreInfo", (size==0) ? getLocalizationManager().getLocalizedTextString("remainingSourceBeingLoaded") : ""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				}
+				catch(InProgressException ipe)
+				{
+					sb.append(getLocalizationManager().getLocalizedTextString("debugInfoBeingLoaded")); //$NON-NLS-1$
+				}
+				args.put("url", e.getUrl()); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString("swfInfo", args)); //$NON-NLS-1$
+				sb.append(m_newline);
+			}
+			out( sb.toString() );
+		}
+		catch(NullPointerException npe)
+		{
+			err(getLocalizationManager().getLocalizedTextString("noSWFs")); //$NON-NLS-1$
+		}
+    }
+
+	private static final int AUTHORED_FILE = 1;		// a file that was created by the end user, e.g. MyApp.mxml
+	private static final int FRAMEWORK_FILE = 2;	// a file from the Flex framework, e.g. mx.controls.Button.as, see FRAMEWORK_FILE_PACKAGES
+	private static final int SYNTHETIC_FILE = 3;	// e.g. "<set up XML utilities.1>"
+	private static final int ACTIONS_FILE = 4;		// e.g. "Actions for UIComponent: Frame 1 of Layer Name Layer 1"
+
+    private static final String[] FRAMEWORK_FILE_PACKAGES // package prefixes that we consider FRAMEWORK_FILEs
+        = new String[] {"mx","flex","text"}; // 'text' is Vellum (temporary) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+	/**
+	 * Given a file, guesses what type it is -- e.g. a file created by the end user,
+	 * or a file from the Flex framework, etc.
+	 */
+	private int getFileType(SourceFile sourceFile)
+	{
+		String name = sourceFile.getName();
+		String pkg = sourceFile.getPackageName();
+
+		if (name.startsWith("<") && name.endsWith(">") || name.equals("GeneratedLocale")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+			return SYNTHETIC_FILE;
+
+        for (final String frameworkPkg : FRAMEWORK_FILE_PACKAGES )
+        {
+            // look for packages starting with pkgName
+            if (pkg.startsWith(frameworkPkg + '\\') ||
+                pkg.startsWith(frameworkPkg + '/')  ||
+                pkg.equals(frameworkPkg))
+            {
+                return FRAMEWORK_FILE;
+            }
+        }
+
+        if (name.startsWith("Actions for")) //$NON-NLS-1$
+            return ACTIONS_FILE;
+
+        return AUTHORED_FILE;
+}
+
+	void buildFileList(StringBuilder sb, boolean authoredFilesOnly)
+	{
+		SourceFile[] ar = m_fileInfo.getFileList(m_activeIsolate);
+		if (ar == null)
+		{
+			err(getLocalizationManager().getLocalizedTextString("noSourceFilesFound")); //$NON-NLS-1$
+			return;
+		}
+
+		Vector<String> authoredFiles = new Vector<String>();
+		Vector<String> frameworkFiles = new Vector<String>();
+		Vector<String> syntheticFiles = new Vector<String>();
+		Vector<String> actionsFiles = new Vector<String>();
+
+		for (int i = 0; i < ar.length; i++)
+		{
+ 			SourceFile m = ar[i];
+			int fileType = getFileType(m);
+			int id = m.getId();
+//			int fakeId = m_fileInfo.getFakeId(m);
+			String entry = m.getName() + "#" + id; //$NON-NLS-1$
+
+			switch (fileType)
+			{
+			case SYNTHETIC_FILE:
+				syntheticFiles.add(entry);
+				break;
+			case FRAMEWORK_FILE:
+				frameworkFiles.add(entry);
+				break;
+			case ACTIONS_FILE:
+				actionsFiles.add(entry);
+				break;
+			case AUTHORED_FILE:
+				authoredFiles.add(entry);
+				break;
+			}
+		}
+
+		int wrapAt = propertyGet(FILE_LIST_WRAP);
+
+		if (!authoredFilesOnly)
+		{
+			if (actionsFiles.size() > 0)
+			{
+				appendStrings(sb, actionsFiles, (actionsFiles.size() > wrapAt) );
+			}
+
+			if (frameworkFiles.size() > 0)
+			{
+				sb.append("---"+m_newline); //$NON-NLS-1$
+				appendStrings(sb, frameworkFiles, (frameworkFiles.size() > wrapAt) );
+			}
+
+			if (syntheticFiles.size() > 0)
+			{
+				sb.append("---"+m_newline); //$NON-NLS-1$
+				appendStrings(sb, syntheticFiles, (syntheticFiles.size() > wrapAt) );
+			}
+
+			sb.append("---"+m_newline); //$NON-NLS-1$
+		}
+
+		appendStrings(sb, authoredFiles, (authoredFiles.size() > wrapAt) );
+	}
+
+	/**
+	 * Dump a list of strings contained a vector
+	 * If flow is set then the strings are placed
+	 * on a single line and wrapped at $columnwidth
+	 */
+	void appendStrings(StringBuilder sb, Vector<String> v, boolean flow)
+	{
+		int count = v.size();
+		int width = 0;
+		int maxCol = propertyGet(COLUMN_WIDTH);
+
+		for (int i = 0; i < count; i++)
+		{
+			String s = v.get(i);
+			sb.append(s);
+
+			// too many of them, then wrap according to columnwidth
+			if (flow)
+			{
+				width += (s.length() + 2);
+				if (width >= maxCol)
+				{
+					sb.append(m_newline);
+					width = 0;
+				}
+				else
+					sb.append(", "); //$NON-NLS-1$
+			}
+			else
+				sb.append(m_newline);
+		}
+
+		// add a line feed for flow based
+		if (flow && width > 0)
+			sb.append(m_newline);
+	}
+
+	void doInfoFiles()
+	{
+		try
+		{
+			StringBuilder sb = new StringBuilder();
+            if (hasMoreTokens())
+            {
+                String arg = nextToken();
+                listFilesMatching(sb, arg);
+            }
+            else
+            {
+			    buildFileList(sb, false);
+            }
+			out(sb.toString());
+		}
+		catch(NullPointerException npe)
+		{
+			throw new IllegalStateException();
+		}
+	}
+
+    public void waitForMetaData() throws InProgressException
+    {
+        // perform a query to see if our metadata has loaded
+        int metadatatries = propertyGet(METADATA_ATTEMPTS);
+        int maxPerCall = 8;   // cap on how many attempt we make per call
+
+        int tries = Math.min(maxPerCall, metadatatries);
+        if (tries > 0)
+        {
+            int remain = metadatatries - tries; // assume all get used up
+
+            // perform the call and then update our remaining number of attempts
+            try
+            {
+                tries = waitForMetaData(tries);
+                remain = metadatatries - tries; // update our used count
+            }
+            catch(InProgressException ipe)
+            {
+                propertyPut(METADATA_ATTEMPTS, remain);
+				throw ipe;
+            }
+        }
+    }
+
+	/**
+	 * Wait for the API to load function names, which
+	 * exist in the form of external meta-data.
+	 *
+	 * Only do this tries times, then give up
+	 *
+	 * We wait period * attempts
+	 */
+	public int waitForMetaData(int attempts) throws InProgressException
+	{
+        int start = attempts;
+        int period = propertyGet(METADATA_ATTEMPTS_PERIOD);
+		while(attempts > 0)
+		{
+			// are we done yet?
+			if (isMetaDataAvailable())
+				break;
+			else
+				try { attempts--; Thread.sleep(period); } catch(InterruptedException ie) {}
+		}
+
+		// throw exception if still not ready
+		if (!isMetaDataAvailable())
+			throw new InProgressException();
+
+        return start-attempts;  // remaining number of tries
+	}
+
+	/**
+	 * Ask each swf if metadata processing is complete
+	 */
+	public boolean isMetaDataAvailable()
+	{
+		boolean allLoaded = true;
+		try 
+		{
+			// we need to ask the session since our fileinfocache will hide the exception
+			SwfInfo[] swfs = m_session.getSwfs();
+			for(int i=0; i<swfs.length; i++)
+			{
+				// check if our processing is finished.
+				SwfInfo swf = swfs[i];
+				if (swf != null && !swf.isProcessingComplete())
+				{
+					allLoaded = false;
+					break;
+				}
+			}
+		}
+		catch(NoResponseException nre)
+		{
+			// ok we still need to wait for player to read the swd in
+			allLoaded = false;
+		}
+
+		// count the number of times we checked and it wasn't there
+		if (!allLoaded)
+		{
+			int count = propertyGet(METADATA_NOT_AVAILABLE);
+			count++;
+			propertyPut(METADATA_NOT_AVAILABLE, count);
+		}
+		else
+		{
+			// success so we reset our attempt counter
+			propertyPut(METADATA_ATTEMPTS, METADATA_RETRIES);
+		}
+		return allLoaded;
+	}
+
+	void doInfoHandle()
+	{
+		if (hasMoreTokens())
+		{
+			// user specified a fault
+			String faultName = nextToken();
+
+			// make sure we know about this one
+		    if (!m_faultTable.exists(faultName))
+				err(getLocalizationManager().getLocalizedTextString("unrecognizedFault")); //$NON-NLS-1$
+			else
+				listFault(faultName);
+		}
+		else
+		{
+			// dump them all
+			StringBuilder sb = new StringBuilder();
+
+			appendFaultTitles(sb);
+
+			Object names[]  = m_faultTable.names();
+			Arrays.sort(names);
+
+			for(int i=0; i<names.length; i++)
+				appendFault(sb, (String)names[i]);
+
+			out ( sb.toString() );
+		}
+	}
+
+	void doInfoFuncs()
+	{
+		StringBuilder sb = new StringBuilder();
+
+		String arg = null;
+
+		// we take an optional single arg which specifies a module
+		try
+		{
+			// let's wait a bit for the background load to complete
+			waitForMetaData();
+
+			if (hasMoreTokens())
+			{
+				arg = nextToken();
+                int id = arg.equals(".") ? propertyGet(LIST_MODULE) : parseFileArg(-1, arg); //$NON-NLS-1$
+
+				SourceFile m = m_fileInfo.getFile(id, m_activeIsolate);
+				listFunctionsFor(sb, m);
+			}
+			else
+			{
+				SourceFile[] ar = m_fileInfo.getFileList(m_activeIsolate);
+				if (ar == null)
+					err(getLocalizationManager().getLocalizedTextString("noSourceFilesFound")); //$NON-NLS-1$
+				else
+                {
+                    for(int i = 0; ar != null && i < ar.length; i++)
+                    {
+                        SourceFile m = ar[i];
+                        listFunctionsFor(sb, m);
+                    }
+                }
+			}
+
+			out(sb.toString());
+		}
+		catch(NullPointerException npe)
+		{
+			err(getLocalizationManager().getLocalizedTextString("noFunctionsFound")); //$NON-NLS-1$
+		}
+		catch(ParseException pe)
+		{
+			err(pe.getMessage());
+		}
+		catch(NoMatchException nme)
+		{
+			err(nme.getMessage());
+		}
+		catch(AmbiguousException ae)
+		{
+			err(ae.getMessage());
+		}
+		catch(InProgressException ipe)
+		{
+		    err(getLocalizationManager().getLocalizedTextString("functionListBeingPrepared")); //$NON-NLS-1$
+		}
+	}
+
+	void listFunctionsFor(StringBuilder sb, SourceFile m)
+	{
+		String[] names = m.getFunctionNames(m_session);
+		if (names == null)
+			return;
+
+		Arrays.sort(names);
+
+		Map<String, Object> args = new HashMap<String, Object>();
+		args.put("sourceFile", m.getName() + "#" + m.getId()); //$NON-NLS-1$ //$NON-NLS-2$
+		sb.append(getLocalizationManager().getLocalizedTextString("functionsInSourceFile", args)); //$NON-NLS-1$
+		sb.append(m_newline);
+
+        for (int j = 0; j < names.length; j++)
+		{
+			String fname = names[j];
+			sb.append(' ');
+			sb.append(fname);
+			sb.append(' ');
+			sb.append(m.getLineForFunctionName(m_session, fname));
+			sb.append(m_newline);
+		}
+	}
+
+    void listFilesMatching(StringBuilder sb, String match)
+    {
+        SourceFile[] sourceFiles = m_fileInfo.getFiles(match);
+
+        for (int j = 0; j < sourceFiles.length; j++)
+        {
+            SourceFile sourceFile = sourceFiles[j];
+            sb.append(sourceFile.getName());
+			sb.append('#');
+			sb.append(sourceFile.getId());
+			sb.append(m_newline);
+        }
+    }
+
+    void doInfoSources()
+	{
+		try
+		{
+			StringBuilder sb = new StringBuilder();
+			buildFileList(sb, true);
+			out(sb.toString());
+		}
+		catch(NullPointerException npe)
+		{
+			throw new IllegalStateException();
+		}
+	}
+
+	void doInfoBreak() throws NotConnectedException
+	{
+//		waitTilHalted();
+
+		StringBuilder sb = new StringBuilder();
+		sb.append("Num Type           Disp Enb Address    What"+m_newline); //$NON-NLS-1$
+
+		int count = breakpointCount();
+		for(int i=0; i<count; i++)
+		{
+			BreakAction b = breakpointAt(i);
+			int status = b.getStatus();
+			boolean isResolved = (status == BreakAction.RESOLVED);
+			Location l = b.getLocation();
+			SourceFile file = (l != null) ? l.getFile() : null;
+			String funcName = (file == null) ? null : file.getFunctionNameForLine(m_session, l.getLine()) ;
+			boolean singleSwf = b.isSingleSwf();
+			int cmdCount = b.getCommandCount();
+			int hits = b.getHits();
+			String cond = b.getConditionString();
+			boolean silent = b.isSilent();
+			int offset = adjustOffsetForUnitTests((file == null) ? 0 : file.getOffsetForLine(l.getLine()));
+
+			int num = b.getId();
+			FieldFormat.formatLong(sb, num, 3);
+			sb.append(" breakpoint     "); //$NON-NLS-1$
+
+			if (b.isAutoDisable())
+				sb.append("dis  "); //$NON-NLS-1$
+			else if (b.isAutoDelete())
+				sb.append("del  "); //$NON-NLS-1$
+			else
+				sb.append("keep "); //$NON-NLS-1$
+
+			if (b.isEnabled())
+				sb.append("y   "); //$NON-NLS-1$
+			else
+				sb.append("n   "); //$NON-NLS-1$
+
+			sb.append("0x"); //$NON-NLS-1$
+			FieldFormat.formatLongToHex(sb, offset, 8);
+			sb.append(' ');
+
+			if (funcName != null)
+			{
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("functionName", funcName); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString("inFunctionAt", args)); //$NON-NLS-1$
+			}
+
+			if (file != null)
+			{
+				sb.append(file.getName());
+				if (isResolved && singleSwf)
+				{
+					sb.append("#"); //$NON-NLS-1$
+					sb.append(file.getId());
+				}
+				sb.append(':');
+				sb.append(l.getLine());
+			}
+			else
+			{
+				String expr = b.getBreakpointExpression();
+				if (expr != null)
+					sb.append(expr);
+			}
+
+			switch (status)
+			{
+			case BreakAction.UNRESOLVED:
+				sb.append(getLocalizationManager().getLocalizedTextString("breakpointNotYetResolved")); //$NON-NLS-1$
+				break;
+			case BreakAction.AMBIGUOUS:
+				sb.append(getLocalizationManager().getLocalizedTextString("breakpointAmbiguous")); //$NON-NLS-1$
+				break;
+			case BreakAction.NOCODE:
+				sb.append(getLocalizationManager().getLocalizedTextString("breakpointNoCode")); //$NON-NLS-1$
+				break;
+			}
+
+			// if a single swf break action then append more info
+			if (singleSwf && isResolved)
+			{
+				try
+				{
+					SwfInfo info = m_fileInfo.swfForFile(file, l.getIsolateId());
+					Map<String, Object> swfArgs = new HashMap<String, Object>();
+					swfArgs.put("swf", FileInfoCache.nameOfSwf(info)); //$NON-NLS-1$
+					sb.append(getLocalizationManager().getLocalizedTextString("inSwf", swfArgs)); //$NON-NLS-1$
+				}
+				catch(NullPointerException npe)
+				{
+					// can't find the swf
+					sb.append(getLocalizationManager().getLocalizedTextString("nonRestorable")); //$NON-NLS-1$
+				}
+			}
+			sb.append(m_newline);
+
+			final String INDENT = "        "; //$NON-NLS-1$
+
+			// state our condition if we have one
+			if (cond != null && cond.length() > 0)
+			{
+				sb.append(INDENT);
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("breakpointCondition", cond ); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString(getLocalizationManager().getLocalizedTextString("stopOnlyIfConditionMet", args))); //$NON-NLS-1$
+				sb.append(m_newline);
+			}
+
+			// now if its been hit, lets state the fact
+			if (hits > 0)
+			{
+				sb.append(INDENT);
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("count", Integer.toString(hits)); //$NON-NLS-1$
+				sb.append(getLocalizationManager().getLocalizedTextString("breakpointAlreadyHit", args)); //$NON-NLS-1$
+				sb.append(m_newline);
+			}
+
+			// silent?
+			if (silent)
+			{
+				sb.append(INDENT);
+				sb.append(getLocalizationManager().getLocalizedTextString("silentBreakpoint")+m_newline); //$NON-NLS-1$
+			}
+
+			// now if any commands are trailing then we pump them out
+			for(int j=0; j<cmdCount; j++)
+			{
+				sb.append(INDENT);
+				sb.append(b.commandAt(j));
+				sb.append(m_newline);
+			}
+		}
+//		}
+
+		int wcount = watchpointCount();
+		for(int k = 0; k < wcount; k++)
+		{
+			WatchAction b = watchpointAt(k);
+			int id = b.getId();
+			FieldFormat.formatLong(sb, id, 4);
+
+			int flags = b.getKind();
+			switch(flags)
+			{
+				case WatchKind.READ:
+					sb.append("rd watchpoint  "); //$NON-NLS-1$
+					break;
+				case WatchKind.WRITE:
+					sb.append("wr watchpoint  "); //$NON-NLS-1$
+					break;
+				case WatchKind.READWRITE:
+				default:
+					sb.append("watchpoint     "); //$NON-NLS-1$
+					break;
+			}
+
+			sb.append("keep "); //$NON-NLS-1$
+			sb.append("y   "); //$NON-NLS-1$
+			sb.append("           "); //$NON-NLS-1$
+			sb.append(b.getExpr());
+			sb.append(m_newline);
+		}
+
+		int ccount = catchpointCount();
+		for (int k = 0; k < ccount; k++)
+		{
+			CatchAction c = catchpointAt(k);
+			int id = c.getId();
+			FieldFormat.formatLong(sb, id, 4);
+
+			String typeToCatch = c.getTypeToCatch();
+			if (typeToCatch == null)
+				typeToCatch = "*"; //$NON-NLS-1$
+
+			sb.append("catch          "); //$NON-NLS-1$
+			sb.append("keep "); //$NON-NLS-1$
+			sb.append("y   "); //$NON-NLS-1$
+			sb.append("           "); //$NON-NLS-1$
+			sb.append(typeToCatch);
+			sb.append(m_newline);
+		}
+
+		out(sb.toString());
+	}
+
+	/**
+	 * Dump out the state of the execution, either the fact we are running
+	 * or the breakpoint we hit.
+	 */
+	void dumpHaltState(boolean postStep) throws NotConnectedException
+	{
+		// spit out any event output, if we are to resume after a fault and we're not stepping then we're done.
+		processEvents();
+//		System.out.println("processEvents = "+m_requestResume);
+
+		//if (m_requestResume && !postStep)
+		if (hasAnyPendingResumes() != -1 && !postStep)
+			return;
+
+		if (!m_session.isConnected())
+		{
+			// session is kaput
+			out(getLocalizationManager().getLocalizedTextString("sessionTerminated")); //$NON-NLS-1$
+			exitSession();
+		}
+		else
+		{
+			if (hasAnythingSuspended())
+			{
+				// capture our break location / information
+				StringBuilder sbLine = new StringBuilder();
+				dumpBreakLine(postStep, sbLine);
+
+				// Process our breakpoints.
+				// Since we can have conditional breakpoints, which the
+				// player always breaks for, but we may not want to, the variable
+				// m_requestResume may be set after this call.  Additionally,
+				// silent may be set for one of two reasons; 1) m_requestResume
+				// was set to true in the call or one or more breakpoints that
+				// hit contained the keyword silent in their command list.
+				//
+				StringBuilder sbBreak = new StringBuilder();
+				boolean silent = processBreak(postStep, sbBreak, m_activeIsolate);
+
+				StringBuilder sb = new StringBuilder();
+				if (silent)
+				{
+					// silent means we only spit out our current location
+					dumpBreakLine(postStep, sb);
+				}
+				else
+				{
+					// not silent means we append things like normal
+					sb.append(sbLine);
+					if (sbLine.length() > 0 && sbLine.charAt(sbLine.length()-1) != '\n')
+						sb.append(m_newline);
+					sb.append(sbBreak);
+				}
+
+				// output whatever was generated 
+				if (sb.length() > 0)
+					out( sb.toString() );
+
+//				System.out.println("processbreak = "+m_requestResume+",silent="+silent+",reason="+m_session.suspendReason());
+			}
+			else
+			{
+				// very bad, set stepping so that we don't trigger a continue on a breakpoint or fault
+				out(getLocalizationManager().getLocalizedTextString("playerDidNotStop")); //$NON-NLS-1$
+			}
+		}
+	}
+
+	Location getCurrentLocation()
+	{
+		return getCurrentLocationIsolate(Isolate.DEFAULT_ID);
+	}
+	
+	Location getCurrentLocationIsolate(int isolateId)
+	{
+		Location where = null;
+		try
+		{
+			Frame[] ar = m_session.getWorkerSession(isolateId).getFrames();
+			propertyPut(CURRENT_FRAME_DEPTH, (ar.length > 0) ? ar.length : 0);
+			where = ( (ar.length > 0) ? ar[0].getLocation() : null);
+		}
+		catch(PlayerDebugException pde)
+		{
+			// where == null
+		}
+		return where;
+	}
+
+	void dumpBreakLine(boolean postStep, StringBuilder sb) throws NotConnectedException
+	{
+		int bp = -1;
+		String name = getLocalizationManager().getLocalizedTextString("unknownFilename"); //$NON-NLS-1$
+		int line = -1;
+
+		// clear our current frame display
+		propertyPut(DISPLAY_FRAME_NUMBER, 0);
+		
+		int targetIsolate = getLastStoppedIsolate();
+		boolean activeIsolateChanged = (m_activeIsolate != targetIsolate);
+		m_activeIsolate = targetIsolate;
+		propertyPut(LIST_WORKER, targetIsolate);
+
+		/* dump a context line to the console */
+		Location l = getCurrentLocationIsolate(targetIsolate);
+
+		// figure out why we stopped
+		int reason = SuspendReason.Unknown;
+		try { reason = m_session.getWorkerSession(targetIsolate).suspendReason(); } catch(PlayerDebugException pde) {}
+
+		// then see if it because of a swfloaded event
+		if( reason == SuspendReason.ScriptLoaded)
+		{
+            // since the player takes a long time to provide swf/swd, try 80 * 250ms = ~20s
+            if (propertyGet(METADATA_ATTEMPTS) > 0)
+			    try { waitForMetaData(80); } catch(InProgressException ipe) { }
+
+            m_fileInfo.setDirty();
+            m_fileInfo.getSwfsIsolate(targetIsolate);
+            //propertyPut(LIST_MODULE, m_fileInfo.getFakeId(m_fileInfo.getFile(1, targetIsolate)));
+			processEvents();
+            propagateBreakpoints(targetIsolate);
+            propertyPut(LIST_LINE, 1);
+            propertyPut(LIST_WORKER, targetIsolate);
+            propertyPut(LIST_MODULE, 1);
+            sb.append(getLocalizationManager().getLocalizedTextString("additionalCodeLoaded")); //$NON-NLS-1$
+            if ( activeIsolateChanged ) {
+            	sb.append(m_newline + getLocalizationManager().getLocalizedTextString("workerChanged")+ " " + (targetIsolate - 1) + m_newline); //$NON-NLS-1$ //$NON-NLS-2$
+            }
+            sb.append(m_newline);
+
+			if (resolveBreakpoints(sb))
+				sb.append(getLocalizationManager().getLocalizedTextString("setAdditionalBreakpoints")+m_newline); //$NON-NLS-1$
+			else
+				sb.append(getLocalizationManager().getLocalizedTextString("fixBreakpoints")+m_newline); //$NON-NLS-1$
+			
+			setPromptState(InitialPromptState.SHOWN_ONCE, targetIsolate);
+		}
+		else if ( l == null || l.getFile() == null )
+		{
+			
+			if ( activeIsolateChanged ) {
+				sb.append(m_newline + getLocalizationManager().getLocalizedTextString("workerChanged")+ " " + (targetIsolate - 1) + m_newline); 
+			}
+			
+			// no idea where we are ?!?
+			propertyPut(LAST_FRAME_DEPTH, 0);
+			sb.append(getLocalizationManager().getLocalizedTextString("executionHalted")); //$NON-NLS-1$
+			sb.append(' ');
+
+			/** disable this line (and enable the one after) if implementation Extensions are not provided */
+			appendBreakInfo(sb, m_activeIsolate);
+			//sb.append("unknown location");
+		}
+		else
+		{
+			if ( activeIsolateChanged ) {
+				sb.append(m_newline + getLocalizationManager().getLocalizedTextString("workerChanged")+ " " + (targetIsolate - 1) + m_newline); 
+			}
+			
+			SourceFile file = l.getFile();
+			name = file.getName();
+			line = l.getLine();
+			String funcName = file.getFunctionNameForLine(m_session, line) ;
+
+			// where were we last time
+			int lastModule = propertyGet(LIST_MODULE);
+			int lastDepth = propertyGet(LAST_FRAME_DEPTH);
+
+			int thisModule = file.getId();
+			int thisDepth = propertyGet(CURRENT_FRAME_DEPTH);  // triggered via getCurrentLocation()
+
+			// mark where we stopped
+			propertyPut(LAST_FRAME_DEPTH, thisDepth);
+
+			// if we have changed our context or we are not spitting out source then dump our location
+			if (!postStep || lastModule != thisModule || lastDepth != thisDepth )
+			{
+				// is it a fault?
+				String reasonForHalting;
+				if ( reason == SuspendReason.Fault || reason == SuspendReason.StopRequest)
+				{
+					StringBuilder s = new StringBuilder();
+					appendReason(s, reason);
+					reasonForHalting = s.toString();
+				}
+				// if its a breakpoint add that information
+				else if ( (bp = enabledBreakpointIndexOf(l)) > -1 )
+				{
+					Map<String, Object> args = new HashMap<String, Object>();
+					args.put("breakpointNumber", Integer.toString(breakpointAt(bp).getId())); //$NON-NLS-1$
+					reasonForHalting = getLocalizationManager().getLocalizedTextString("hitBreakpoint", args); //$NON-NLS-1$
+				}
+				else
+				{
+					reasonForHalting = getLocalizationManager().getLocalizedTextString("executionHalted"); //$NON-NLS-1$
+				}
+
+				Map<String, Object> args = new HashMap<String, Object>();
+				args.put("reasonForHalting", reasonForHalting); //$NON-NLS-1$
+				args.put("fileAndLine", name + ':' + line); //$NON-NLS-1$
+				String formatString;
+				if (funcName != null)
+				{
+					args.put("functionName", funcName); //$NON-NLS-1$
+					formatString = "haltedInFunction"; //$NON-NLS-1$
+				}
+				else
+				{
+					formatString = "haltedInFile"; //$NON-NLS-1$
+				}
+				sb.append(getLocalizationManager().getLocalizedTextString(formatString, args));
+
+				if (!m_fullnameOption) 
+					sb.append(m_newline);				
+			}
+
+            // set current listing poistion and emit emacs trigger
+            setListingPosition(thisModule, line, targetIsolate);
+
+			// dump our source line if not in emacs mode
+			if (!m_fullnameOption)
+				appendSource(sb, file.getId(), line, file.getLine(line), false);
+		}
+	}
+
+	private int getLastStoppedIsolate() {
+	int targetIsolate = Isolate.DEFAULT_ID;
+		
+		if (m_breakIsolates.size() > 0) {
+			targetIsolate = m_breakIsolates.get(m_breakIsolates.size() - 1);
+		}
+		return targetIsolate;
+	}
+
+	void appendFullnamePosition(StringBuilder sb, SourceFile file, int lineNbr)
+	{
+        // fullname option means we dump 'path:line:col?:offset', which is used for emacs !
+		String name = file.getFullPath();
+		if (name.startsWith("file:/")) //$NON-NLS-1$
+			name = name.substring(6);
+
+		// Ctrl-Z Ctrl-Z
+		sb.append('\u001a');
+		sb.append('\u001a');
+
+		sb.append(name);
+		sb.append(':');
+		sb.append(lineNbr);
+		sb.append(':');
+		sb.append('0');
+		sb.append(':');
+		sb.append("beg"); //$NON-NLS-1$
+		sb.append(':');
+		sb.append('0');
+	}
+
+	// pretty print a trace statement to the console
+	void dumpTraceLine(String s)
+	{
+		StringBuilder sb = new StringBuilder();
+		sb.append("[trace] "); //$NON-NLS-1$
+		sb.append(s);
+		out(sb.toString());
+	}
+
+	// pretty print a fault statement to the console
+	void dumpFaultLine(FaultEvent e)
+	{
+		StringBuilder sb = new StringBuilder();
+
+		// use a slightly different format for ConsoleErrorFaults
+		if (e instanceof ConsoleErrorFault)
+		{
+			sb.append(getLocalizationManager().getLocalizedTextString("linePrefixWhenDisplayingConsoleError")); //$NON-NLS-1$
+			sb.append(' ');
+			sb.append(e.information);
+		}
+		else
+		{
+			String name = e.name();
+			sb.append(getLocalizationManager().getLocalizedTextString("linePrefixWhenDisplayingFault")); //$NON-NLS-1$
+			sb.append(' ');
+			sb.append(name);
+			if (e.information != null && e.information.length() > 0)
+			{
+				sb.append(getLocalizationManager().getLocalizedTextString("informationAboutFault")); //$NON-NLS-1$
+				sb.append(e.information);
+			}
+		}
+		out( sb.toString() );
+	}
+
+    /**
+     * Called when a swf has been loaded by the player
+     * @param e event documenting the load
+     */
+    void handleSwfLoadedEvent(SwfLoadedEvent e)
+    {
+        // first we dump out a message that displays we have loaded a swf
+        dumpSwfLoadedLine(e);
+    }
+
+	// pretty print a SwfLoaded statement to the console
+	void dumpSwfLoadedLine(SwfLoadedEvent e)
+	{
+		// now rip off any trailing ? options
+		int at = e.path.lastIndexOf('?');
+		String name = (at > -1) ? e.path.substring(0, at) : e.path;
+
+		StringBuilder sb = new StringBuilder();
+		sb.append(getLocalizationManager().getLocalizedTextString("linePrefixWhenSwfLoaded")); //$NON-NLS-1$
+		sb.append(' ');
+		sb.append(name);
+		sb.append(" - "); //$NON-NLS-1$
+
+		Map<String, Object> args = new HashMap<String, Object>();
+		args.put("size", NumberFormat.getInstance().format(e.swfSize)); //$NON-NLS-1$
+		sb.append(getLocalizationManager().getLocalizedTextString("sizeAfterDecompression", args)); //$NON-NLS-1$
+		out(sb.toString());
+	}
+
+    /**
+     * Propagate current breakpoints to the newly loaded swf.
+     */
+    void propagateBreakpoints(int isolateId) throws NotConnectedException
+    {
+		// get the newly added swf, which lands at the end list
+		SwfInfo[] swfs = m_fileInfo.getSwfsIsolate(isolateId);
+		SwfInfo swf = (swfs.length > 1) ? swfs[swfs.length-1] : null;
+
+		// now walk through all breakpoints propagating the 
+		// the break for each source and line number we
+		// find in the new swf
+		int size = m_breakpoints.size();
+		for (int i = 0; (swf != null) && i < size; i++)
+		{
+			// dont do this for single swf breakpoints
+			BreakAction bp = breakpointAt(i);
+			if (bp.isSingleSwf())
+				continue;
+			if (bp.getStatus() != BreakAction.RESOLVED)
+				continue;
+
+			try
+			{
+				Location l = bp.getLocation();
+				int line = l.getLine();
+				SourceFile f = l.getFile();
+				Location newLoc = findAndEnableBreak(swf, f, line);
+				if (newLoc != null)
+					bp.addLocation(newLoc);
+			}
+			catch(InProgressException ipe)
+			{
+				if (breakpointCount() > 0)
+				{
+					Map<String, Object> args = new HashMap<String, Object>();
+					args.put("breakpointNumber", Integer.toString(bp.getId())); //$NON-NLS-1$
+					out(getLocalizationManager().getLocalizedTextString("breakpointNotPropagated", args)); //$NON-NLS-1$
+				}
+			}
+		}
+    }
+
+	/**
+	 * Perform the tasks need for when a swf is unloaded
+	 * the player
+	 */
+	void handleSwfUnloadedEvent(SwfUnloadedEvent e)
+	{
+		// print out the notification
+		dumpSwfUnloadedLine(e);
+	}
+
+	// pretty print a SwfUnloaded statement to the console
+	void dumpSwfUnloadedLine(SwfUnloadedEvent e)
+	{
+		// now rip off any trailing ? options
+		int at = e.path.lastIndexOf('?');
+		String name = (at > -1) ? e.path.substring(0, at) : e.path;
+
+		StringBuilder sb = new StringBuilder();
+		sb.append(getLocalizationManager().getLocalizedTextString("linePrefixWhenSwfUnloaded")); //$NON-NLS-1$
+		sb.append(' ');
+		sb.append(name);
+		out(sb.toString());
+	}
+
+	void doContinue() throws NotConnectedException
+	{
+		//int stoppedIsolate = getLastStoppedIsolate();
+		int stoppedIsolate = m_activeIsolate;
+		waitTilHalted(stoppedIsolate);
+
+		// this will trigger a resume when we get back to the main loop
+		//m_requestResume = true;
+		setRequestResume(true, stoppedIsolate);
+		m_repeatLine = m_currentLine;
+	}
+	
+	boolean hasAnythingSuspended() throws NotConnectedException {
+		boolean hasAnythingSuspended = false;
+		for (Integer id : m_breakIsolates) {
+			if (m_session.getWorkerSession(id).isSuspended()) {
+				hasAnythingSuspended = true;
+				break;
+			}
+		}
+		return hasAnythingSuspended;
+	}
+	
+	int hasAnyPendingResumes() throws NotConnectedException {
+		int rid = -1;
+		if (m_mainState.m_requestResume)
+			return Isolate.DEFAULT_ID;
+		for (Integer id : m_breakIsolates) {
+			if (getIsolateState(id).m_requestResume) {
+				rid = id;
+				break;
+			}
+		}
+		return rid;
+	}
+	
+	/**
+	 * Returns the first isolate's id for which we need to keep showing prompts.
+	 * 
+	 * @return The isolate id
+	 * @throws NotConnectedException
+	 */
+	int hasPendingInitialPrompts() throws NotConnectedException {
+		int rid = -1;
+		for (Integer id : m_breakIsolates) {
+			if (getPromptState(id) != InitialPromptState.DONE) {
+				rid = id;
+				break;
+			}
+		}
+		return rid;
+	}
+
+	/**
+	 * Our main loop when the player is off running
+	 */
+	public void runningLoop() throws NoResponseException, NotConnectedException
+	{
+		int update = propertyGet(UPDATE_DELAY);
+		boolean nowait = (propertyGet(NO_WAITING) == 1) ? true : false;  // DEBUG ONLY; do not document
+		boolean stop = false;
+		boolean noConnection = !haveConnection();
+		boolean hasAnythingSuspended = false;
+		int targetIsolate = Isolate.DEFAULT_ID;
+		if (!noConnection) {
+			hasAnythingSuspended = hasAnythingSuspended();
+		}
+
+		if (hasAnythingSuspended) {
+			if (m_breakIsolates.size() > 0) {
+				targetIsolate = m_breakIsolates.get(m_breakIsolates.size() - 1);
+			}
+		}
+		// not there, not connected or already halted and no pending resume requests => we are done
+		//if (noConnection || (hasAnythingSuspended && !m_requestResume) )
+		if (noConnection || (hasAnythingSuspended && hasAnyPendingResumes() == -1) )
+		{
+			processEvents();
+			stop = true;
+			
+			if(!noConnection) {
+				/** At this point, some isolate is in suspended state and will be until a resume 
+				 *  is requested via the prompt. We thus check for any pending prompts to be displayed 
+				 *  for freshly loaded swfs. If any, we switch to that worker and prompt the user to set 
+				 *  any break points.  */
+				int pendingPromptIsolate = -1;
+				if ( m_lastPromptIsolate != -1 && ( getPromptState(m_lastPromptIsolate) != InitialPromptState.DONE ) ) {
+					pendingPromptIsolate = m_lastPromptIsolate;
+				} else {
+					pendingPromptIsolate = hasPendingInitialPrompts();
+				}
+				if ( pendingPromptIsolate != -1) {
+					dumpInitialPrompt(pendingPromptIsolate);
+				}
+			}
+		}
+
+	    while(!stop)
+		{
+			// allow keyboard input
+			if (!nowait)
+				m_keyboardReadRequest = true;
+			int pendingResumeId = hasAnyPendingResumes();
+			if (pendingResumeId != -1)
+			{
+				// resume execution (request fulfilled) and look for keyboard input
+				try
+				{
+					IsolateSession workerSession = m_session.getWorkerSession(pendingResumeId);
+					//if (m_stepResume)
+					if (getStepResume(pendingResumeId))
+						workerSession.stepContinue();
+					else {
+						workerSession.resume();
+					}
+					/** The user is done setting initial breakpoints for this isolate,
+					 *  clear any pending initial prompts */
+					setPromptState(InitialPromptState.DONE, pendingResumeId);
+					removeBreakIsolate(pendingResumeId);
+				}
+				catch(NotSuspendedException nse)
+				{
+					err(getLocalizationManager().getLocalizedTextString("playerAlreadyRunning")); //$NON-NLS-1$
+				}
+
+				setRequestResume(false, pendingResumeId);
+				setRequestHalt(false, pendingResumeId);
+				setStepResume(false, pendingResumeId);
+//				m_requestResume = false;
+//				m_requestHalt = false;
+//				m_stepResume = false;
+			}
+
+			// sleep for a bit, then process our events.
+			try { Thread.sleep(update); } catch(InterruptedException ie) {}
+			processEvents();
+
+			// lost connection?
+			if (!haveConnection())
+			{
+				stop = true;
+				dumpHaltState(false);
+			}
+			else if (hasAnythingSuspended())
+			{
+				/**
+				 * We have stopped for some reason.  Now for all cases, but conditional
+				 * breakpoints, we should be done.  For conditional breakpoints it
+				 * may be that the condition has turned out to be false and thus
+				 * we need to continue
+				 */
+
+				/**
+				 * Now before we do this see, if we have a valid break reason, since
+				 * we could be still receiving incoming messages, even though we have halted.
+				 * This is definately the case with loading of multiple SWFs.  After the load
+				 * we get info on the swf.
+				 */
+				if (m_breakIsolates.size() > 0) {
+					targetIsolate = m_breakIsolates.get(m_breakIsolates.size() - 1);
+				}
+				else {
+					targetIsolate = Isolate.DEFAULT_ID;
+				}
+				int tries = 3;
+				IsolateSession workerSession = m_session.getWorkerSession(targetIsolate);
+				while (tries-- > 0 && workerSession.suspendReason() == SuspendReason.Unknown)
+					try { Thread.sleep(100); processEvents(); } catch(InterruptedException ie) {}
+
+				dumpHaltState(false);
+				//if (!m_requestResume)
+				if (!getRequestResume(targetIsolate))
+					stop = true;
+			}
+			else if (nowait)
+			{
+				stop = true;  // for DEBUG only
+			}
+			else
+			{
+				/**
+				 * We are still running which is fine.  But let's see if the user has
+				 * tried to enter something on the keyboard.  If so, then we need to
+				 * stop
+				 */
+				if (!m_keyboardInput.isEmpty() && System.getProperty("fdbunit")==null) //$NON-NLS-1$
+				{
+					// flush the queue and prompt the user if they want us to halt
+					m_keyboardInput.clear();
+					try
+					{
+						if (yesNoQuery(getLocalizationManager().getLocalizedTextString("doYouWantToHalt"))) //$NON-NLS-1$
+						{
+							out(getLocalizationManager().getLocalizedTextString("attemptingToHalt")); //$NON-NLS-1$
+							IsolateSession workerSession = m_session.getWorkerSession(m_activeIsolate);
+							workerSession.suspend();
+//							m_session.suspend();
+							getIsolateState(m_activeIsolate).m_requestHalt = true;
+
+							// no connection => dump state and end
+							if (!haveConnection())
+							{
+								dumpHaltState(false);
+								stop = true;
+							}
+							else if (!workerSession.isSuspended()

<TRUNCATED>

Mime
View raw message