flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aha...@apache.org
Subject [15/63] [abbrv] [partial] git commit: [flex-falcon] [refs/heads/develop] - move stuff to where I think Maven wants it
Date Tue, 26 Apr 2016 04:29:07 GMT
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/07f5a7de/debugger/src/main/java/flash/tools/debugger/events/SwfLoadedEvent.java
----------------------------------------------------------------------
diff --git a/debugger/src/main/java/flash/tools/debugger/events/SwfLoadedEvent.java b/debugger/src/main/java/flash/tools/debugger/events/SwfLoadedEvent.java
new file mode 100644
index 0000000..0245d93
--- /dev/null
+++ b/debugger/src/main/java/flash/tools/debugger/events/SwfLoadedEvent.java
@@ -0,0 +1,57 @@
+/*
+ * 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.events;
+
+/**
+ * This event is fired when the player has completed the loading of 
+ * the specified SWF.
+ */
+public class SwfLoadedEvent extends DebugEvent
+{
+	/** unique identifier for the SWF */
+	public long id;				
+
+	/** index of swf in Session.getSwfs() array */
+	public int index;
+
+	/** full path name for  SWF */
+	public String path;
+
+	/** size of the loaded SWF in bytes */
+	public long swfSize;
+
+	/** URL of the loaded SWF */
+	public String url;
+
+	/** port number related to the URL */
+	public long port;
+
+	/** name of host in which the SWF was loaded */
+	public String host;
+
+	public SwfLoadedEvent(long sId, int sIndex, String sPath, String sUrl, String sHost, long sPort, long sSwfSize)
+	{
+		id = sId;
+		index = sIndex;
+		swfSize = sSwfSize;
+		port = sPort;
+		path = sPath;
+		url = sUrl;
+		host = sHost;
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/07f5a7de/debugger/src/main/java/flash/tools/debugger/events/SwfUnloadedEvent.java
----------------------------------------------------------------------
diff --git a/debugger/src/main/java/flash/tools/debugger/events/SwfUnloadedEvent.java b/debugger/src/main/java/flash/tools/debugger/events/SwfUnloadedEvent.java
new file mode 100644
index 0000000..b91e941
--- /dev/null
+++ b/debugger/src/main/java/flash/tools/debugger/events/SwfUnloadedEvent.java
@@ -0,0 +1,40 @@
+/*
+ * 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.events;
+
+/**
+ * This event is fired when the player has unloaded a swf
+ */
+public class SwfUnloadedEvent extends DebugEvent
+{
+	/** unique identifier for the SWF */
+	public long			id;
+
+	/** index of SWF in Session.getSwfs() array */
+	public int			index;
+
+	/** full path name for the SWF */
+	public String		path;
+
+	public SwfUnloadedEvent(long sId, String sPath, int sIndex)
+	{
+		id = sId;
+		index = sIndex;
+		path = sPath;
+	}
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/07f5a7de/debugger/src/main/java/flash/tools/debugger/events/TraceEvent.java
----------------------------------------------------------------------
diff --git a/debugger/src/main/java/flash/tools/debugger/events/TraceEvent.java b/debugger/src/main/java/flash/tools/debugger/events/TraceEvent.java
new file mode 100644
index 0000000..5f04af8
--- /dev/null
+++ b/debugger/src/main/java/flash/tools/debugger/events/TraceEvent.java
@@ -0,0 +1,32 @@
+/*
+ * 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.events;
+
+/**
+ * Trace is a special operation by the player that
+ * allows text strings to be displayed during the
+ * execution of some ActionScript.  
+ * <p>
+ * The event provides notification that a trace 
+ * statement was encountered. The info string 
+ * contains the contenxt of the trace message.
+ */
+public class TraceEvent extends DebugEvent
+{
+	public TraceEvent(String s) { super(s); }
+}

http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/07f5a7de/debugger/src/main/java/flash/tools/debugger/expression/AS3DebuggerReducer.java
----------------------------------------------------------------------
diff --git a/debugger/src/main/java/flash/tools/debugger/expression/AS3DebuggerReducer.java b/debugger/src/main/java/flash/tools/debugger/expression/AS3DebuggerReducer.java
new file mode 100644
index 0000000..4015b6f
--- /dev/null
+++ b/debugger/src/main/java/flash/tools/debugger/expression/AS3DebuggerReducer.java
@@ -0,0 +1,2294 @@
+/*
+ * 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.expression;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Vector;
+
+import flash.tools.debugger.*;
+import org.apache.flex.abc.ABCConstants;
+import org.apache.flex.compiler.constants.IASLanguageConstants;
+import org.apache.flex.compiler.definitions.IDefinition;
+import org.apache.flex.compiler.definitions.ITypeDefinition;
+import org.apache.flex.compiler.internal.definitions.NamespaceDefinition;
+import org.apache.flex.compiler.internal.semantics.SemanticUtils;
+import org.apache.flex.compiler.internal.tree.as.IdentifierNode;
+import org.apache.flex.compiler.internal.tree.as.MemberAccessExpressionNode;
+import org.apache.flex.compiler.internal.tree.as.NumericLiteralNode;
+import org.apache.flex.compiler.internal.tree.as.RegExpLiteralNode;
+import org.apache.flex.compiler.projects.ICompilerProject;
+import org.apache.flex.compiler.tree.ASTNodeID;
+import org.apache.flex.compiler.tree.as.INumericLiteralNode.INumericValue;
+import org.apache.flex.compiler.tree.as.IASNode;
+import org.apache.flex.compiler.tree.as.IExpressionNode;
+import org.apache.flex.compiler.tree.as.IIdentifierNode;
+
+import flash.tools.debugger.concrete.DValue;
+
+/**
+ * Reducer for the debugger - equivalent to the old DebuggerEvaluator
+ */
+public class AS3DebuggerReducer {
+
+	private final ContextStack contextStack;
+	private final ICompilerProject project;
+
+	public static class ContextStack {
+
+		private final List<Context> ctxStckInternal;
+
+		public ContextStack(Context context) {
+			ctxStckInternal = new ArrayList<Context>();
+			pushScope(context);
+		}
+
+		public Context scope(int i) {
+			return ctxStckInternal.get(i);
+		}
+
+		public void pushScope(Context scope) {
+			ctxStckInternal.add(scope);
+		}
+
+		public void popScope() {
+			assert (!ctxStckInternal.isEmpty());
+			ctxStckInternal.remove(ctxStckInternal.size() - 1);
+		}
+
+		public Context scope() {
+			return ctxStckInternal.get(ctxStckInternal.size() - 1);
+		}
+
+	}
+
+	public AS3DebuggerReducer(Context context, ICompilerProject project) {
+		super();
+		this.contextStack = new ContextStack(context);
+		this.project = project;
+	}
+
+	static final int ERROR_TRAP = 268435456;
+
+	// TODO: IMPORTANT, SET IT TO FALSE BEFORE COMMIT or it won't work in IntelliJ.
+	private boolean hookallreducercalls = false;
+	
+	private void hookforreducercalls(String name)
+	{
+		System.out.println(name);
+	}
+
+	private Object callFunction(Context cx, boolean isConstructor,
+			Object function, Object[] args) throws PlayerDebugException {
+		if (hookallreducercalls)
+			hookforreducercalls("callFunction");
+		
+		Session session = cx.getSession();
+
+		flash.tools.debugger.Value thisObject = cx.toValue();
+		if (thisObject == null)
+			thisObject = DValue.forPrimitive(null, cx.getIsolateId());
+
+		flash.tools.debugger.Value[] valueArgs = new flash.tools.debugger.Value[args.length];
+		for (int i = 0; i < args.length; ++i) {
+			/**
+			 * context.toValue() may return null while
+			 * PlayerSession::buildCallFunctionMessage expects the Value to be a
+			 * value that depicts null. For example,
+			 * xmlVar.childNode[nonexistentornullvar] will run into this case.
+			 * (Came to notice via bug FB-25660)
+			 */
+			flash.tools.debugger.Value tempValue = cx.toValue(args[i]);
+			if (tempValue == null) {
+				tempValue = DValue.forPrimitive(null, cx.getIsolateId());
+			}
+			valueArgs[i] = tempValue;
+		}
+
+		String functionName;
+		if (function instanceof Variable) {
+			// Sometimes, the function will show up as a Variable. This happens,
+			// for example, if the user wrote "MyClass.myFunction = function() {
+			// ... }";
+			// String.fromCharCode(), for example, is defined that way.
+			functionName = ((Variable) function).getQualifiedName();
+		} else {
+			functionName = function.toString();
+		}
+		IsolateSession workerSession = session.getWorkerSession(cx
+				.getIsolateId());
+
+		if (isConstructor)
+		{
+			return ((IsolateController) session).callConstructorWorker(functionName, valueArgs, thisObject.getIsolateId());
+		}
+		else
+		{
+			return ((IsolateController) session).callFunctionWorker(thisObject, functionName, valueArgs, thisObject.getIsolateId());
+		}
+	}
+
+	Object compoundBinaryAssignmentBracketExpr(IASNode iNode, Object stem,
+			Object index, Object r, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("compoundBinaryAssignmentBracketExpr");
+		Object leftVariable = reduce_arrayIndexExpr(iNode, stem, false, index);
+		DebuggerValue operationValue = (DebuggerValue) binaryOp(iNode,
+				leftVariable, r, opcode);
+		return reduce_assignToBracketExpr_to_expression(iNode, stem, index,
+				operationValue, false);
+	}
+
+	Object compoundBinaryAssignmentMemberExpr(IASNode iNode, Object stem,
+			Object member, Object r, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("compoundBinaryAssignmentMemberExpr");
+		Object leftVariable = reduce_memberAccessExpr(iNode, stem, member, -1);
+		DebuggerValue operationValue = (DebuggerValue) binaryOp(iNode,
+				leftVariable, r, opcode);
+		return reduce_assignToMemberExpr_to_expression(iNode, stem, member,
+				operationValue);
+	}
+
+	Object compoundBinaryAssignmentNameExpr(IASNode iNode, Object l, Object r,
+			int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("compoundBinaryAssignmentNameExpr");
+		Object leftVariable = transform_name_to_expression(iNode, l);
+		DebuggerValue operationValue = (DebuggerValue) binaryOp(iNode,
+				leftVariable, r, opcode);
+		return reduce_assignToNameExpr_to_expression(iNode, l, operationValue);
+	}
+
+	/**
+	 * Generate a binary operator.
+	 * 
+	 * @param l
+	 *            - the left-hand operand.
+	 * @param r
+	 *            - the right-hand operand.
+	 * @param opcode
+	 *            - the operator's opcode.
+	 * @return the combined instruction sequence with the operator appended.
+	 */
+	Object binaryOp(IASNode iNode, Object l, Object r, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("binaryOp");
+		// REFER : ASC : public Value evaluate(macromedia.asc.util.Context cx,
+		// BinaryExpressionNode node)
+		switch (opcode) {
+		case ABCConstants.OP_add:
+			break;
+		}
+
+		DebuggerValue lhs = (DebuggerValue) l;
+		DebuggerValue rhs = (DebuggerValue) r;
+
+		Context eeContext = contextStack.scope();
+		Session session = eeContext.getSession();
+		switch (opcode) {
+		case ABCConstants.OP_multiply: {
+			// ECMA 11.5
+			double d1 = ECMA.toNumber(session,
+					eeContext.toValue(lhs.debuggerValue));
+			double d2 = ECMA.toNumber(session,
+					eeContext.toValue(rhs.debuggerValue));
+			return new DebuggerValue(new Double(d1 * d2));
+		}
+		case ABCConstants.OP_divide: {
+			// ECMA 11.5
+			double d1 = ECMA.toNumber(session,
+					eeContext.toValue(lhs.debuggerValue));
+			double d2 = ECMA.toNumber(session,
+					eeContext.toValue(rhs.debuggerValue));
+			return new DebuggerValue(new Double(d1 / d2));
+		}
+		case ABCConstants.OP_modulo: {
+			// ECMA 11.5
+			double d1 = ECMA.toNumber(session,
+					eeContext.toValue(lhs.debuggerValue));
+			double d2 = ECMA.toNumber(session,
+					eeContext.toValue(rhs.debuggerValue));
+			return new DebuggerValue(new Double(d1 % d2));
+		}
+		case ABCConstants.OP_add: {
+			// E4X 11.4.1 and ECMA 11.6.1
+			flash.tools.debugger.Value v1 = eeContext
+					.toValue(lhs.debuggerValue);
+			flash.tools.debugger.Value v2 = eeContext
+					.toValue(rhs.debuggerValue);
+
+			boolean isXMLConcat = false;
+
+			if (v1.getType() == VariableType.OBJECT
+					&& v2.getType() == VariableType.OBJECT) {
+				String type1 = v1.getTypeName();
+				String type2 = v2.getTypeName();
+				int at;
+				at = type1.indexOf('@');
+				if (at != -1)
+					type1 = type1.substring(0, at);
+				at = type2.indexOf('@');
+				if (at != -1)
+					type2 = type2.substring(0, at);
+
+				if (type1.equals("XML") || type1.equals("XMLList")) //$NON-NLS-1$ //$NON-NLS-2$
+					if (type2.equals("XML") || type2.equals("XMLList")) //$NON-NLS-1$ //$NON-NLS-2$
+						isXMLConcat = true;
+			}
+
+			if (isXMLConcat) {
+				try {
+					IsolateSession workerSession = session.getWorkerSession(v1
+							.getIsolateId());
+					flash.tools.debugger.Value xml1 = workerSession
+							.callFunction(
+									v1,
+									"toXMLString", new flash.tools.debugger.Value[0]); //$NON-NLS-1$
+					flash.tools.debugger.Value xml2 = session.getWorkerSession(
+							v2.getIsolateId()).callFunction(v2,
+							"toXMLString", new flash.tools.debugger.Value[0]); //$NON-NLS-1$
+					String allXML = xml1.getValueAsString()
+							+ xml2.getValueAsString();
+					flash.tools.debugger.Value allXMLValue = DValue
+							.forPrimitive(allXML, v1.getIsolateId());
+					flash.tools.debugger.Value retval = workerSession
+							.callConstructor(
+									"XMLList", new flash.tools.debugger.Value[] { allXMLValue }); //$NON-NLS-1$
+					return new DebuggerValue(retval);
+				} catch (PlayerDebugException e) {
+					throw new ExpressionEvaluatorException(e);
+				}
+			} else {
+				v1 = ECMA.toPrimitive(session, v1, null,
+						eeContext.getIsolateId());
+				v2 = ECMA.toPrimitive(session, v2, null,
+						eeContext.getIsolateId());
+				if (v1.getType() == VariableType.STRING
+						|| v2.getType() == VariableType.STRING) {
+					return new DebuggerValue(ECMA.toString(session, v1)
+							+ ECMA.toString(session, v2));
+				} else {
+					return new DebuggerValue(new Double(ECMA.toNumber(session,
+							v1) + ECMA.toNumber(session, v2)));
+				}
+			}
+		}
+		case ABCConstants.OP_subtract: {
+			// ECMA 11.6.2
+			double d1 = ECMA.toNumber(session,
+					eeContext.toValue(lhs.debuggerValue));
+			double d2 = ECMA.toNumber(session,
+					eeContext.toValue(rhs.debuggerValue));
+			return new DebuggerValue(new Double(d1 - d2));
+		}
+		case ABCConstants.OP_lshift: {
+			// ECMA 11.7.1
+			int n1 = ECMA
+					.toInt32(session, eeContext.toValue(lhs.debuggerValue));
+			int n2 = (int) (ECMA.toUint32(session,
+					eeContext.toValue(rhs.debuggerValue)) & 0x1F);
+			return new DebuggerValue(new Double(n1 << n2));
+		}
+		case ABCConstants.OP_rshift: {
+			// ECMA 11.7.1
+			int n1 = ECMA
+					.toInt32(session, eeContext.toValue(lhs.debuggerValue));
+			int n2 = (int) (ECMA.toUint32(session,
+					eeContext.toValue(rhs.debuggerValue)) & 0x1F);
+			return new DebuggerValue(new Double(n1 >> n2));
+		}
+		case ABCConstants.OP_urshift: {
+			// ECMA 11.7.1
+			long n1 = ECMA.toUint32(session,
+					eeContext.toValue(lhs.debuggerValue));
+			long n2 = (ECMA.toUint32(session,
+					eeContext.toValue(rhs.debuggerValue)) & 0x1F);
+			return new DebuggerValue(new Double(n1 >>> n2));
+		}
+		case ABCConstants.OP_lessthan: {
+			// ECMA 11.8.1
+			flash.tools.debugger.Value lessThan = ECMA.lessThan(session,
+					eeContext.toValue(lhs.debuggerValue),
+					eeContext.toValue(rhs.debuggerValue));
+			boolean result;
+			if (lessThan.getType() == VariableType.UNDEFINED) {
+				result = false;
+			} else {
+				result = ECMA.toBoolean(lessThan);
+			}
+			return new DebuggerValue(result);
+		}
+		case ABCConstants.OP_greaterthan: {
+			// ECMA 11.8.2
+			flash.tools.debugger.Value greaterThan = ECMA.lessThan(session,
+					eeContext.toValue(rhs.debuggerValue),
+					eeContext.toValue(lhs.debuggerValue));
+			boolean result;
+			if (greaterThan.getType() == VariableType.UNDEFINED) {
+				result = false;
+			} else {
+				result = ECMA.toBoolean(greaterThan);
+			}
+			return new DebuggerValue(result);
+		}
+		case ABCConstants.OP_lessequals: {
+			// ECMA 11.8.3
+			flash.tools.debugger.Value lessThan = ECMA.lessThan(session,
+					eeContext.toValue(rhs.debuggerValue),
+					eeContext.toValue(lhs.debuggerValue));
+			boolean result;
+			if (lessThan.getType() == VariableType.UNDEFINED) {
+				result = false;
+			} else {
+				result = !ECMA.toBoolean(lessThan);
+			}
+			return new DebuggerValue(result);
+		}
+		case ABCConstants.OP_greaterequals: {
+			// ECMA 11.8.4
+			flash.tools.debugger.Value lessThan = ECMA.lessThan(session,
+					eeContext.toValue(lhs.debuggerValue),
+					eeContext.toValue(rhs.debuggerValue));
+			boolean result;
+			if (lessThan.getType() == VariableType.UNDEFINED) {
+				result = false;
+			} else {
+				result = !ECMA.toBoolean(lessThan);
+			}
+			return new DebuggerValue(result);
+		}
+		case ABCConstants.OP_instanceof: {
+			try {
+				return new DebuggerValue(session.getWorkerSession(
+						eeContext.getIsolateId()).evalInstanceof(
+						eeContext.toValue(lhs.debuggerValue),
+						eeContext.toValue(rhs.debuggerValue)));
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			} catch (PlayerFaultException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		}
+		case ABCConstants.OP_in: {
+			try {
+				return new DebuggerValue(session.getWorkerSession(
+						eeContext.getIsolateId()).evalIn(
+						eeContext.toValue(lhs.debuggerValue),
+						eeContext.toValue(rhs.debuggerValue)));
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			} catch (PlayerFaultException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		}
+		case ABCConstants.OP_istypelate: {
+			try {
+				return new DebuggerValue(session.getWorkerSession(
+						eeContext.getIsolateId()).evalIs(
+						eeContext.toValue(lhs.debuggerValue),
+						eeContext.toValue(rhs.debuggerValue)));
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			} catch (PlayerFaultException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		}
+		case ABCConstants.OP_astypelate: {
+			try {
+				return new DebuggerValue(session.getWorkerSession(
+						eeContext.getIsolateId()).evalAs(
+						eeContext.toValue(lhs.debuggerValue),
+						eeContext.toValue(rhs.debuggerValue)));
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			} catch (PlayerFaultException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		}
+		case ABCConstants.OP_equals: {
+			// ECMA 11.9.1
+			return new DebuggerValue(new Boolean(ECMA.equals(session,
+					eeContext.toValue(lhs.debuggerValue),
+					eeContext.toValue(rhs.debuggerValue))));
+		}
+		// ASC3 notequals is a sepearate reducer nequals
+		// case ABCConstants.op_Tokens.NOTEQUALS_TOKEN:
+		// {
+		// // ECMA 11.9.2
+		// return new DebuggerValue(new Boolean(!ECMA.equals(session,
+		// eeContext.toValue(lhs.debuggerValue), eeContext
+		// .toValue(rhs.debuggerValue))));
+		// }
+		case ABCConstants.OP_strictequals: {
+			// ECMA 11.9.4
+			return new DebuggerValue(new Boolean(ECMA.strictEquals(
+					eeContext.toValue(lhs.debuggerValue),
+					eeContext.toValue(rhs.debuggerValue))));
+		}
+		// ASC3 notequals is a sepearate reducer nequals
+		/*
+		 * case Tokens.STRICTNOTEQUALS_TOKEN: { // ECMA 11.9.5 return new
+		 * DebuggerValue(new
+		 * Boolean(!ECMA.strictEquals(eeContext.toValue(lhs.debuggerValue),
+		 * eeContext .toValue(rhs.debuggerValue)))); }
+		 */
+		case ABCConstants.OP_bitand: {
+			// ECMA 11.10
+			return new DebuggerValue(new Double(ECMA.toInt32(session,
+					eeContext.toValue(lhs.debuggerValue))
+					& ECMA.toInt32(session,
+							eeContext.toValue(rhs.debuggerValue))));
+		}
+		case ABCConstants.OP_bitxor: {
+			// ECMA 11.10
+			return new DebuggerValue(new Double(ECMA.toInt32(session,
+					eeContext.toValue(lhs.debuggerValue))
+					^ ECMA.toInt32(session,
+							eeContext.toValue(rhs.debuggerValue))));
+		}
+		case ABCConstants.OP_bitor: {
+			// ECMA 11.10
+			return new DebuggerValue(new Double(ECMA.toInt32(session,
+					eeContext.toValue(lhs.debuggerValue))
+					| ECMA.toInt32(session,
+							eeContext.toValue(rhs.debuggerValue))));
+		}
+		/*
+		 * ASC3 reduce_logicalAndExpr & reduce_logicalOrExpr sepearate reducers
+		 * case Tokens.LOGICALAND_TOKEN: { // ECMA 11.11
+		 * flash.tools.debugger.Value result =
+		 * eeContext.toValue(lhs.debuggerValue); if (ECMA.toBoolean(result)) {
+		 * rhs = (DebuggerValue) node.rhs.evaluate(cx, this); result =
+		 * eeContext.toValue(rhs.debuggerValue); } return new
+		 * DebuggerValue(result); } case Tokens.LOGICALOR_TOKEN: { // ECMA 11.11
+		 * flash.tools.debugger.Value result =
+		 * eeContext.toValue(lhs.debuggerValue); if (!ECMA.toBoolean(result)) {
+		 * rhs = (DebuggerValue) node.rhs.evaluate(cx, this); result =
+		 * eeContext.toValue(rhs.debuggerValue); } return new
+		 * DebuggerValue(result); }
+		 */
+		// case Tokens.EMPTY_TOKEN:
+		// // do nothing, already been folded
+		// return new DebuggerValue(null);
+		default:
+			//cx.internalError(ASTBuilder.getLocalizationManager().getLocalizedTextString("unrecognizedBinaryOperator")); //$NON-NLS-1$
+			return new DebuggerValue(null);
+		}
+	}
+
+	/**
+	 * Resolve a dotted name, e.g., foo.bar.baz
+	 */
+	Object dottedName(IASNode iNode, String qualifiers, String base_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("dottedName");
+		return qualifiers + "." + base_name;
+	}
+
+	/**
+	 * Error trap.
+	 */
+	public Object error_namespaceAccess(IASNode iNode, IASNode raw_qualifier,
+			Object qualified_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("error_namespaceAccess");
+		return null;
+	}
+
+	/**
+	 * Error trap.
+	 */
+	public Object error_reduce_Op_AssignId(IASNode iNode, Object non_lvalue,
+			Object rvalue) {
+		if (hookallreducercalls)
+			hookforreducercalls("error_reduce_Op_AssignId");
+		return null;
+	}
+
+	/**
+	 * @return the double content of a numeric literal.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Double getDoubleContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getDoubleContent");
+		return SemanticUtils.getDoubleContent(iNode);
+	}
+
+	/**
+	 * @return the double content of a numeric literal.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Float getFloatContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getFloatContent");
+		//return SemanticUtils.getFloatContent(iNode);
+		return null;
+	}
+
+	/**
+	 * @return the name of an identifier.
+	 * @param iNode
+	 *            - the IIdentifier node.
+	 */
+	String getIdentifierContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getIdentifierContent");
+		return SemanticUtils.getIdentifierContent(iNode);
+	}
+
+	/**
+	 * @return the int content of a numeric literal.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Integer getIntegerContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getIntegerContent");
+		return SemanticUtils.getIntegerContent(iNode);
+	}
+
+	/**
+	 * @return always zero.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Integer getIntegerZeroContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getIntegerZeroContent");
+		return 0;
+	}
+
+	/**
+	 * @return always zero.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Long getIntegerZeroContentAsLong(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getIntegerZeroContentAsLong");
+		return 0L;
+	}
+
+	/**
+	 * @return the string content of a literal.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	String getStringLiteralContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getStringLiteralContent");
+		return SemanticUtils.getStringLiteralContent(iNode);
+	}
+
+	/**
+	 * @return the uint content of a numeric literal.
+	 * @param iNode
+	 *            - the literal node.
+	 */
+	Long getUintContent(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("getUintContent");
+		return SemanticUtils.getUintContent(iNode);
+	}
+
+	/*
+	 * *******************************
+	 * ** Cost/Decision Functions ** *******************************
+	 */
+
+	public int isIntLiteral(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isIntLiteral");
+		if (iNode.getNodeID() == ASTNodeID.LiteralNumberID) {
+			INumericValue numericVal = ((NumericLiteralNode) iNode)
+					.getNumericValue();
+
+			if (numericVal.getAssumedType() == IASLanguageConstants.BuiltinType.INT) {
+				return 1;
+			}
+		}
+		return Integer.MAX_VALUE;
+	}
+
+	public int isUintLiteral(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isUintLiteral");
+		if (iNode.getNodeID() == ASTNodeID.LiteralNumberID) {
+			INumericValue numericVal = ((NumericLiteralNode) iNode)
+					.getNumericValue();
+
+			if (numericVal.getAssumedType() == IASLanguageConstants.BuiltinType.UINT) {
+				return 1;
+			}
+		}
+		return Integer.MAX_VALUE;
+	}
+
+	public int isDoubleLiteral(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isDoubleLiteral");
+		if (iNode.getNodeID() == ASTNodeID.LiteralDoubleID) {
+			return 2;
+		}
+		return Integer.MAX_VALUE;
+	}
+
+	/*
+	public int isFloatLiteral(IASNode iNode) {
+		if (iNode.getNodeID() == ASTNodeID.LiteralNumberID) {
+			INumericValue numericVal = ((NumericLiteralNode) iNode)
+					.getNumericValue();
+
+			if (numericVal.getAssumedType() == IASLanguageConstants.BuiltinType.NUMBER) {
+				return 1;
+			}
+			return Integer.MAX_VALUE;
+		}
+		return Integer.MAX_VALUE;
+	}
+	*/
+
+	/**
+	 * Explore a MemberAccessNode and decide if its stem is a reference to a
+	 * package. This method will always return a result greater than what
+	 * isPackageName will return, as package name must "win" over dotted name.
+	 */
+	int isDottedName(IASNode n) {
+		if (hookallreducercalls)
+			hookforreducercalls("isDottedName");
+		int result = Integer.MAX_VALUE;
+
+		if (n instanceof MemberAccessExpressionNode) {
+			MemberAccessExpressionNode ma = (MemberAccessExpressionNode) n;
+
+			if (ma.stemIsPackage())
+				// This needs to be greater than the value returned from
+				// isPackageName,
+				// so that isPackageName wins
+				result = 2;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Explore a MemberAccessNode and decide if it is a reference to a package.
+	 * This method will always return a result less than what isDottedName will
+	 * return, as package name must "win" over dotted name.
+	 */
+	int isPackageName(IASNode n) {
+		if (hookallreducercalls)
+			hookforreducercalls("isPackageName");
+		int result = Integer.MAX_VALUE;
+
+		if (n instanceof MemberAccessExpressionNode) {
+			MemberAccessExpressionNode ma = (MemberAccessExpressionNode) n;
+
+			if (ma.isPackageReference())
+				// This needs to be less than the value returned from
+				// isDottedName,
+				// so that isPackageName wins
+				result = 1;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Get the definition associated with a node's qualifier and decide if the
+	 * qualifier is a compile-time constant.
+	 * 
+	 * @param iNode
+	 *            - the node to check.
+	 * @pre - the node has an IdentifierNode 0th child.
+	 * @return an attractive cost if the child has a known namespace, i.e., it's
+	 *         a compile-time constant qualifier.
+	 */
+	int qualifierIsCompileTimeConstant(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("qualifierIsCompileTimeConstant");
+		IdentifierNode qualifier = (IdentifierNode) SemanticUtils
+				.getNthChild(iNode, 0);
+		IDefinition def = qualifier.resolve(project);
+
+		int result = def instanceof NamespaceDefinition ? 1 : Integer.MAX_VALUE;
+		return result;
+	}
+
+	/**
+	 * @return a feasible cost if a node has a compile-time constant defintion.
+	 */
+	int isCompileTimeConstant(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isCompileTimeConstant");
+		if (SemanticUtils.transformNameToConstantValue(iNode, project) != null)
+			return 1;
+		else
+			return Integer.MAX_VALUE;
+	}
+
+	/**
+	 * @return a feasible cost if a node has a compile-time constant defintion.
+	 */
+	int isCompileTimeConstantFunction(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isCompileTimeConstantFunction");
+		IDefinition def = ((IdentifierNode)iNode).resolve(project);
+		if (SemanticUtils.isConstDefinition(def))
+			return 1;
+		else
+			return Integer.MAX_VALUE;
+	}
+
+	/**
+	 * @return a feasible cost if the parameterized type's base and parameter
+	 *         types are compile-time constants, ERROR_TRAP if not.
+	 */
+	int parameterTypeIsConstant(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("parameterTypeIsConstant");
+		return Math.max(isKnownType(SemanticUtils.getNthChild(iNode, 0)),
+				isKnownType(SemanticUtils.getNthChild(iNode, 1)));
+	}
+
+	/**
+	 * @return a feasible cost if the given node is a known type, ERROR_TRAP
+	 *         otherwise.
+	 */
+	int isKnownType(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isKnownType");
+		boolean isConstant = false;
+		if (iNode instanceof IExpressionNode) {
+			isConstant = ((IExpressionNode) iNode).resolve(project) instanceof ITypeDefinition;
+		}
+
+		return isConstant ? 1 : ERROR_TRAP;
+	}
+
+	/**
+	 * Reduce a function call to a constant value. This is only possible for a
+	 * limited set of function calls, and you should call
+	 * isCompileTimeConstantFunction first to make sure this is possible.
+	 * 
+	 * @param iNode
+	 *            the IFunctionCallNode
+	 * @param method
+	 *            the Object of the method to call
+	 * @param constant_args
+	 *            the constant_values used as arguments to the function call
+	 * @return A constant value that that would be the result of calling the
+	 *         function at runtime with the specified arguments
+	 */
+	public Object transform_constant_function_to_value(IASNode iNode,
+			Object method, Vector<Object> constant_args) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_constant_function_to_value");
+		return null;
+	}
+
+	/**
+	 * @return a feasible cost if the node is a BinaryExpression, and the type
+	 *         of the left or right side of the expressions resolves to "float"
+	 */
+	int isFloatBinOp(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isFloatBinOp");
+		return 0;
+	}
+
+	/**
+	 * @return a feasible cost (1) if the node is for 'new Array()'
+	 */
+	int isEmptyArrayConstructor(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isEmptyArrayConstructor");
+		IIdentifierNode identifierNode = (IIdentifierNode) SemanticUtils
+				.getNthChild(iNode, 1);
+		if (identifierNode.resolve(project) == project
+				.getBuiltinType(IASLanguageConstants.BuiltinType.ARRAY))
+			return 1;
+
+		return Integer.MAX_VALUE;
+	}
+
+	/**
+	 * @return a feasible cost (1) if the node is for 'new Object()'
+	 */
+	int isEmptyObjectConstructor(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("isEmptyObjectConstructor");
+		IIdentifierNode identifierNode = (IIdentifierNode) SemanticUtils
+				.getNthChild(iNode, 1);
+		if (identifierNode.resolve(project) == project
+				.getBuiltinType(IASLanguageConstants.BuiltinType.OBJECT))
+			return 1;
+
+		return Integer.MAX_VALUE;
+	}
+
+	/*
+	 * *************************
+	 * ** Reduction actions ** *************************
+	 */
+
+	public Object reduce_arrayIndexExpr(IASNode iNode, Object stem,
+			boolean is_super, Object index) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_arrayIndexExpr");
+		return reduce_memberAccessExpr(iNode, stem, index, -1);
+	}
+
+	public Object reduce_arrayLiteral(IASNode iNode, Vector<Object> elements) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_arrayLiteral");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_assignToBracketExpr_to_expression(IASNode iNode,
+			Object stem, Object index, Object r, boolean is_super) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToBracketExpr_to_expression");
+		Context eeContext = contextStack.scope();
+		Context newContext = eeContext
+				.createContext(((DebuggerValue) stem).debuggerValue);
+		contextStack.pushScope(newContext);
+		try {
+			return reduce_assignToNameExpr_to_expression(iNode, index, r);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_assignToMemberExpr_to_expression(IASNode iNode,
+			Object stem, Object member, Object r) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToMemberExpr_to_expression");
+		Context eeContext = contextStack.scope();
+		Context newContext = eeContext
+				.createContext(((DebuggerValue) stem).debuggerValue);
+		contextStack.pushScope(newContext);
+		try {
+			return reduce_assignToNameExpr_to_expression(iNode, member, r);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_assignToDescendantsExpr(IASNode iNode, Object stem,
+			Object member, Object r, boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToDescendantsExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_assignToNameExpr_to_expression(IASNode iNode,
+			Object lvalue, Object r) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToNameExpr_to_expression");
+
+		// ASC : Refer : evaluate(macromedia.asc.util.Context cx,
+		// SetExpressionNode node)
+		Context eeContext = contextStack.scope();
+		DebuggerValue lhs = (DebuggerValue) lvalue;
+		Object variableToAssignTo;
+		// if (node.getMode() == Tokens.LEFTBRACKET_TOKEN || node.getMode() ==
+		// Tokens.EMPTY_TOKEN)
+		{
+			variableToAssignTo = ECMA.toString(eeContext.getSession(),
+					eeContext.toValue(lhs.debuggerValue));
+		}
+		// else
+		// {
+		// variableToAssignTo = rhs.debuggerValue;
+		// }
+
+		DebuggerValue newValue = (DebuggerValue) r;
+
+		try {
+			eeContext.assign(variableToAssignTo,
+					eeContext.toValue(newValue.debuggerValue));
+		} catch (NoSuchVariableException e) {
+			throw new ExpressionEvaluatorException(e);
+		} catch (PlayerFaultException e) {
+			throw new ExpressionEvaluatorException(e);
+		}
+		return newValue;
+	}
+
+	// Not supported :: //throw error
+	public Object reduce_assignToQualifiedMemberExpr(IASNode iNode,
+			Object stem, Object qualifier, Object member, Object rhs,
+			boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToQualifiedMemberExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	// Not supported :: //throw error
+	public Object reduce_assignToQualifiedRuntimeMemberExpr(IASNode iNode,
+			Object stem, Object qualifier, Object runtime_member_selector,
+			Object rhs, boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToQualifiedRuntimeMemberExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	// Not supported :: //throw error
+	public Object reduce_assignToQualifiedAttributeExpr(IASNode iNode,
+			Object stem, Object qualifier, Object member, Object rhs,
+			boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToQualifiedAttributeExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_assignToRuntimeNameExpr(IASNode iNode, Object lval,
+			Object r, final boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToRuntimeNameExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_assignToUnqualifiedRuntimeAttributeExpr(IASNode iNode,
+			Object stem, Object rt_attr, Object rhs, boolean need_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_assignToUnqualifiedRuntimeAttributeExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$;
+	}
+
+	public Object reduce_attributeName(IASNode iNode, Object attr_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_attributeName");
+		return new DebuggerValue("@"
+				+ ((DebuggerValue) attr_name).debuggerValue);
+	}
+
+	public Boolean reduce_booleanLiteral(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_booleanLiteral");
+		return SemanticUtils.getBooleanContent(iNode);
+	}
+
+	public String reduce_by_concatenation(IASNode iNode, String first,
+			String second) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_by_concatenation");
+		return first + "." + second;
+	}
+
+	public Object reduce_commaExpr(IASNode iNode, Object payload_expr,
+			Vector<Object> exprs) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_commaExpr");
+		Object result = null;
+		return result;
+	}
+
+	/**
+	 * Reduce expression like:<br>
+	 * {@code delete o[p]}
+	 * 
+	 * @param iNode
+	 *            Tree node for the {@code delete} statement.
+	 * @param stem
+	 *            Instructions for creating a {@code DynamicAccessNode}.
+	 * @param index
+	 *            Instructions for initializing the index expression.
+	 * @return Instructions for executing a {@code delete} statement.
+	 */
+	public Object reduce_deleteBracketExpr(IASNode iNode, Object stem,
+			Object index) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteBracketExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	/**
+	 * Reduce E4X expression like:<br>
+	 * {@code delete x.@[foo]}
+	 * 
+	 * @param iNode
+	 *            Tree node for the {@code delete} statement.
+	 * @param stem
+	 *            Instructions for creating a {@code MemberAccessExpressionNode}
+	 *            .
+	 * @param index
+	 *            Instructions for initializing the array index expression.
+	 * @return Instructions for executing a {@code delete} statement.
+	 */
+	public Object reduce_deleteAtBracketExpr(IASNode iNode, Object stem,
+			Object index) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteAtBracketExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_deleteDescendantsExpr(IASNode iNode, Object stem,
+			Object field) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteDescendantsExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_deleteExprExprExpr(IASNode iNode, Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteExprExprExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_deleteMemberExpr(IASNode iNode, Object stem,
+			Object field) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteMemberExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_deleteRuntimeNameExpr(IASNode iNode, Object stem,
+			Object rt_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteRuntimeNameExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_deleteNameExpr(IASNode iNode, Object n) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_deleteNameExpr");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("delete")); //$NON-NLS-1$
+	}
+
+	public Object reduce_e4xFilter(IASNode iNode, Object stem, Object filter) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_e4xFilter");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_embed(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_embed");
+		Object result = null;
+		return result;
+	}
+
+	/**
+	 * Reduce expression like:<br>
+	 * {@code a[i]()}
+	 * 
+	 * @param iNode
+	 *            Tree node for the function call.
+	 * @param stem
+	 *            Instructions for creating a {@code DynamicAccessNode}.
+	 * @param index
+	 *            Instructions for initializing the index expression.
+	 * @return Instructions for executing a {@code function call} statement.
+	 */
+	public Object reduce_functionAsBracketExpr(IASNode iNode, Object stem,
+			Object index, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionAsBracketExpr");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_functionAsMemberExpr(IASNode iNode, Object stem,
+			Object method_name, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionAsMemberExpr");
+		try {
+			Context context = contextStack.scope();
+			DebuggerValue lhs = (DebuggerValue) stem;
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			return reduce_functionCall_common(iNode, method_name, args, true,
+					false);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_functionAsRandomExpr(IASNode iNode,
+			Object random_expr, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionAsRandomExpr");
+		return reduce_functionCall_common(iNode, random_expr, args, true, false);
+	}
+
+	public Object reduce_functionCallExpr_to_expression(IASNode iNode,
+			Object method_name, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionCallExpr_to_expression");
+		return reduce_functionCall_common(iNode, method_name, args, true, false);
+	}
+
+	public Object reduce_functionCallSpecial_to_expression(IASNode iNode,
+			Object method_name, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionCallSpecial_to_expression");
+		IdentifierNode id = (IdentifierNode)method_name;
+		
+		Context context = contextStack.scope();
+		try {
+			Object[] argValues = new Object[1];
+			for (int i = 0; i < args.size(); i++) {
+				DebuggerValue dv = (DebuggerValue) args.get(i);
+				argValues[i] = dv.debuggerValue;
+			}
+			return new DebuggerValue(callFunction(context, false,
+					id.getName(), argValues));
+		} catch (PlayerDebugException e) {
+			throw new ExpressionEvaluatorException(e);
+		}
+	}
+
+	private Object reduce_functionCall_common(IASNode iNode,
+			Object method_name, Vector<Object> args, boolean need_result,
+			boolean isConstructor) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionCall_common");
+
+		Context context = contextStack.scope();
+		DebuggerValue func = (DebuggerValue) method_name;
+		try {
+			Object[] argValues = new Object[args.size()];
+			for (int i = 0; i < args.size(); i++) {
+				DebuggerValue dv = (DebuggerValue) args.get(i);
+				argValues[i] = dv.debuggerValue;
+			}
+			return new DebuggerValue(callFunction(context, isConstructor,
+					func.debuggerValue, argValues));
+		} catch (PlayerDebugException e) {
+			throw new ExpressionEvaluatorException(e);
+		}
+	}
+
+	public Object reduce_functionCallOfSuperclassMethod_to_expression(
+			IASNode iNode, Object stem, Object method_name, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_functionCallOfSuperclassMethod_to_expression");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("super")); //$NON-NLS-1$
+	}
+
+	public Object reduce_logicalAndExpr(IASNode iNode, Object l, Object r) {
+		// REFER : ASC : public Value evaluate(macromedia.asc.util.Context cx,
+		// BinaryExpressionNode node)
+		// ECMA 11.11
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_logicalAndExpr");
+		Context eeContext = contextStack.scope();
+		DebuggerValue lhs = (DebuggerValue) l;
+		flash.tools.debugger.Value result = eeContext
+				.toValue(lhs.debuggerValue);
+
+		if (ECMA.toBoolean(result)) {
+			DebuggerValue rhs = null;
+			if (r instanceof DebuggerValue) {
+				rhs = (DebuggerValue) r;
+			} else {
+				rhs = ((UnEvaluatedDebugExpression) r).evaluate(eeContext);
+			}
+
+			result = eeContext.toValue(rhs.debuggerValue);
+		}
+		return new DebuggerValue(result);
+	}
+
+	public Object reduce_logicalNotExpr(IASNode iNode, Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_logicalNotExpr");
+		Context eeContext = contextStack.scope();
+		DebuggerValue arg = (DebuggerValue) expr;
+		// ECMA 11.4.9
+		return new DebuggerValue(new Boolean(!ECMA.toBoolean(eeContext
+				.toValue(arg.debuggerValue))));
+	}
+
+	public Object reduce_logicalOrExpr(IASNode iNode, Object l, Object r) {
+		// REFER : ASC : public Value evaluate(macromedia.asc.util.Context cx,
+		// BinaryExpressionNode node)
+		// ECMA 11.11
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_logicalOrExpr");
+		Context eeContext = contextStack.scope();
+		DebuggerValue lhs = (DebuggerValue) l;
+		flash.tools.debugger.Value result = eeContext
+				.toValue(lhs.debuggerValue);
+
+		if (!ECMA.toBoolean(result)) {
+			DebuggerValue rhs = null;
+			if (rhs instanceof DebuggerValue) {
+				rhs = (DebuggerValue) r;
+			} else {
+				rhs = ((UnEvaluatedDebugExpression) r).evaluate(eeContext);
+			}
+			result = eeContext.toValue(rhs.debuggerValue);
+		}
+		return new DebuggerValue(result);
+	}
+
+	/**
+	 * reduce a MemberAccessExpression. This example just concats the stem and
+	 * member together
+	 */
+	public Object reduce_memberAccessExpr(IASNode iNode, Object stem,
+			Object member, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_memberAccessExpr");
+		DebuggerValue lhs = (DebuggerValue) stem;
+		Context context = contextStack.scope();
+		boolean pushedScope = false;
+		if (lhs != null) {
+			flash.tools.debugger.Value lhsValue = context
+					.toValue(lhs.debuggerValue);
+			if (ECMA.equals(context.getSession(), lhsValue,
+					context.toValue(null)))
+				throw new ExpressionEvaluatorException(ASTBuilder
+						.getLocalizationManager().getLocalizedTextString(
+								"nullPointerException")); //$NON-NLS-1$
+
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			pushedScope = true;
+		}
+
+		try {
+			DebuggerValue rhs = (DebuggerValue) transform_name_to_expression(
+					iNode, member);
+
+			return rhs;// node.selector.evaluate(cx, this);
+		} finally {
+			if (pushedScope)
+				contextStack.popScope();
+		}
+		// return stem + "." + member;
+	}
+
+	public Object reduce_qualifiedMemberAccessExpr(IASNode iNode, Object stem,
+			Object qualifier, Object member, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_qualifiedMemberAccessExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_qualifiedAttributeRuntimeMemberExpr(IASNode iNode,
+			Object stem, Object qualifier, Object runtime_member_selector,
+			int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_qualifiedAttributeRuntimeMemberExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_qualifiedMemberRuntimeNameExpr(IASNode iNode,
+			Object stem, Object qualifier, Object runtime_member_selector) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_qualifiedMemberRuntimeNameExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$;
+	}
+
+	public Object reduce_qualifiedAttributeExpr(IASNode iNode, Object stem,
+			Object qualifier, Object member, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_qualifiedAttributeExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_unqualifiedAttributeExpr(IASNode iNode, Object stem,
+			Object rt_attr, int opcode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_unqualifiedAttributeExpr");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$	}
+	}
+
+	/**
+	 * Reduce runtime attribute expression, such as {@code @[exp]}.
+	 * 
+	 * @param iNode
+	 *            Node for {@code @[...]}. It is a
+	 *            {@code ArrayIndexExpressionID(Op_AtID, ...)}.
+	 * @param rt_attr
+	 *            Instructions generated for the runtime name expression.
+	 * @return Instructions to get the value of an attribute described with a
+	 *         runtime name.
+	 */
+	public Object reduce_runtimeAttributeExp(IASNode iNode, Object rt_attr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_runtimeAttributeExp");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceAccess(IASNode iNode, IASNode qualifier,
+			Object qualified_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceAccess");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceAsName_to_expression(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceAsName_to_expression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceAsName_to_multinameL(IASNode iNode,
+			final boolean is_attribute) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceAsName_to_multinameL");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceAsName_to_name(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceAsName_to_name");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceMultinameL(IASNode iNode,
+			IASNode qualifier_node, Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceMultinameL");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceRTQName(IASNode iNode, Object qualifier,
+			Object qualified_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceRTQName");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_namespaceRTQNameL(IASNode iNode, Object qualifier,
+			Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_namespaceRTQNameL");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_neqExpr(IASNode iNode, Object l, Object r) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_neqExpr");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_nameToTypeName(Object name, boolean check_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_nameToTypeName");
+		return name;
+	}
+
+	public Object reduce_newMemberProperty(IASNode iNode, Object stem,
+			Object member, Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newMemberProperty");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_newAsRandomExpr(IASNode iNode, Object random_expr,
+			Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newAsRandomExpr");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_newEmptyArray(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newEmptyArray");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_newEmptyObject(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newEmptyObject");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_newExpr(IASNode iNode, Object class_Object,
+			Vector<Object> args) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newExpr");
+
+		return reduce_functionCall_common(iNode, class_Object, args, true, true);
+	}
+
+	public Object reduce_newVectorLiteral(IASNode iNode, Object literal) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_newVectorLiteral");
+		return literal;
+	}
+
+	public Object reduce_nilExpr_to_expression(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_nilExpr_to_expression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_nullLiteral_to_constant_value(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_nullLiteral_to_constant_value");
+		return new DebuggerValue(null);
+	}
+
+	public Object reduce_nullLiteral_to_object_literal(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_nullLiteral_to_object_literal");
+		return new DebuggerValue(null);
+	}
+
+	public Object reduce_objectLiteral(IASNode iNode, Vector<Object> elements) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_objectLiteral");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_objectLiteralElement(IASNode iNode, Object id,
+			Object value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_objectLiteralElement");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_parameterizedTypeName(IASNode iNode, Object base,
+			Object param) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_parameterizedTypeName");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_parameterizedTypeExpression(IASNode iNode,
+			Object base, Object param) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_parameterizedTypeExpression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_postDecBracketExpr(IASNode iNode, Object stem,
+			Object index, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postDecBracketExpr");
+
+		return reduce_postDecMemberExpr(iNode, stem, index, need_result);
+	}
+
+	public Object reduce_postDecMemberExpr(IASNode iNode, Object stem,
+			Object field, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postDecMemberExpr");
+		try {
+			DebuggerValue lhs = (DebuggerValue) stem;
+			Context context = contextStack.scope();
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			return reduce_prePostIncDecExpr(iNode, field, true, false);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_postDecNameExpr(IASNode iNode, Object unary,
+			boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postDecNameExpr");
+		return reduce_prePostIncDecExpr(iNode, unary, true, false);
+	}
+
+	public Object reduce_postIncBracketExpr(IASNode iNode, Object stem,
+			Object index, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postIncBracketExpr");
+		return reduce_postIncMemberExpr(iNode, stem, index, need_result);
+	}
+
+	public Object reduce_postIncMemberExpr(IASNode iNode, Object stem,
+			Object field, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postIncMemberExpr");
+		try {
+			DebuggerValue lhs = (DebuggerValue) stem;
+			Context context = contextStack.scope();
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			return reduce_prePostIncDecExpr(iNode, field, true, true);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_postIncNameExpr(IASNode iNode, Object unary,
+			boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_postIncNameExpr");
+		return reduce_prePostIncDecExpr(iNode, unary, true, true);
+	}
+
+	public Object reduce_preDecBracketExpr(IASNode iNode, Object stem,
+			Object index, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preDecBracketExpr");
+		return reduce_preDecMemberExpr(iNode, stem, index, need_result);
+	}
+
+	public Object reduce_preDecMemberExpr(IASNode iNode, Object stem,
+			Object field, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preDecMemberExpr");
+		try {
+			DebuggerValue lhs = (DebuggerValue) stem;
+			Context context = contextStack.scope();
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			return reduce_prePostIncDecExpr(iNode, field, false, false);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_preDecNameExpr(IASNode iNode, Object unary,
+			boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preDecNameExpr");
+		return reduce_prePostIncDecExpr(iNode, unary, false, false);
+	}
+
+	public Object reduce_preIncBracketExpr(IASNode iNode, Object stem,
+			Object index, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preIncBracketExpr");
+		return reduce_preIncMemberExpr(iNode, stem, index, need_result);
+	}
+
+	public Object reduce_preIncMemberExpr(IASNode iNode, Object stem,
+			Object field, boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preIncMemberExpr");
+		try {
+			DebuggerValue lhs = (DebuggerValue) stem;
+			Context context = contextStack.scope();
+			Context newContext = context.createContext(lhs.debuggerValue);
+			contextStack.pushScope(newContext);
+			return reduce_prePostIncDecExpr(iNode, field, false, true);
+		} finally {
+			contextStack.popScope();
+		}
+	}
+
+	public Object reduce_preIncNameExpr(IASNode iNode, Object unary,
+			boolean need_result) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_preIncNameExpr");
+		return reduce_prePostIncDecExpr(iNode, unary, false, true);
+	}
+
+	public Object reduce_prePostIncDecExpr(IASNode iNode, Object unary,
+			boolean isPostFix, boolean isIncrement) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_prePostIncDecExpr");
+		try {
+			DebuggerValue expr = (DebuggerValue) unary;
+			Context debuggerContext = contextStack.scope();
+			String memberName = ECMA.toString(debuggerContext.getSession(),
+					debuggerContext.toValue(expr.debuggerValue));
+
+			Object lookupResult = debuggerContext.lookup(memberName);
+
+			double before = ECMA.toNumber(debuggerContext.getSession(),
+					debuggerContext.toValue(lookupResult));
+			double after;
+			if (isIncrement) {
+				after = before + 1;
+			} else {
+				after = before - 1;
+			}
+			debuggerContext.assign(memberName,
+					debuggerContext.toValue(new Double(after)));
+
+			Object result;
+			if (isPostFix) {
+				result = new Double(before);
+			} else {
+				result = new Double(after);
+			}
+
+			return new DebuggerValue(result);
+		} catch (NoSuchVariableException e) {
+			throw new ExpressionEvaluatorException(e);
+		} catch (PlayerFaultException e) {
+			throw new ExpressionEvaluatorException(e);
+		}
+	}
+
+	public Object reduce_regexLiteral(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_regexLiteral");
+		if (iNode instanceof RegExpLiteralNode) {
+			RegExpLiteralNode rgXNode = (RegExpLiteralNode) iNode;
+			String val = rgXNode.getValue(true);
+			String flags;
+			String re;
+			if (val.length() > 0 && val.charAt(0) == '/') {
+				int lastSlash = val.lastIndexOf('/');
+				re = val.substring(1, lastSlash);
+				flags = val.substring(lastSlash + 1);
+			} else {
+				re = val;
+				flags = ""; //$NON-NLS-1$
+			}
+			Context eeContext = contextStack.scope();
+			try {
+				return new DebuggerValue(callFunction(eeContext, true,
+						"RegExp", new Object[] { re, flags })); //$NON-NLS-1$
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		}
+		throw new ExpressionEvaluatorException("Unable to resolve regex");
+	}
+
+	public Object reduce_runtimeNameExpression(IASNode iNode, Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_runtimeNameExpression");
+		return expr;
+	}
+
+	/**
+	 * Reduce an identifier node This just returns the name of the name
+	 * currently.
+	 */
+	public Object reduce_simpleName(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_simpleName");
+		return new DebuggerValue(((IdentifierNode) iNode).getName());
+	}
+
+	public Object reduce_declName(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_declName");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_strictneqExpr(IASNode iNode, Object l, Object r) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_strictneqExpr");
+		Context eeContext = contextStack.scope();
+		DebuggerValue lhs = (DebuggerValue) l;
+		DebuggerValue rhs = (DebuggerValue) r;
+		// ECMA 11.9.5
+		return new DebuggerValue(new Boolean(!ECMA.strictEquals(
+				eeContext.toValue(lhs.debuggerValue),
+				eeContext.toValue(rhs.debuggerValue))));
+	}
+
+	public Object reduce_superAccess(IASNode iNode, Object qualified_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_superAccess");
+		throw new ExpressionEvaluatorException(keywordNotAllowed("super")); //$NON-NLS-1$
+	}
+
+	public Object reduce_ternaryExpr(IASNode iNode, Object test,
+			Object when_true, Object when_false) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_ternaryExpr");
+		DebuggerValue condition = (DebuggerValue) test;
+		Context eeContext = contextStack.scope();
+		boolean b = ECMA.toBoolean(eeContext.toValue(condition.debuggerValue));
+		if (b) {
+			return when_true;
+		} else {
+			return when_false;
+		}
+	}
+
+	public Object reduce_typedVariableExpression(IASNode iNode,
+			Object var_name, Object var_type) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_typedVariableExpression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	// transform_name_to_expression
+	public Object reduce_typeof_expr(IASNode iNode, Object operand) {
+		// ECMA 11.4.3
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_typeof_expr");
+		Context eeContext = contextStack.scope();
+		DebuggerValue arg = (DebuggerValue) operand;
+		flash.tools.debugger.Value value = eeContext.toValue(arg.debuggerValue);
+		switch (value.getType()) {
+		case VariableType.UNDEFINED:
+			return new DebuggerValue("undefined"); //$NON-NLS-1$
+		case VariableType.NULL:
+			return new DebuggerValue("object"); //$NON-NLS-1$
+		case VariableType.BOOLEAN:
+			return new DebuggerValue("boolean"); //$NON-NLS-1$
+		case VariableType.NUMBER:
+			return new DebuggerValue("number"); //$NON-NLS-1$
+		case VariableType.STRING:
+			return new DebuggerValue("string"); //$NON-NLS-1$
+		case VariableType.OBJECT: {
+			String typeName = value.getTypeName();
+			int at = typeName.indexOf('@');
+			if (at != -1)
+				typeName = typeName.substring(0, at);
+			if (typeName.equals("XML") || typeName.equals("XMLList")) //$NON-NLS-1$ //$NON-NLS-2$
+				return new DebuggerValue("xml"); //$NON-NLS-1$
+		}
+		default:
+			return new DebuggerValue("object"); //$NON-NLS-1$
+		}
+	}
+
+	public Object reduce_typeof_name(IASNode iNode, Object object) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_typeof_name");
+		Object exprObject = transform_name_to_expression(iNode, object);
+		return reduce_typeof_expr(iNode, exprObject);
+	}
+
+	public Object reduce_typeNameParameterAsType(IASNode iNode,
+			Object type_param) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_typeNameParameterAsType");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_vectorLiteral(IASNode iNode, Object type_param,
+			Vector<Object> elements) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_vectorLiteral");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_voidExpr_to_type_name(IASNode node) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_voidExpr_to_type_name");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_void0Literal_to_constant_value(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_void0Literal_to_constant_value");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_void0Literal_to_object_literal(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_void0Literal_to_object_literal");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_void0Operator(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_void0Operator");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_voidOperator_to_constant_value(IASNode iNode,
+			Object constant_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_voidOperator_to_constant_value");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object reduce_voidOperator_to_expression(IASNode iNode, Object expr) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_voidOperator_to_expression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	/**
+	 * The enumeration of states that the code generator finds interesting in an
+	 * XML literal. There are states here than the reducer, below, doesn't
+	 * consider especially interesting; see computeXMLContentStateMatrix() for
+	 * their usage.
+	 */
+	@SuppressWarnings("unused")
+	private enum XMLContentState {
+	};
+
+	public Object reduce_XMLContent(IASNode iNode, Vector<Object> exprs) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_XMLContent");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_XMLList(IASNode iNode, Vector<Object> exprs) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_XMLList");
+		Object result = null;
+		return result;
+	}
+
+	public Object reduce_XMLListConst(IASNode iNode, Vector<String> elements) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduce_XMLListConst");
+		Object result = null;
+		return result;
+	}
+
+	/*
+	 * ******************************
+	 * ** Transformation routines ** ******************************
+	 */
+
+	public Object transform_boolean_constant(IASNode iNode,
+			Boolean boolean_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_boolean_constant");
+		Object result = new DebuggerValue(boolean_constant);
+		return result;
+	}
+
+	public Object transform_double_constant(IASNode iNode,
+			Double double_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_double_constant");
+		Object result = new DebuggerValue(double_constant);
+		return result;
+	}
+
+	public Object transform_numeric_constant(IASNode iNode,
+			Number numeric_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_numeric_constant");
+		Object result = new DebuggerValue(numeric_constant);
+		;
+		return result;
+	}
+
+	/**
+	 * Transform any constant_value into an expression, so we can constant fold
+	 * all sorts of expressions.
+	 * 
+	 * @param iNode
+	 *            the node that generated the constant_value
+	 * @param constant_value
+	 *            the constant value
+	 * @return an Object that contains instructions to push the constant_value
+	 *         onto the stack.
+	 */
+	public Object transform_constant_value(IASNode iNode, Object constant_value) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_constant_value");
+		return constant_value;
+	}
+
+	public Object transform_float_constant(IASNode iNode, Float float_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_float_constant");
+		Object result = new DebuggerValue(float_constant);
+		return result;
+	}
+
+	/**
+	 * transform a string_constant to a constant_value - essentially a no-op,
+	 * but need a reduction so we can assign it a cost
+	 */
+	public Object transform_string_constant_to_constant(IASNode iNode,
+			String string_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_string_constant_to_constant");
+		return string_constant;
+	}
+
+	/**
+	 * transform a boolean_constant to a constant_value - essentially a no-op,
+	 * but need a reduction so we can assign it a cost
+	 */
+	public Object transform_boolean_constant_to_constant(IASNode iNode,
+			Boolean boolean_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_boolean_constant_to_constant");
+		return boolean_constant;
+	}
+
+	/**
+	 * transform a numeric_constant to a constant_value - essentially a no-op,
+	 * but need a reduction so we can assign it a cost
+	 */
+	public Object transform_numeric_constant_to_constant(IASNode iNode,
+			Number numeric_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_numeric_constant_to_constant");
+		if (numeric_constant instanceof Float) {
+			return new DebuggerValue(new Double((Float) numeric_constant));
+		} else {
+			return new DebuggerValue(new Double((Double) numeric_constant));
+		}
+
+	}
+
+	public Object transform_expression_to_constant_value(IASNode iNode,
+			Object expression) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_expression_to_constant_value");
+		// return null - something higher up will report any appropriate
+		// diagnostics.
+		return null;
+	}
+
+	public Object transform_integer_constant(IASNode iNode,
+			Integer integer_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_integer_constant");
+		DebuggerValue result = new DebuggerValue(new Double(integer_constant));
+		return result;
+	}
+
+	public Object transform_name_to_constant_value(IASNode iNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_name_to_constant_value");
+		Object result = null;
+		return result;
+	}
+
+	/**
+	 * Transform a name into an expression. In the Code generator this generates
+	 * code to get the name and put it on the stack, but for the debugger we
+	 * probably just want to return the name.
+	 */
+	public Object transform_name_to_expression(IASNode iNode, Object name) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_name_to_expression");
+
+		// ASC REFER : public Value evaluate(macromedia.asc.util.Context cx,
+		// GetExpressionNode node)
+		DebuggerValue identifier = (DebuggerValue) name;
+		Context eeContext = contextStack.scope();
+		String nameStr = ECMA.toString(eeContext.getSession(),
+				eeContext.toValue(identifier.debuggerValue));
+		flash.tools.debugger.Value contextValue = eeContext.toValue();
+		/**
+		 * When contextValue is XMLList and a child node has been accessed, the
+		 * context used to resolve variables within [] operator will be a
+		 * FlashValueContext while rhs.debuggerValue will be a
+		 * FlexLocalVariable. The fix for FB-25660 makes sure
+		 * FlashValueContext.toValue(o) checks this case and returns
+		 * getFlashVariable().getValue(). We still need to check if this Value
+		 * is of type Number so that the if check below behaves correctly.
+		 */
+		if (contextValue != null && isXMLType(contextValue)
+				&& !isNumericIndex(iNode, identifier.debuggerValue, eeContext)) {
+			String function;
+			Object arg;
+
+			if (nameStr.length() > 0 && nameStr.charAt(0) == '@') {
+				// expression is node.@attr, so we call node.attribute("attr")
+				function = "attribute"; //$NON-NLS-1$
+				arg = nameStr.substring(1);
+			} else {
+				arg = identifier.debuggerValue;
+				boolean isDecendentsOpr = (iNode.getNodeID() == ASTNodeID.Op_DescendantsID);
+				if (isDecendentsOpr) {// node.getMode() ==
+										// Tokens.DOUBLEDOT_TOKEN) {
+					// expression is node..tag, so we call
+					// node.descendants("tag")
+					function = "descendants"; //$NON-NLS-1$
+				} else {
+					// expression is node.tag, so we call node.child("tag")
+					function = "child"; //$NON-NLS-1$
+				}
+			}
+
+			try {
+				return new DebuggerValue(callFunction(eeContext, false,
+						function, new Object[] { arg }));
+			} catch (PlayerDebugException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+		} else if (contextValue != null
+				&& contextValue.getType() == VariableType.STRING
+				&& ((DebuggerValue) name).debuggerValue.equals("length")) //$NON-NLS-1$
+		{
+			String valuestr = contextValue.getValueAsString();
+			return new DebuggerValue(new Double(valuestr.length()));
+		} else {
+			Object lookupResult;
+			try {
+				lookupResult = eeContext.lookup(ECMA.toString(
+						eeContext.getSession(),
+						eeContext.toValue(identifier.debuggerValue)));
+			} catch (NoSuchVariableException e) {
+				throw new ExpressionEvaluatorException(e);
+			} catch (PlayerFaultException e) {
+				throw new ExpressionEvaluatorException(e);
+			}
+			return new DebuggerValue(lookupResult);
+		}
+	}
+
+	public Object transform_non_resolving_identifier(IASNode iNode,
+			String non_resolving_identifier) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_non_resolving_identifier");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object transform_runtime_name_expression(IASNode iNode,
+			Object runtime_name_expression) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_runtime_name_expression");
+		throw new ExpressionEvaluatorException(ASTBuilder
+				.getLocalizationManager().getLocalizedTextString(
+						"unsupportedExpression")); //$NON-NLS-1$
+	}
+
+	public Object transform_string_constant(IASNode iNode,
+			String string_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_string_constant");
+		return new DebuggerValue(string_constant);
+	}
+
+	public Object transform_uint_constant(IASNode iNode, Long uint_constant) {
+		if (hookallreducercalls)
+			hookforreducercalls("transform_uint_constant");
+		Object result = new DebuggerValue(uint_constant);
+		return result;
+	}
+
+	/**
+	 * Generate a unary operator.
+	 * 
+	 * @param operand
+	 *            - the operand expression.
+	 * @param opcode
+	 *            - the operator's opcode.
+	 * @return an Object that applies the operator to the operand.
+	 */
+	Object unaryOp(IASNode iNode, Object operand, int opcode) {
+		// REFER ASC public Value evaluate(macromedia.asc.util.Context cx,
+		// UnaryExpressionNode node)
+		if (hookallreducercalls)
+			hookforreducercalls("unaryOp");
+		DebuggerValue arg = (DebuggerValue) operand;
+		Context eeContext = contextStack.scope();
+		switch (opcode) {
+		case ABCConstants.OP_returnvoid:
+			// ECMA 11.4.2
+			eeContext.toValue(arg.debuggerValue);
+			return new DebuggerValue(flash.tools.debugger.Value.UNDEFINED);
+		case ABCConstants.OP_typeof: {
+			return reduce_typeof_expr(iNode, operand);
+		}
+		case ABCConstants.OP_convert_d:
+		case ABCConstants.OP_unplus: {
+			// ECMA 11.4.6
+			return new DebuggerValue(new Double(ECMA.toNumber(
+					eeContext.getSession(),
+					eeContext.toValue(arg.debuggerValue))));
+		}
+		case ABCConstants.OP_negate: {
+			// ECMA 11.4.7
+			return new DebuggerValue(new Double(-ECMA.toNumber(
+					eeContext.getSession(),
+					eeContext.toValue(arg.debuggerValue))));
+		}
+		case ABCConstants.OP_bitnot: {
+			// ECMA 11.4.8
+			return new DebuggerValue(new Double(~ECMA.toInt32(
+					eeContext.getSession(),
+					eeContext.toValue(arg.debuggerValue))));
+		}
+		case ABCConstants.OP_not: {
+			// ECMA 11.4.9
+			return new DebuggerValue(new Boolean(!ECMA.toBoolean(eeContext
+					.toValue(arg.debuggerValue))));
+		}
+		default:
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	Object errorPackageName(IASNode iNode, String qualifiers, String base_name) {
+		if (hookallreducercalls)
+			hookforreducercalls("errorPackageName");
+		return null;
+	}
+
+	// myxml[3] or myxml["3"] is handled differently from myxml["childtag"].
+	// This function takes the part in the brackets, and returns true if it
+	// is a number or a string that can be converted to a number.
+	private boolean isNumericIndex(IASNode node, Object index, Context context) {
+		if (hookallreducercalls)
+			hookforreducercalls("isNumericIndex");
+		// if (node.getMode() != Tokens.LEFTBRACKET_TOKEN)
+		if (node.getNodeID() != ASTNodeID.ArrayIndexExpressionID)
+			return false; // it is node.member or node..member or whatever, but
+							// not node[member]
+
+		if (index instanceof Double) {
+			return true; // it is node[number]
+		} else if (index instanceof String) {
+			String s = (String) index;
+
+			if (s.length() == 0) {
+				return false;
+			} else {
+				try {
+					Double.parseDouble(s);
+					return true; // it is node["number"]
+				} catch (NumberFormatException e) {
+					return false;
+				}
+			}
+		} else if (context != null && index != null) {
+			// Resolve the Value to see if it is a Number
+			flash.tools.debugger.Value value = context.toValue(index);
+			if (value != null && value.getType() == VariableType.NUMBER) {
+				return true;
+			}
+			return false;
+		} else {
+			return false;
+		}
+	}
+
+	private boolean isXMLType(flash.tools.debugger.Value value) {
+		if (hookallreducercalls)
+			hookforreducercalls("isXMLType");
+		String typename = value.getTypeName();
+		int at = typename.indexOf('@');
+		if (at != -1)
+			typename = typename.substring(0, at);
+		return typename.equals("XML") || typename.equals("XMLList"); //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+	private String keywordNotAllowed(String keyword) {
+		if (hookallreducercalls)
+			hookforreducercalls("keywordNotAllowed");
+		Map<String, String> parameters = new HashMap<String, String>();
+		parameters.put("keyword", keyword); //$NON-NLS-1$
+		return ASTBuilder.getLocalizationManager().getLocalizedTextString(
+				"keywordNotAllowed", parameters); //$NON-NLS-1$
+	}
+
+	/**
+	 * @param expressionNode
+	 * @param expression
+	 * @return
+	 */
+	public Object reduceLazyExpression(final IASNode expressionNode) {
+		if (hookallreducercalls)
+			hookforreducercalls("reduceLazyExpression");
+
+		UnEvaluatedDebugExpression delayedEvaluator = new UnEvaluatedDebugExpression() {
+
+			@Override
+			public DebuggerValue evaluate(Context eeContext) {
+				try {
+					IExpressionEvaluator evalutor = new DebuggerExpressionEvaluator(
+							project);
+
+					return evalutor.evaluate(eeContext, expressionNode);
+				} catch (Exception e) {
+					throw new ExpressionEvaluatorException(e);
+				}
+			}
+		};
+
+		return delayedEvaluator;
+	}
+
+	private static abstract class UnEvaluatedDebugExpression {
+
+		public abstract DebuggerValue evaluate(Context eeContext);
+	}
+
+}


Mime
View raw message