flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aha...@apache.org
Subject [27/50] [abbrv] git commit: [flex-falcon] [refs/heads/develop] - get donated fdbworkers to work, including integration with latest falcon compiler for expression evaluation
Date Tue, 02 Jun 2015 17:05:30 GMT
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/IsolateController.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/IsolateController.java b/debugger/src/flash/tools/debugger/IsolateController.java
new file mode 100644
index 0000000..ed09477
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/IsolateController.java
@@ -0,0 +1,184 @@
+/*
+ * 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 flash.tools.debugger;
+
+import flash.tools.debugger.expression.PlayerFaultException;
+
+/**
+ * Worker specific debug session commands. These are a subset of Session that
+ * can be individually routed to a specific worker (including the main worker if
+ * the player does not support concurrency). This is implemented by
+ * PlayerSession and used by the getWorkerSession() api.
+ * 
+ * @see flash.tools.debugger.IsolateSession,
+ *      flash.tools.debugger.Session#getWorkerSession(int)
+ * @author anirudhs
+ * 
+ */
+public interface IsolateController {
+	
+	/**
+	 * @see flash.tools.debugger.Session#resume()
+	 */
+	public void resumeWorker(int isolateId) throws NotSuspendedException, NotConnectedException, NoResponseException;
+
+	/**
+	 * @see flash.tools.debugger.Session#suspend()
+	 */
+	public void suspendWorker(int isolateId) throws SuspendedException, NotConnectedException, NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#isSuspended()
+	 */
+	public boolean isWorkerSuspended(int isolateId) throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#isSuspended()
+	 */
+	public int suspendReasonWorker(int isolateId) throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getFrames()
+	 */
+	public Frame[] getFramesWorker(int isolateId) throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepInto()
+	 */
+	public void stepIntoWorker(int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepOut()
+	 */
+	public void stepOutWorker(int isolateId)  throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepOver()
+	 */
+	public void stepOverWorker(int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepContinue()
+	 */
+	public void stepContinueWorker(int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getSwfs()
+	 */
+	public SwfInfo[] getSwfsWorker(int isolateId) throws NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#setBreakpoint(int, int)
+	 */
+	public Location setBreakpointWorker(int fileId, int lineNum, int isolateId) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getWatchList()
+	 */
+	public Watch[] getWatchListWorker(int isolateId) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getVariableList()
+	 */
+	public Variable[] getVariableListWorker(int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException, VersionException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getValue(long)
+	 */
+	public Value getValueWorker(long valueId, int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+
+	/**
+	 * @see flash.tools.debugger.Session#getGlobal(String)
+	 */
+	public Value getGlobalWorker(String name, int isolateId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#evalIs(Value, Value)
+	 */
+	public boolean evalIsWorker(Value value, Value type, int isolateId) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalIs(Value, String)
+	 */
+	public boolean evalIsWorker(Value value, String type, int isolateId) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalInstanceof(Value, Value)
+	 */
+	public boolean evalInstanceofWorker(Value value, Value type, int isolateId) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalInstanceof(Value, String)
+	 */
+	public boolean evalInstanceofWorker(Value value, String type, int isolateId) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalIn(Value, Value)
+	 */
+	public boolean evalInWorker(Value property, Value object, int isolateId) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalAs(Value, Value)
+	 */
+	public Value evalAsWorker(Value value, Value type, int isolateId) throws PlayerDebugException, PlayerFaultException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#callFunction(Value, String, Value[])
+	 */
+	public Value callFunctionWorker(Value thisObject, String functionName, Value[] args, int isolateId) throws PlayerDebugException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#callConstructor(String, Value[])
+	 */
+	public Value callConstructorWorker(String classname, Value[] args, int isolateId) throws PlayerDebugException;
+
+	/**
+	 * @see flash.tools.debugger.Session#setExceptionBreakpoint(String)
+	 */
+	public boolean setExceptionBreakpointWorker(String exceptionClass, int isolateId) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#clearExceptionBreakpoint(String)
+	 */
+	public boolean clearExceptionBreakpointWorker(String exceptionClass, int isolateId) throws NoResponseException, NotConnectedException;
+
+	/**
+	 * @see flash.tools.debugger.Session#breakOnCaughtExceptions(boolean)
+	 */
+	public void breakOnCaughtExceptions(boolean b, int isolateId) throws NotSupportedException, NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#supportsWatchpoints()
+	 */
+	public boolean supportsWatchpoints(int isolateId);
+	
+	/**
+	 * @see flash.tools.debugger.Session#playerCanBreakOnAllExceptions()
+	 */
+	public boolean playerCanBreakOnAllExceptions(int isolateId);
+	
+	/**
+	 * @see flash.tools.debugger.Session#supportsWideLineNumbers()
+	 */
+	public boolean supportsWideLineNumbers(int isolateId);
+	
+	/**
+	 * @see flash.tools.debugger.Session#playerCanCallFunctions(String)
+	 */
+	public boolean playerCanCallFunctions(int isolateId);
+	
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/IsolateSession.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/IsolateSession.java b/debugger/src/flash/tools/debugger/IsolateSession.java
new file mode 100644
index 0000000..6b57d62
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/IsolateSession.java
@@ -0,0 +1,177 @@
+/*
+ * 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 flash.tools.debugger;
+
+import flash.tools.debugger.expression.PlayerFaultException;
+
+/**
+ * Used to issue commands to a particular worker (isolate).
+ * @see Session
+ * @author anirudhs
+ */
+public interface IsolateSession {
+	
+	/**
+	 * @see flash.tools.debugger.Session#resume()
+	 */
+	public void resume() throws NotSuspendedException, NotConnectedException, NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#suspend()
+	 */
+	public void suspend() throws SuspendedException, NotConnectedException, NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#isSuspended()
+	 */
+	public boolean isSuspended() throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#isSuspended()
+	 */
+	public int suspendReason() throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getFrames()
+	 */
+	public Frame[] getFrames() throws NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepInto()
+	 */
+	public void stepInto() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepOut()
+	 */
+	public void stepOut()  throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepOver()
+	 */
+	public void stepOver() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#stepContinue()
+	 */
+	public void stepContinue() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getSwfs()
+	 */
+	public SwfInfo[] getSwfs() throws NoResponseException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#setBreakpoint(int, int)
+	 */
+	public Location setBreakpoint(int fileId, int lineNum) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getWatchList()
+	 */
+	public Watch[] getWatchList() throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getVariableList()
+	 */
+	public Variable[] getVariableList() throws NotSuspendedException, NoResponseException, NotConnectedException, VersionException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#getValue(long)
+	 */
+	public Value getValue(long valueId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+
+	/**
+	 * @see flash.tools.debugger.Session#getGlobal(String)
+	 */
+	public Value getGlobal(String name) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#evalIs(Value, Value)
+	 */
+	public boolean evalIs(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalIs(Value, String)
+	 */
+	public boolean evalIs(Value value, String type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalInstanceof(Value, Value)
+	 */
+	public boolean evalInstanceof(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalInstanceof(Value, String)
+	 */
+	public boolean evalInstanceof(Value value, String type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalIn(Value, Value)
+	 */
+	public boolean evalIn(Value property, Value object) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * @see flash.tools.debugger.Session#evalAs(Value, Value)
+	 */
+	public Value evalAs(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#resume()
+	 */
+	public Value callFunction(Value thisObject, String functionName, Value[] args) throws PlayerDebugException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#callFunction(Value, String, Value[])
+	 */
+	public Value callConstructor(String classname, Value[] args) throws PlayerDebugException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#setExceptionBreakpoint(String)
+	 */
+	public boolean setExceptionBreakpoint(String exceptionClass) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#clearExceptionBreakpoint(String)
+	 */
+	public boolean clearExceptionBreakpoint(String exceptionClass) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * @see flash.tools.debugger.Session#breakOnCaughtExceptions(boolean)
+	 */
+	public void breakOnCaughtExceptions(boolean b) throws NotSupportedException, NoResponseException;
+
+	/**
+	 * @see flash.tools.debugger.Session#supportsWatchpoints()
+	 */
+	public boolean supportsWatchpoints();
+	
+	/**
+	 * @see flash.tools.debugger.Session#playerCanBreakOnAllExceptions()
+	 */
+	public boolean playerCanBreakOnAllExceptions();
+	
+	/**
+	 * @see flash.tools.debugger.Session#supportsWideLineNumbers()
+	 */
+	public boolean supportsWideLineNumbers();
+	
+	/**
+	 * @see flash.tools.debugger.Session#playerCanCallFunctions()
+	 */
+	public boolean playerCanCallFunctions();
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/Location.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/Location.java b/debugger/src/flash/tools/debugger/Location.java
new file mode 100644
index 0000000..bf6103c
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/Location.java
@@ -0,0 +1,41 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * The Location object identifies a specific line number with a SourceFile.
+ * It is used for breakpoint manipulation and obtaining stack frame context.
+ */
+public interface Location
+{
+	/**
+	 * Source file for this location 
+	 */
+	public SourceFile getFile();
+
+	/**
+	 * Line number within the source for this location 
+	 */
+    public int getLine();
+    
+    /**
+     * Worker to which this location belongs.
+     */
+    public int getIsolateId();
+
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/NoResponseException.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/NoResponseException.java b/debugger/src/flash/tools/debugger/NoResponseException.java
new file mode 100644
index 0000000..b6756e6
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/NoResponseException.java
@@ -0,0 +1,61 @@
+/*
+ * 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 flash.tools.debugger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * NoResponseException is thrown when the Player does
+ * not respond to the command that was issued.
+ * 
+ * The field m_waitedFor contains the number of
+ * milliseconds waited for the response.
+ */
+public class NoResponseException extends PlayerDebugException
+{
+	private static final long serialVersionUID = -3704426811630352537L;
+    
+    /**
+	 * Number of milliseconds that elapsed causing the timeout
+	 * -1 means unknown.
+	 */
+	public int m_waitedFor;
+
+	public NoResponseException(int t) 
+	{
+		m_waitedFor = t;
+	}
+
+	@Override
+	public String getMessage()
+	{
+		Map<String, String> args = new HashMap<String, String>();
+		String formatString;
+		if (m_waitedFor != -1 && m_waitedFor != 0)
+		{
+			formatString = "timeout"; //$NON-NLS-1$
+			args.put("time", Integer.toString(m_waitedFor)); //$NON-NLS-1$
+		}
+		else
+		{
+			formatString = "timeoutAfterUnknownDelay"; //$NON-NLS-1$
+		}
+		return Bootstrap.getLocalizationManager().getLocalizedTextString(formatString, args);
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/NotConnectedException.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/NotConnectedException.java b/debugger/src/flash/tools/debugger/NotConnectedException.java
new file mode 100644
index 0000000..662a10a
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/NotConnectedException.java
@@ -0,0 +1,33 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * NotConnectedException is thrown when the Session
+ * is no longer connnected to the Player
+ */
+public class NotConnectedException extends PlayerDebugException
+{
+	private static final long serialVersionUID = -9087367591357152206L;
+
+    @Override
+	public String getMessage()
+	{
+		return Bootstrap.getLocalizationManager().getLocalizedTextString("notConnected"); //$NON-NLS-1$
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/NotSupportedException.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/NotSupportedException.java b/debugger/src/flash/tools/debugger/NotSupportedException.java
new file mode 100644
index 0000000..8e6dbd3
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/NotSupportedException.java
@@ -0,0 +1,39 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * Indicates that a debugger feature is not supported by the Flash
+ * player that is being targeted.  For example, newer players
+ * support the ability to have the debugger call arbitrary
+ * functions, but older ones do not.
+ * 
+ * @author Mike Morearty
+ */
+public class NotSupportedException extends PlayerDebugException {
+	private static final long serialVersionUID = -8873935118857320824L;
+
+	/**
+	 * @param s an error message, e.g. "Target player does not support
+	 * function calls," or "Target player does not support watchpoints".
+	 */
+	public NotSupportedException(String s)
+	{
+		super(s);
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/NotSuspendedException.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/NotSuspendedException.java b/debugger/src/flash/tools/debugger/NotSuspendedException.java
new file mode 100644
index 0000000..c5dad0e
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/NotSuspendedException.java
@@ -0,0 +1,33 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * NotSuspendedException is thrown when the Player 
+ * is in a state for which the action cannot be performed.
+ */
+public class NotSuspendedException extends PlayerDebugException
+{
+	private static final long serialVersionUID = 1373922470760042675L;
+
+    @Override
+	public String getMessage()
+	{
+		return Bootstrap.getLocalizationManager().getLocalizedTextString("notSuspended"); //$NON-NLS-1$
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/Player.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/Player.java b/debugger/src/flash/tools/debugger/Player.java
new file mode 100644
index 0000000..8b83250
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/Player.java
@@ -0,0 +1,82 @@
+/*
+ * 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 flash.tools.debugger;
+
+import java.io.File;
+
+/**
+ * Describes a Flash player.
+ * 
+ * @author mmorearty
+ */
+public interface Player
+{
+	/**
+	 * Indicates a standalone Flash player, e.g. FlashPlayer.exe.
+	 * 
+	 * @see #getType()
+	 */
+	public static final int STANDALONE = 1;
+
+	/**
+	 * Indicates a Netscape-plugin Flash player, e.g. NPSWF32.dll. Used on
+	 * Windows by all Netscape-based browsers (e.g. Firefox etc.), and on Mac
+	 * and Linux by all browsers.
+	 * 
+	 * @see #getType()
+	 */
+	public static final int NETSCAPE_PLUGIN = 2;
+
+	/**
+	 * Indicates an ActiveX-control Flash player, e.g. Flash.ocx.  Used on Windows
+	 * by Internet Explorer.
+	 * 
+	 * @see #getType()
+	 */
+	public static final int ACTIVEX = 3;
+
+	/**
+	 * Indicates the Flash player inside AIR.
+	 */
+	public static final int AIR = 4;
+
+	/**
+	 * Returns what type of Player this is: <code>STANDALONE</code>, <code>NETSCAPE_PLUGIN</code>,
+	 * <code>ACTIVEX</code>, or <code>AIR</code>.
+	 */
+	public int getType();
+
+	/**
+	 * Returns the path to the Flash player file -- e.g. the path to
+	 * FlashPlayer.exe, NPSWF32.dll, Flash.ocx, or adl.exe -- or
+	 * <code>null</code> if not known. (Filenames are obviously
+	 * platform-specific.)
+	 * 
+	 * <p>
+	 * Note that the file is not guaranteed to exist. You can use File.exists()
+	 * to test that.
+	 */
+	public File getPath();
+
+	/**
+	 * Returns the web browser with which this player is associated,
+	 * or <code>null</code> if this is the standalone player or AIR,
+	 * or if we're not sure which browser will be run.
+	 */
+	public Browser getBrowser();
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/PlayerDebugException.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/PlayerDebugException.java b/debugger/src/flash/tools/debugger/PlayerDebugException.java
new file mode 100644
index 0000000..a8e9f7c
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/PlayerDebugException.java
@@ -0,0 +1,30 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * PlayerDebugException is the base class for all
+ * exceptions thrown by the playerdebug API
+ */
+public class PlayerDebugException extends Exception
+{
+	private static final long serialVersionUID = 757986761482127248L;
+
+    public PlayerDebugException()				{ super(); }
+	public PlayerDebugException(String s)		{ super(s); }
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/Session.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/Session.java b/debugger/src/flash/tools/debugger/Session.java
new file mode 100644
index 0000000..35ebed4
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/Session.java
@@ -0,0 +1,604 @@
+/*
+ * 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 flash.tools.debugger;
+
+import flash.tools.debugger.events.DebugEvent;
+import flash.tools.debugger.expression.PlayerFaultException;
+
+/**
+ * The Session object manages all aspects of debugging session with
+ * the Flash Player.  A program can be suspended, resumed, single
+ * stepping can be performed and state information can be obtained
+ * through this object.
+ */
+public interface Session
+{
+	/**
+	 * Returns the URL that identifies this Session.
+	 * Note: this may not be unique across Sessions if
+	 * the same launching mechanism and SWF are used.
+	 * @return URI received from the connected Player.
+	 * It identifies the debugging session
+	 */
+	public String getURI();
+
+	/**
+	 * Returns the Process object, if any, that triggered this Session.
+	 * @return the Process object that was used to create this Session.
+	 * If SessionManager.launch() was not used, then null is returned.
+	 */
+	public Process getLaunchProcess();
+
+	/**
+	 * Adjust the preferences for this session; see SessionManager
+	 * for a list of valid preference strings.
+	 *
+	 * If an invalid preference is passed, it will be silently ignored.
+	 * @param pref preference name, one of the strings listed above
+	 * @param value value to set for preference
+	 */
+	public void setPreference(String pref, int value);
+
+	/**
+	 * Return the value of a particular preference item
+	 *
+	 * @param pref preference name, one of the strings listed in <code>SessionManager</code>
+	 * @throws NullPointerException if pref does not exist
+	 * @see SessionManager
+	 */
+	public int getPreference(String pref) throws NullPointerException;
+
+	/**
+	 * Is the Player currently connected for this session.  This function
+	 * must be thread-safe.
+	 *
+	 * @return true if connection is alive
+	 */
+	public boolean isConnected();
+
+	/**
+	 * Allow the session to start communicating with the player.  This
+	 * call must be made PRIOR to any other Session method call.
+	 * @return true if bind was successful.
+	 * @throws VersionException connected to Player which does not support all API completely
+	 */
+	public boolean bind() throws VersionException;
+
+	/**
+	 * Permanently stops the debugging session and breaks the
+	 * connection.  If this Session is used for any subsequent
+	 * calls exceptions will be thrown.
+	 * <p>
+	 * Note: this method allows the caller to disconnect
+	 * from the debugging session (and Player) without
+	 * terminating the Player.  A subsequent call to terminate()
+	 * will destroy the Player process.
+	 * <p>
+	 * Under normal circumstances this method need not be
+	 * called since a call to terminate() performs both
+	 * actions of disconnecting from the Player and destroying
+	 * the Player process.
+	 */
+	public void unbind();
+
+	/**
+	 * Permanently stops the debugging session and breaks the connection. If
+	 * this session ID is used for any subsequent calls exceptions will be
+	 * thrown.
+	 * <p>
+	 * Note that due to platform and browser differences, it should not be
+	 * assumed that this function will necessarily kill the process being
+	 * debugged. For example:
+	 *
+	 * <ul>
+	 * <li> On all platforms, Firefox cannot be terminated. This is because when
+	 * we launch a new instance of Firefox, Firefox actually checks to see if
+	 * there is another already-running instance. If there is, then the new
+	 * instance just passes control to that old instance. So, the debugger
+	 * doesn't know the process ID of the browser. It would be bad to attempt to
+	 * figure out the PID and then kill that process, because the user might
+	 * have other browser windows open that they don't want to lose. </li>
+	 * <li> On Mac, similar problems apply to the Safari and Camino browsers:
+	 * all browsers are launched with /usr/bin/open, so we never know the
+	 * process ID, and we can't kill it. However, for Safari and Camino, what we
+	 * do attempt to do is communicate with the browser via AppleScript, and
+	 * tell it to close the window of the program that is being debugged. </li>
+	 * </ul>
+	 *
+	 * <p>
+	 * If SessionManager.launch() was used to initiate the Session then calling
+	 * this function also causes getLaunchProcess().destroy() to be called.
+	 * <p>
+	 * Note: this method first calls unbind() if needed.
+	 */
+	public void terminate();
+
+	/**
+	 * Continue a halted session.  Execution of the ActionScript
+	 * will commence until a reason for halting exists. That
+	 * is, a breakpoint is reached or the <code>suspend()</code> method is called.
+	 * <p>
+	 * This method will NOT block.  It will return immediately
+	 * after the Player resumes execution.  Use the isSuspended
+	 * method to determine when the Player has halted.
+	 *
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is already running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void resume() throws NotSuspendedException, NotConnectedException, NoResponseException;
+
+	/**
+	 * Halt a running session.  Execution of the ActionScript
+	 * will stop at the next possible breakpoint.
+	 * <p>
+	 * This method WILL BLOCK until the Player halts for some
+	 * reason or an error occurs. During this period, one or
+	 * more callbacks may be initiated.
+	 *
+	 * @throws NoResponseException if times out
+	 * @throws SuspendedException if Player is already suspended
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void suspend() throws SuspendedException, NotConnectedException, NoResponseException;
+	
+	/**
+	 * Is the Player currently halted awaiting requests, such as continue,
+	 * stepOut, stepIn, stepOver. This function is guaranteed to be thread-safe.
+	 *
+	 * @return true if player halted
+	 * @throws NotConnectedException
+	 *             if Player is disconnected from Session
+	 */
+	public boolean isSuspended() throws NotConnectedException;
+
+	/**
+	 * Returns a SuspendReason integer which indicates
+	 * why the Player has suspended execution.
+	 * @return see SuspendReason
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public int suspendReason() throws NotConnectedException;
+	
+	/**
+	 * Returns an array of frames that identify the location and contain
+	 * arguments, locals and 'this' information for each frame on the
+	 * function call stack.   The 0th frame contains the current location
+	 * and context for the actionscript program.  Likewise
+	 * getFrames[getFrames().length] is the topmost (or outermost) frame
+	 * of the call stack.
+	 * @return array of call frames with 0th element representing the current frame.
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public Frame[] getFrames() throws NotConnectedException;
+	
+	/**
+	 * Step to the next executable source line within the
+	 * program, will enter into functions.
+	 * <p>
+	 * This method will NOT block.  It will return immediately
+	 * after the Player resumes execution.  Use the isSuspended
+	 * method to determine when the Player has halted.
+	 *
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void stepInto() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Step out of the current method/function onto the
+	 * next executable soruce line.
+	 * <p>
+	 * This method will NOT block.  It will return immediately
+	 * after the Player resumes execution.  Use the isSuspended
+	 * method to determine when the Player has halted.
+	 *
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void stepOut()  throws NotSuspendedException, NoResponseException, NotConnectedException;
+
+	/**
+	 * Step to the next executable source line within
+	 * the program, will NOT enter into functions.
+	 * <p>
+	 * This method will NOT block.  It will return immediately
+	 * after the Player resumes execution.  Use the isSuspended
+	 * method to determine when the Player has halted.
+	 *
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void stepOver() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Continue the process of stepping.
+	 * This call should only be issued if a previous
+	 * stepXXX() call was made and the Player suspended
+	 * execution due to a breakpoint being hit.
+	 * That is getSuspendReason() == SuspendReason.Break
+	 * This operation can be used for assisting with
+	 * the processing of conditional breakpoints.
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public void stepContinue() throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Obtain information about the various SWF(s) that have been
+	 * loaded into the Player, for this session.
+	 *
+	 * Note: As SWFs are loaded by the Player a SwfLoadedEvent is
+	 * fired.  At this point, a call to getSwfInfo() will provide
+	 * updated information.
+	 *
+	 * @return array of records describing the SWFs
+	 * @throws NoResponseException if times out
+	 */
+	public SwfInfo[] getSwfs() throws NoResponseException;
+	
+	/**
+	 * Get a list of the current breakpoints.  No specific ordering
+	 * of the breakpoints is implied by the array.
+	 * @return breakpoints currently set.
+	 * @throws NoResponseException if times out
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public Location[] getBreakpointList() throws NoResponseException, NotConnectedException;
+
+	/**
+	 * Set a breakpoint on a line within the given file.
+	 * <p>
+	 * <em>Warning:</em> <code>setBreakpoint()</code> and
+	 * <code>clearBreakpoint()</code> do not keep track of how many times they
+	 * have been called for a given Location. For example, if you make two calls
+	 * to <code>setBreakpoint()</code> for file X.as line 10, and then one
+	 * call to <code>clearBreakpoint()</code> for that same file and line,
+	 * then the breakpoint is gone. So, the caller is responsible for keeping
+	 * track of whether the user has set two breakpoints at the same location.
+	 *
+	 * @return null if breakpoint not set, otherwise
+	 * Location of breakpoint.
+	 * @throws NoResponseException if times out
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public Location setBreakpoint(int fileId, int lineNum) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * Remove a breakpoint at given location. The Location obtain can be a
+	 * clone/copy of a Location object returned from a previous call to
+	 * getBreakpointList().
+	 * <p>
+	 * <em>Warning:</em> <code>setBreakpoint()</code> and
+	 * <code>clearBreakpoint()</code> do not keep track of how many times they
+	 * have been called for a given Location. For example, if you make two calls
+	 * to <code>setBreakpoint()</code> for file X.as line 10, and then one
+	 * call to <code>clearBreakpoint()</code> for that same file and line,
+	 * then the breakpoint is gone. So, the caller is responsible for keeping
+	 * track of whether the user has set two breakpoints at the same location.
+	 *
+	 * @return null if breakpoint was not removed.
+	 * @throws NoResponseException
+	 *             if times out
+	 * @throws NotConnectedException
+	 *             if Player is disconnected from Session
+	 */
+	public Location clearBreakpoint(Location location) throws NoResponseException, NotConnectedException;
+
+	/**
+	 * Get a list of the current watchpoint.  No specific ordering
+	 * of the watchpoints is implied by the array.  Also, the
+	 * list may contain watchpoints that are no longer relevant due
+	 * to the variable going out of scope.
+	 * @return watchpoints currently set.
+	 * @throws NoResponseException if times out
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 * @since Version 2
+	 */
+	public Watch[] getWatchList() throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * Set a watchpoint on a given variable.  A watchpoint is used
+	 * to suspend Player execution upon access of a particular variable.
+	 * If the variable upon which the watchpoint is set goes out of scope,
+	 * the watchpoint will NOT be automatically removed.
+	 * <p>
+	 * Specification of the variable item to be watched requires two
+	 * pieces of information (similar to setScalarMember())
+	 * The Variable and the name of the particular member to be watched
+	 * within the variable.
+	 * For example if the watchpoint is to be applied to 'a.b.c'.  First the
+	 * Value for object 'a.b' must be obtained and then the call
+	 * setWatch(v, "c", ...) can be issued.
+	 * The watchpoint can be triggered (i.e. the Player suspended) when either a read
+	 * or write (or either) occurs on the variable.  If the Player is suspended
+	 * due to a watchpoint being fired, then the suspendReason() call will
+	 * return SuspendReason.WATCH.
+	 * <p>
+	 * Setting a watchpoint multiple times on the same variable will result
+	 * in the old watchpoint being removed from the list and a new watchpoint
+	 * being added to the end of the list.
+	 * <p>
+	 * Likewise, if a previously existing watchpoint is modified by
+	 * specifiying a different kind variable then the old watchpoint
+	 * will be removed from the list and a new watchpoint will be added
+	 * to the end of the list.
+	 *
+	 * @param v the variable, upon whose member, the watch is to be placed.
+	 * @param varName is the mmeber name upon which the watch
+	 * should be placed.  This variable name may NOT contain the dot ('.')
+	 * character and MUST be a member of v.
+	 * @param kind access type that will trigger the watchpoint to fire --
+	 * read, write, or read/write.  See <code>WatchKind</code>.
+	 * @return null if watchpoint was not created.
+	 * @throws NoResponseException if times out
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 * @throws NotSupportedException if the Player does not support watchpoints,
+	 * or does not support watchpoints on this particular member (e.g. because
+	 * it is a getter or a dynamic variable).
+	 * @since Version 2
+	 * @see WatchKind
+	 */
+	public Watch setWatch(Value v, String memberName, int kind) throws NoResponseException, NotConnectedException, NotSupportedException;
+	
+	/**
+	 * Enables or disables a watchpoint.
+	 *
+	 * @param watch
+	 *            the watch to enable or disable
+	 * @param enabled
+	 *            whether to enable it or disable it
+	 * @throws NotSupportedException
+	 * @throws NotConnectedException
+	 * @throws NoResponseException
+	 */
+	public Watch setWatch(Watch watch) throws NoResponseException, NotConnectedException, NotSupportedException;
+
+	/**
+	 * Remove a previously created watchpoint.  The watchpoint
+	 * that was removed will be returned upon a sucessful call.
+	 * @return null if watchpoint was not removed.
+	 * @throws NoResponseException if times out
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 * @since Version 2
+	 */
+	public Watch clearWatch(Watch watch) throws NoResponseException, NotConnectedException;
+	
+	/**
+	 * Obtains a list of variables that are local to the current
+	 * halted state.
+	 * @deprecated As of version 2.
+	 * @see Frame#getLocals
+	 */
+	public Variable[] getVariableList() throws NotSuspendedException, NoResponseException, NotConnectedException, VersionException;
+	
+	/**
+	 * From a given value identifier return a Value.  This call
+	 * allows tools to access a specific value whenever the Player has
+	 * suspended.  A Value's id is maintained for the life of the
+	 * Value and is guaranteed not to change.  Values that
+	 * go out of scope are no longer accessible and will result
+	 * in a null being returned.   Also note, that scalar
+	 * variables do not contain an id that can be referenced in
+	 * this manner.  Therefore the caller must also maintain the
+	 * 'context' in which the variable was obtained.  For example
+	 * if a Number b exists on a, then the reference 'a.b' must be
+	 * managed, as the id of 'a' will be needed to obtain the
+	 * value of 'b'.
+	 * @param valueId identifier from Value class or
+	 * from a call to Value.getId()
+	 * @return null, if value cannot be found or
+	 * value with the specific id.
+	 * @throws NoResponseException if times out
+	 * @throws NotSuspendedException if Player is running
+	 * @throws NotConnectedException if Player is disconnected from Session
+	 */
+	public Value getValue(long valueId) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Looks up a global name, like "MyClass", "String", etc.
+	 *
+	 * @return its value, or <code>null</code> if the global does not exist.
+	 */
+	public Value getGlobal(String name) throws NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Events provide a mechanism whereby status information is provided from
+	 * the Player in a timely fashion.
+	 * <p>
+	 * The caller has the option of either polling the event queue via
+	 * <code>nextEvent()</code> or calling <code>waitForEvent()</code> which
+	 * blocks the calling thread until one or more events exist in the queue.
+	 *
+	 * @throws NotConnectedException
+	 *             if Session is disconnected from Player
+	 * @throws InterruptedException
+	 */
+	public void waitForEvent() throws NotConnectedException, InterruptedException;
+
+	/**
+	 * Returns the number of events currently in the queue.  This function
+	 * is guaranteed to be thread-safe.
+	 */
+	public int getEventCount();
+
+	/**
+	 * Removes and returns the next event from queue
+	 */
+	public DebugEvent nextEvent();
+
+	/**
+	 * Gets the SourceLocator for this session.  If none has been
+	 * specified, returns null.
+	 */
+    public SourceLocator getSourceLocator();
+
+	/**
+	 * Sets the SourceLocator for this session.  This can be used in order
+	 * to override the default rules used for finding source files.
+	 */
+	public void setSourceLocator(SourceLocator sourceLocator);
+
+	/**
+	 * Invokes a constructor in the player. Returns the newly created object.
+	 * Not supported in Player 9 or AIR 1.0. If you call this function and the
+	 * player to which you are connected doesn't support this feature, this will
+	 * throw a PlayerDebugException.
+	 */
+	public Value callConstructor(String classname, Value[] args) throws PlayerDebugException;
+
+	/**
+	 * Invokes a function. For example, calling
+	 * <code>callFunction(myobj, "toString", new Value[0])</code> will call
+	 * <code>myobj.toString()</code>. Not supported in Player 9 or AIR 1.0.
+	 * If you call this function and the player to which you are connected
+	 * doesn't support this feature, this will throw a PlayerDebugException.
+	 */
+	public Value callFunction(Value thisObject, String functionName, Value[] args) throws PlayerDebugException;
+	
+	/**
+	 * The player always halts on exceptions that are not going to be caught;
+	 * this call allows the debugger to control its behavior when an exception
+	 * that *will* be caught is thrown.
+	 *
+	 * @throws NotSupportedException
+	 *             thrown by older players that don't support this feature.
+	 * @throws NoResponseException
+	 */
+	public void breakOnCaughtExceptions(boolean b) throws NotSupportedException, NoResponseException;
+
+	/**
+	 * Evaluate the ActionScript expression "value is type"
+	 *
+	 * @throws PlayerDebugException
+	 * @throws PlayerFaultException
+	 */
+	public boolean evalIs(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * Evaluate the ActionScript expression "value is type"
+	 *
+	 * @throws PlayerDebugException
+	 * @throws PlayerFaultException
+	 */
+	public boolean evalIs(Value value, String type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * Evaluate the ActionScript expression "value instanceof type"
+	 *
+	 * @throws PlayerFaultException
+	 * @throws PlayerDebugException
+	 */
+	public boolean evalInstanceof(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * Evaluate the ActionScript expression "value instanceof type"
+	 *
+	 * @throws PlayerFaultException
+	 * @throws PlayerDebugException
+	 */
+	public boolean evalInstanceof(Value value, String type) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * Evaluate the ActionScript expression "property in object"
+	 *
+	 * @throws PlayerFaultException
+	 * @throws PlayerDebugException
+	 */
+	public boolean evalIn(Value property, Value object) throws PlayerDebugException, PlayerFaultException;
+
+	/**
+	 * Evaluate the ActionScript expression "value as type"
+	 *
+	 * @throws PlayerDebugException
+	 * @throws PlayerFaultException
+	 */
+	public Value evalAs(Value value, Value type) throws PlayerDebugException, PlayerFaultException;
+	
+	/**
+	 * Returns whether the target player supports watchpoints.
+	 * @see #setWatch(Value, String, int)
+	 */
+	public boolean supportsWatchpoints();
+	
+	/**
+	 * Returns the root SocketException that caused the rxMessage()
+	 * thread to shut down. This works in conjunction with 
+	 * PREF_SOCKET_TIMEOUT and helps in detecting broken connections.
+	 */
+	public Exception getDisconnectCause();
+
+	/**
+	 * Set an exception breakpoint. Returns true if succeeded.
+	 * @param exceptionClass
+	 * @return
+	 * @throws NoResponseException
+	 * @throws NotConnectedException
+	 */
+	public boolean setExceptionBreakpoint(String exceptionClass) throws NoResponseException, NotConnectedException;
+
+	/**
+	 * Clears an exception breakpoint. Returns true if succeeded.
+	 * @param exceptionClass
+	 * @return
+	 * @throws NoResponseException
+	 * @throws NotConnectedException
+	 */
+	public boolean clearExceptionBreakpoint(String exceptionClass) throws NoResponseException, NotConnectedException;
+	
+	// Concurrency begin
+	
+	/**
+	 * Returns whether the target player supports concurrency.
+	 * @see #setActiveIsolate(Value)
+	 */
+	public boolean supportsConcurrency();
+	
+	/**
+	 * Get an array of all workers that the debugger knows of.
+	 */
+	public Isolate[] getWorkers();
+	
+	/**
+	 * Ask the player again for a list of all workers. Use this
+	 * method with caution as it will also reset all state about
+	 * workers that the debugger is aware of.
+	 */
+	public Isolate[] refreshWorkers() throws  NotSupportedException, NotSuspendedException, NoResponseException, NotConnectedException;
+	
+	/**
+	 * Return the worker specific session object that can be used
+	 * to communicate with that worker.
+	 */
+	public IsolateSession getWorkerSession(int isolateId);
+	
+	/**
+	 * 
+	 * Sets the ILauncher instance which is associated with this session. 
+	 * ILauncher instance is used to terminate the process at the end of the debugging session.
+	 *
+	 * @param launcher 
+	 * 				ILauncher instance used to launch & terminate the process.
+	 */
+	public void setLauncher(ILauncher launcher);
+
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/SessionManager.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/SessionManager.java b/debugger/src/flash/tools/debugger/SessionManager.java
new file mode 100644
index 0000000..e67e68b
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/SessionManager.java
@@ -0,0 +1,390 @@
+/*
+ * 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 flash.tools.debugger;
+
+import java.io.IOException;
+
+/**
+ * A SessionManager controls connection establishment and preferences 
+ * for all debugging sessions with the Flash Player.
+ * 
+ * To begin a new debugging session:
+ * 
+ * <ol>
+ * <li> Get a <code>SessionManager</code> from <code>Bootstrap.sessionManager()</code> </li>
+ * <li> Call <code>SessionManager.startListening()</code> </li>
+ * <li> If you want to have the API launch the Flash Player for you, call
+ *      <code>SessionManager.launch()</code>.  If you want to launch the Flash Player
+ *      and then have the API connect to it, then launch the Flash Player and then
+ *      call <code>SessionManager.accept()</code>. <em>Note:</em> <code>launch()</code> 
+ *      and <code>accept()</code> are both blocking calls, so you probably don't want
+ *      to call them from your main UI thread. </li>
+ * <li> Finally, call <code>SessionManager.stopListening()</code>.
+ * </ol>
+ */
+public interface SessionManager
+{
+	/**
+	 * The preferences are set using the setPreference() method, and
+	 * take effect immediately thereafter.
+	 */
+
+	/**
+	 * The value used for <code>$accepttimeout</code> controls how long (in
+	 * milliseconds) <code>accept()</code> waits before timing out. The
+	 * default value for this preference is 120000 (2 minutes).
+	 */
+	public static final String PREF_ACCEPT_TIMEOUT				= "$accepttimeout"; //$NON-NLS-1$
+
+	/**
+	 * Valid values for <code>$urimodification</code> are 0 (off) and 1 (on).
+	 * The default value is 1 (on), which allows this API to modify the URI
+	 * passed to <code>launch()</code> as necessary for creating a debuggable
+	 * version of an MXML file.
+	 */
+	public static final String PREF_URI_MODIFICATION			= "$urimodification"; //$NON-NLS-1$
+
+	/**
+	 *-----------------------------------------------------------------
+	 * The following are Session specific preferences.  These can be
+	 * modified in this class, resulting in all future sessions using
+	 * the values or they can be modified at the session level via
+	 * Session.setPreference().
+	 *-----------------------------------------------------------------
+	 */
+
+	/**
+	 * <code>$responsetimeout</code> is used to determine how long (in
+	 * milliseconds) the session will wait, for a player response before giving
+	 * up on the request and throwing an Exception.
+	 */
+	public static final String PREF_RESPONSE_TIMEOUT			= "$responsetimeout"; //$NON-NLS-1$
+	
+	/**
+	 * <code>$sockettimeout</code> is used to determine how long (in
+	 * milliseconds) the session will wait on a Socket recv call.
+	 * On timeout, we do not immediately abort the session, instead we
+	 * write a squelch message to player. If the write succeeds, we assume
+	 * everything is normal.This helps identify broken connections that 
+	 * are relevant when performing WiFi debugging. 
+	 * This is -1 by default to indicate no timeout 
+	 * (for backward compatibility).
+	 */
+	public static final String PREF_SOCKET_TIMEOUT			= "$sockettimeout"; //$NON-NLS-1$
+
+	/**
+	 * <code>$contextresponsetimeout</code> is used to determine how long (in
+	 * milliseconds) the session will wait for a player response from a request
+	 * to get context, before giving up on the request and throwing an
+	 * Exception.
+	 */
+	public static final String PREF_CONTEXT_RESPONSE_TIMEOUT	= "$contextresponsetimeout"; //$NON-NLS-1$
+
+	/**
+	 * <code>$getvarresponsetimeout</code> is used to determine how long (in
+	 * milliseconds) the session will wait, for a player response to a get
+	 * variable request before giving up on the request and throwing an
+	 * Exception.
+	 */
+	public static final String PREF_GETVAR_RESPONSE_TIMEOUT		= "$getvarresponsetimeout"; //$NON-NLS-1$
+
+	/**
+	 * <code>$setvarresponsetimeout</code> is the amount of time (in
+	 * milliseconds) that a setter in the user's code will be given to execute,
+	 * before the player interrupts it with a ScriptTimeoutError. Default value
+	 * is 5000 ms.
+	 */
+	public static final String PREF_SETVAR_RESPONSE_TIMEOUT		= "$setvarresponsetimeout"; //$NON-NLS-1$
+
+	/**
+	 * <code>$swfswdloadtimeout<code> is used to determine how long (in milliseconds)
+	 * the session will wait, for a player response to a swf/swd load 
+	 * request before giving up on the request and throwing an Exception.
+	 */
+	public static final String PREF_SWFSWD_LOAD_TIMEOUT			= "$swfswdloadtimeout"; //$NON-NLS-1$
+
+	/**
+	 * <code>$suspendwait</code> is the amount of time (in milliseconds) that
+	 * a Session will wait for the Player to suspend, after a call to
+	 * <code>suspend()</code>.
+	 */
+	public static final String PREF_SUSPEND_WAIT				= "$suspendwait"; //$NON-NLS-1$
+
+	/**
+	 * <code>$invokegetters</code> is used to determine whether a getter
+	 * property is invoked or not when requested via <code>getVariable()</code>
+	 * The default value is for this to be enabled.
+	 */
+	public static final String PREF_INVOKE_GETTERS				= "$invokegetters"; //$NON-NLS-1$
+
+	public static final String PLAYER_SUPPORTS_GET				= "$playersupportsget"; //$NON-NLS-1$
+
+	/**
+	 * <code>$hiervars</code> is used to determine whether the members of
+	 * a variable are shown in a hierchical way.
+	 */
+	public static final String PREF_HIERARCHICAL_VARIABLES		= "$hiervars"; //$NON-NLS-1$
+
+	/**
+	 * The value used for <code>$connecttimeout</code> controls how long (in
+	 * milliseconds) <code>connect()</code> waits before timing out. The
+	 * default value for this preference is 120000 (2 minutes).
+	 */
+	public static final String PREF_CONNECT_TIMEOUT				= "$connecttimeout"; //$NON-NLS-1$
+
+	 /**
+     * The value used for <code>$connectwaitinterval</code> controls how long (in
+     * milliseconds) we wait between subsequent <code>connect()</code> calls. The
+     * default value for this preference is 250.
+     */
+    public static final String PREF_CONNECT_WAIT_INTERVAL = "$connectwaitinterval"; //$NON-NLS-1$
+
+    /**
+     * The value used for <code>$connectretryattempts</code> controls how many times
+     * the debugger retries connecting to the application. This is time bound by 
+     * <code>$connecttimeout</code>. The default value for this preference is -1 and
+     * indicates that the debugger should retry till the timeout period has elapsed.
+     * Setting this to zero will disable the retry mechanism.
+     */
+    public static final String PREF_CONNECT_RETRY_ATTEMPTS = "$connectretryattempts"; //$NON-NLS-1$
+    
+	/**
+	 * Set preference for this manager and for subsequent Sessions 
+	 * that are initiated after this call.
+	 * 
+	 * If an invalid preference is passed, it will be silently ignored.
+	 * @param pref preference name, one of the strings listed above
+	 * @param value value to set for preference
+	 */
+	public void setPreference(String pref, int value);
+
+	/**
+	 * Set preference for this manager and for subsequent Sessions 
+	 * that are initiated after this call.
+	 * 
+	 * If an invalid preference is passed, it will be silently ignored.
+	 * @param pref preference name, one of the strings listed above
+	 * @param value value to set for preference
+	 */
+	public void setPreference(String pref, String value);
+
+	/**
+	 * Return the value of a particular preference item
+	 * 
+	 * @param pref preference name, one of the strings listed above
+	 * @throws NullPointerException if pref does not exist
+	 */
+	public int getPreference(String pref) throws NullPointerException;
+
+	/**
+	 * Listens for Player attempts to open a debug session. This method must be
+	 * called prior to <code>accept()</code> being invoked.
+	 * 
+	 * @throws IOException
+	 *             if opening the server side socket fails
+	 */
+	public void startListening() throws IOException;
+
+	/**
+	 * Stops listening for new Player attempts to open a debug session. The
+	 * method DOES NOT terminate currently connected sessions, but will cause
+	 * threads blocked in <code>accept</code> to throw SocketExceptions.
+	 */
+	public void stopListening() throws IOException;
+
+	/**
+	 * Is this object currently listening for Debug Player connections 
+	 * @return TRUE currently listening 
+	 */
+	public boolean isListening();
+
+	/**
+	 * Launches a Player using the given string as a URI, as defined by RFC2396.
+	 * It is expected that the operating system will be able to launch the
+	 * appropriate player application given this URI.
+	 * <p>
+	 * For example "http://localhost:8100/flex/my.mxml" or for a local file on
+	 * Windows, "file://c:/my.swf"
+	 * <p>
+	 * This call will block until a session with the newly launched player is
+	 * created.
+	 * <p>
+	 * It is the caller's responsibility to ensure that no other thread is
+	 * blocking in <code>accept()</code>, since that thread will gain control
+	 * of this session.
+	 * <p>
+	 * Before calling <code>launch()</code>, you should first call
+	 * <code>supportsLaunch()</code>. If <code>supportsLaunch()</code>
+	 * returns false, then you will have to tell the user to manually launch the
+	 * Flash player.
+	 * <p>
+	 * Also, before calling <code>launch()</code>, you must call
+	 * <code>startListening()</code>.
+	 * 
+	 * @param uri
+	 *            which will launch a Flash player under running OS. For
+	 *            Flash/Flex apps, this can point to either a SWF or an HTML
+	 *            file. For AIR apps, this must point to the application.xml
+	 *            file for the application.
+	 * @param airLaunchInfo
+	 *            If trying to launch an AIR application, this argument must be
+	 *            specified; it gives more information about how to do the
+	 *            launch. If trying to launch a regular web-based Flash or Flex
+	 *            application, such as one that will be in a browser or in the
+	 *            standalone Flash Player, this argument should be
+	 *            <code>null</code>.
+	 * @param forDebugging
+	 *            if <code>true</code>, then the launch is for the purposes
+	 *            of debugging. If <code>false</code>, then the launch is
+	 *            simply because the user wants to run the movie but not debug
+	 *            it; in that case, the return value of this function will be
+	 *            <code>null</code>.
+	 * @param waitReporter
+	 *            a progress monitor to allow accept() to notify its parent how
+	 *            long it has been waiting for the Flash player to connect to
+	 *            it. May be <code>null</code> if the caller doesn't need to
+	 *            know how long it's been waiting.
+	 * @param launchNotification
+	 *            a notifier to notify the caller about ADL Exit Code.
+	 *            Main usage is for ADL Exit Code 1 (Successful invocation of an 
+	 *            already running AIR application. ADL exits immediately).
+	 *            May be <code>null</code> if no need to listen ADL. 
+	 *            Will only be called if forDebugging is false.  (If forDebugging
+	 *            is true, error conditions are handled by throwing an exception.)
+	 *			  The callback will be called on a different thread.
+	 * @return a Session to use for debugging, or null if forDebugging==false.
+	 *         The return value is not used to indicate an error -- exceptions
+	 *         are used for that. If this function returns without throwing an
+	 *         exception, then the return value will always be non-null if
+	 *         forDebugging==true, or null if forDebugging==false.
+	 * @throws BindException
+	 *             if <code>isListening()</code> == false
+	 * @throws FileNotFoundException
+	 *             if file cannot be located
+	 * @throws CommandLineException
+	 *             if the program that was launched exited unexpectedly. This
+	 *             will be returned, for example, when launching an AIR
+	 *             application, if adl exits with an error code.
+	 *             CommandLineException includes functions to return any error
+	 *             text that may have been sent to stdout/stderr, and the exit
+	 *             code of the program.
+	 * @throws IOException
+	 *             see Runtime.exec()
+	 */
+	public Session launch(String uri, AIRLaunchInfo airLaunchInfo,
+			boolean forDebugging, IProgress waitReporter, ILaunchNotification launchNotification) throws IOException;
+
+	/**
+	 * Returns information about the Flash player which will be used to run the
+	 * given URI.
+	 * 
+	 * @param uri
+	 *            The URI which will be passed to <code>launch()</code> -- for
+	 *            example, <code>http://flexserver/mymovie.mxml</code> or
+	 *            <code>c:\mymovie.swf</code>. If launching an AIR app, this
+	 *            should point to the app's *-app.xml file.
+	 * @param airLaunchInfo
+	 *            If launching an AIR app, this should, if possible, contain
+	 *            info about the version of AIR being launched, but it can be
+	 *            null if you don't have that information. If launching a
+	 *            web-based app, this should be null.
+	 * @return a {@link Player} which can be used to determine information about
+	 *         the player -- for example, whether it is a debugger-enabled
+	 *         player. Returns <code>null</code> if the player cannot be
+	 *         determined. <em>Important:</em> There are valid situations in
+	 *         which this will return <code>null</code>
+	 */
+	public Player playerForUri(String uri, AIRLaunchInfo airLaunchInfo);
+
+	/**
+	 * Returns whether this platform supports the <code>launch()</code>
+	 * command; that is, whether the debugger can programmatically launch the
+	 * Flash player. If this function returns false, then the debugger will have
+	 * to tell the user to manually launch the Flash player.
+	 * 
+	 * @return true if this platform supports the <code>launch()</code>
+	 *         command.
+	 */
+	public boolean supportsLaunch();
+
+	/**
+	 * Blocks until the next available player debug session commences, or until
+	 * <code>getPreference(PREF_ACCEPT_TIMEOUT)</code> milliseconds pass.
+	 * <p>
+	 * Before calling <code>launch()</code>, you must call
+	 * <code>startListening()</code>.
+	 * <p>
+	 * Once a Session is obtained, Session.bind() must be called prior to any
+	 * other Session method.
+	 * 
+	 * @param waitReporter
+	 *            a progress monitor to allow accept() to notify its parent how
+	 *            long it has been waiting for the Flash player to connect to it.
+	 *            May be <code>null</code> if the caller doesn't need to know how
+	 *            long it's been waiting.
+	 * @throws BindException
+	 *             if isListening() == false
+	 * @throws IOException -
+	 *             see java.net.ServerSocket.accept()
+	 */
+	public Session accept(IProgress waitReporter) throws IOException;
+
+	/**
+	 * Tells the session manager to use the specified IDebuggerCallbacks for
+	 * performing certain operatios, such as finding the Flash Player and
+	 * launching the debug target. If you do not call this, the session manager
+	 * will use a <code>DefaultDebuggerCallbacks</code> object.
+	 */
+	public void setDebuggerCallbacks(IDebuggerCallbacks debugger);
+
+	/**
+	 * Initiate a debug session by connecting to the specified port. Blocks 
+	 * until a connection is made, or until 
+	 * <code>getPreference(PREF_CONNECT_TIMEOUT)</code> milliseconds pass.
+	 * <p>
+	 * This work-flow is a reverse of <code>accept()</code> and suited for 
+	 * cases where the player is unable to initiate the connection. The 
+	 * player must be listening on the specified port for an incoming debug 
+	 * connection. In addition, this function calls bind() on the session
+	 * to determine if the handshake was successful so that retry works
+	 * correctly even across port-forwards.
+	 * <p> 
+	 * Use <code>stopConnecting()</code> to cancel connect,
+	 * <code>isConnecting()</code> to check if we are currently trying to 
+	 * connect.
+	 * 
+	 * @param port - The port to connect to. See DProtocol.DEBUG_CONNECT_PORT.
+	 * @param waitReporter
+	 * @return A Session object on which bind() has already been called.
+	 * @throws IOException - This may have a wrapped VersionException due to bind()
+	 */
+	public Session connect(int port, IProgress waitReporter) throws IOException;
+	
+	/**
+	 * Stops connecting to the Player for a debug session. The
+	 * method DOES NOT terminate currently connected sessions, but will cause
+	 * threads blocked in <code>connect</code> to throw SocketExceptions.
+	 */
+	public void stopConnecting() throws IOException;
+
+	/**
+	 * Is this object currently connecting to the Debug Player 
+	 * @return TRUE currently connecting 
+	 */
+	public boolean isConnecting();
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/SessionManager2.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/SessionManager2.java b/debugger/src/flash/tools/debugger/SessionManager2.java
new file mode 100644
index 0000000..c1801d9
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/SessionManager2.java
@@ -0,0 +1,184 @@
+/*
+ * 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 flash.tools.debugger;
+
+import java.io.IOException;
+
+public interface SessionManager2 extends SessionManager {
+	
+	/**
+	 * This is, functionally, a clone of the SessionManager.launch() method. There are however some differences.
+	 * 	-This is to be called only for run launches. only for debug launches, the launch() method creates a Session and
+	 * binds it to the launch and since the launch() method returns the Session, which will be null in a Run Launch case,
+	 * we have no way of accessing the Process that was created for the launch.
+	 * 	-To enable auto termination of run launches, we need to know the system Process for us to terminate it when
+	 * necessary.
+	 *  -This method creates the process and binds a process listener to it and then returns the process.
+	 *
+	 * 
+	 * @param uri
+	 *            which will launch a Flash player under running OS. For
+	 *            Flash/Flex apps, this can point to either a SWF or an HTML
+	 *            file. For AIR apps, this must point to the application.xml
+	 *            file for the application.
+	 * @param airLaunchInfo
+	 *            If trying to launch an AIR application, this argument must be
+	 *            specified; it gives more information about how to do the
+	 *            launch. If trying to launch a regular web-based Flash or Flex
+	 *            application, such as one that will be in a browser or in the
+	 *            standalone Flash Player, this argument should be
+	 *            <code>null</code>.
+	 * @param waitReporter
+	 *            a progress monitor to allow accept() to notify its parent how
+	 *            long it has been waiting for the Flash player to connect to
+	 *            it. May be <code>null</code> if the caller doesn't need to
+	 *            know how long it's been waiting.
+	 * @param launchNotification
+	 *            a notifier to notify the caller about ADL Exit Code.
+	 *            Main usage is for ADL Exit Code 1 (Successful invocation of an 
+	 *            already running AIR application. ADL exits immediately).
+	 *            May be <code>null</code> if no need to listen ADL. 
+	 *			  The callback will be called on a different thread.
+	 * @return a Process to use for the run launch.
+	 *         The return value is not used to indicate an error -- exceptions
+	 *         are used for that. If this function returns without throwing an
+	 *         exception, then the return value will always be non-null.
+	 * @throws IOException
+	 *             see Runtime.exec()
+	 */
+	public Process launchForRun(String uri, AIRLaunchInfo airLaunchInfo,
+			 IProgress waitReporter, ILaunchNotification launchNotification) throws IOException;
+	/**
+	 * This is, functionally, a clone of the SessionManager.launch() method. There are however some differences.
+	 * 	-This is to be called only for run launches. only for debug launches, the launch() method creates a Session and
+	 * binds it to the launch and since the launch() method returns the Session, which will be null in a Run Launch case,
+	 * we have no way of accessing the Process that was created for the launch.
+	 * 	-To enable auto termination of run launches, we need to know the system Process for us to terminate it when
+	 * necessary.
+	 *  -This method creates the process and binds a process listener to it and then returns the process.
+	 *
+	 *  - This method used the ILauncher instance passed to launch the application.
+	 *  
+	 * @param uri
+	 *  		  which will launch a Flash player under running OS. For
+	 *            Flash/Flex apps, this can point to either a SWF or an HTML
+	 *            file. For AIR apps, this must point to the application.xml
+	 *            file for the application.
+	  * @param airLaunchInfo
+	 *            If trying to launch an AIR application, this argument must be
+	 *            specified; it gives more information about how to do the
+	 *            launch. If trying to launch a regular web-based Flash or Flex
+	 *            application, such as one that will be in a browser or in the
+	 *            standalone Flash Player, this argument should be
+	 *            <code>null</code>.
+	 * @param waitReporter
+	 *            a progress monitor to allow accept() to notify its parent how
+	 *            long it has been waiting for the Flash player to connect to
+	 *            it. May be <code>null</code> if the caller doesn't need to
+	 *            know how long it's been waiting.
+	 * @param launchNotification
+	 *            a notifier to notify the caller about ADL Exit Code.
+	 *            Main usage is for ADL Exit Code 1 (Successful invocation of an 
+	 *            already running AIR application. ADL exits immediately).
+	 *            May be <code>null</code> if no need to listen ADL. 
+	 *			  The callback will be called on a different thread.
+	 * @param launcher
+	 * 			  a launcher instance which will be used to launch.
+	 * @return a Process to use for the run launch.
+	 *         The return value is not used to indicate an error -- exceptions
+	 *         are used for that. If this function returns without throwing an
+	 *         exception, then the return value will always be non-null.
+	 * @throws IOException
+	 */
+	public Process launchForRun(String uri, AIRLaunchInfo airLaunchInfo,
+			 IProgress waitReporter, ILaunchNotification launchNotification, ILauncher launcher) throws IOException;
+	
+	
+	/**
+	 * Launches the given string as a URI using the ILauncher Instance.
+	 * 
+	 * This API is to provide more flexibility to handle the Player launch in different platforms.
+	 * 
+	 * This call will block until a session with the newly launched player is
+	 * created.
+	 * <p>
+	 * It is the caller's responsibility to ensure that no other thread is
+	 * blocking in <code>accept()</code>, since that thread will gain control
+	 * of this session.
+	 * <p>
+	 * Before calling <code>launch()</code>, you should first call
+	 * <code>supportsLaunch()</code>. If <code>supportsLaunch()</code>
+	 * returns false, then you will have to tell the user to manually launch the
+	 * Flash player.
+	 * <p>
+	 * Also, before calling <code>launch()</code>, you must call
+	 * <code>startListening()</code>.
+	 * 
+	 * @param uri
+	 *            which will launch a Flash player under running OS. For
+	 *            Flash/Flex apps, this can point to either a SWF or an HTML
+	 *            file. For AIR apps, this must point to the application.xml
+	 *            file for the application.
+	 * @param airLaunchInfo
+	 *            If trying to launch an AIR application, this argument must be
+	 *            specified; it gives more information about how to do the
+	 *            launch. If trying to launch a regular web-based Flash or Flex
+	 *            application, such as one that will be in a browser or in the
+	 *            standalone Flash Player, this argument should be
+	 *            <code>null</code>.
+	 * @param forDebugging
+	 *            if <code>true</code>, then the launch is for the purposes
+	 *            of debugging. If <code>false</code>, then the launch is
+	 *            simply because the user wants to run the movie but not debug
+	 *            it; in that case, the return value of this function will be
+	 *            <code>null</code>.
+	 * @param waitReporter
+	 *            a progress monitor to allow accept() to notify its parent how
+	 *            long it has been waiting for the Flash player to connect to
+	 *            it. May be <code>null</code> if the caller doesn't need to
+	 *            know how long it's been waiting.
+	 * @param launchNotification
+	 *            a notifier to notify the caller about ADL Exit Code.
+	 *            Main usage is for ADL Exit Code 1 (Successful invocation of an 
+	 *            already running AIR application. ADL exits immediately).
+	 *            May be <code>null</code> if no need to listen ADL. 
+	 *            Will only be called if forDebugging is false.  (If forDebugging
+	 *            is true, error conditions are handled by throwing an exception.)
+	 *			  The callback will be called on a different thread.
+	 * @return a Session to use for debugging, or null if forDebugging==false.
+	 *         The return value is not used to indicate an error -- exceptions
+	 *         are used for that. If this function returns without throwing an
+	 *         exception, then the return value will always be non-null if
+	 *         forDebugging==true, or null if forDebugging==false.
+	 * @throws BindException
+	 *             if <code>isListening()</code> == false
+	 * @throws FileNotFoundException
+	 *             if file cannot be located
+	 * @throws CommandLineException
+	 *             if the program that was launched exited unexpectedly. This
+	 *             will be returned, for example, when launching an AIR
+	 *             application, if adl exits with an error code.
+	 *             CommandLineException includes functions to return any error
+	 *             text that may have been sent to stdout/stderr, and the exit
+	 *             code of the program.
+	 * @throws IOException 
+	 * 				Exception during launch.
+	 */
+	public Session launch(String uri, AIRLaunchInfo airLaunchInfo,
+			boolean forDebugging, IProgress waitReporter, ILaunchNotification launchNotification, ILauncher launcher) throws IOException;
+
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/SourceFile.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/SourceFile.java b/debugger/src/flash/tools/debugger/SourceFile.java
new file mode 100644
index 0000000..6fe0978
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/SourceFile.java
@@ -0,0 +1,124 @@
+/*
+ * 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 flash.tools.debugger;
+
+/**
+ * A SourceFile contains information about a specific segment 
+ * of ActionScript source code.  The source code could be
+ * derived from a number of locations; an ActionScript file, a 
+ * snip-it of code from a frame, compiler generated code, etc.
+ */
+public interface SourceFile
+{
+	/**
+	 * Base path for this filename, without the package-name portion.  For
+	 * example, if class mx.controls.Button.as was in
+	 * C:\flex\sdk\frameworks\mx\controls\Button.as, then getBasePath()
+	 * would return "C:\flex\sdk\frameworks" (note that the "mx\controls"
+	 * part would NOT be returned).
+	 * @return base path, or null
+	 */
+	public String getBasePath();
+
+	/**
+	 * Get the package name portion of the path for this file. For example, if
+	 * class mx.controls.Button.as was in
+	 * C:\flex\sdk\frameworks\mx\controls\Button.as, then getPackageName() would
+	 * return "mx\controls".
+	 * 
+	 * @return package name, or "" (never null)
+	 */
+	public String getPackageName();
+
+	/**
+	 * File name of this SourceFile.  In the case of a disk-based SourceFile,
+	 * this is the same as the filename with no path, e.g. 'myfile.as'
+	 * @return filename, or "" (never null)
+	 */
+	public String getName();
+
+	/**
+	 * Full path and file name, if its exists, for this SourceFile.  For
+	 * disk-based SourceFiles, this is equivalent to
+	 *     <code>getBasePath + slash + getPackageName() + slash + getName()</code>
+	 * where "slash" is a platform-specific slash character.
+	 * @return path, never null
+	 */
+	public String getFullPath();
+
+	/**
+	 * Raw, unprocessed file name for this SourceFile.
+	 * @since As of Version 2
+	 */
+	public String getRawName();
+
+	/**
+	 * Returns the number of source lines in the given file
+	 * @return -1 indicates an error.  Call getError() to 
+	 * obtain specific reason code.
+	 */
+	public int getLineCount();
+
+	/**
+	 * Return a unique identifier for this SourceFile. 
+	 */
+	public int getId();
+
+	/**
+	 * Obtains the textual content of the given line
+	 * from within a source file.  
+	 * Line numbers start at 1 and go to getLineCount().
+	 * 
+	 * @return the line of source of the file.  Any carriage
+	 *		   return and/or line feed are stripped from the
+	 *		   end of the string.
+	 */
+	public String getLine(int lineNum);
+
+	/**
+	 *---------------------------------------------------
+	 * WARNING:  The functions below will return null
+	 *			 and/or 0 values while 
+	 *			 Session.fileMetaDataLoaded() is false.
+	 *---------------------------------------------------
+	 */
+
+	/**
+	 * Return the function name for a given line number, or <code>null</code>
+	 * if not known or if the line matches more than one function.
+     * @since Version 3.
+	 */
+	public String getFunctionNameForLine(Session s, int lineNum);
+
+	/**
+	 * Return the line number for the given function name
+	 * if it doesn't exists -1 is returned
+	 */
+	public int getLineForFunctionName(Session s, String name);
+
+	/**
+	 * Get a list of all function names for this SourceFile
+	 */
+	public String[] getFunctionNames(Session s);
+
+	/**
+	 * Return the offset within the SWF for a given line 
+	 * number.
+	 */
+	public int getOffsetForLine(int lineNum);
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/00c0bf63/debugger/src/flash/tools/debugger/SourceLocator.java
----------------------------------------------------------------------
diff --git a/debugger/src/flash/tools/debugger/SourceLocator.java b/debugger/src/flash/tools/debugger/SourceLocator.java
new file mode 100644
index 0000000..23d49d7
--- /dev/null
+++ b/debugger/src/flash/tools/debugger/SourceLocator.java
@@ -0,0 +1,51 @@
+/*
+ * 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 flash.tools.debugger;
+
+import java.io.InputStream;
+
+/**
+ * A callback interface which should be implemented by the client debugger
+ * (such as fdb), to locate source files.
+ * 
+ * This is only necessary if the client debugger wants the DJAPI to "own"
+ * the source code.  Zorn, for example, will probably *not* want to
+ * implement this interface, because Eclipse itself will load the source
+ * files from disk.
+ */
+public interface SourceLocator
+{
+	/**
+	 * Callback from DJAPI to the debugger, to find a source file.
+	 * Returns null if it can't find the file.
+	 */
+    public InputStream locateSource(String path, String pkg, String name);
+
+	/**
+	 * Returns a number which indicates how many times this SourceLocator's
+	 * search algorithm has been changed since it was created.  For example,
+	 * if a SourceLocator allows the user to change the list of directories
+	 * that are searched, then each time the user changes that list of
+	 * directories, the return value from getChangeCount() should change.
+	 * 
+	 * The DJAPI uses this in order to figure out if it should try again
+	 * to look for a source file that it had previously been unable to
+	 * find.
+	 */
+	public int getChangeCount();
+}


Mime
View raw message