/*
*
* 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 org.apache.flex.compiler.internal.as.codegen;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Vector;
import java.util.Stack;
import static org.apache.flex.abc.ABCConstants.*;
import org.apache.flex.abc.ABCConstants;
import org.apache.flex.abc.instructionlist.InstructionList;
import org.apache.flex.abc.semantics.ECMASupport;
import org.apache.flex.abc.semantics.Instruction;
import org.apache.flex.abc.semantics.InstructionFactory;
import org.apache.flex.abc.semantics.Label;
import org.apache.flex.abc.semantics.MethodInfo;
import org.apache.flex.abc.semantics.Name;
import org.apache.flex.abc.semantics.Namespace;
import org.apache.flex.abc.semantics.NoOperandsInstruction;
import org.apache.flex.abc.semantics.Nsset;
import org.apache.flex.abc.semantics.PooledValue;
import org.apache.flex.compiler.constants.IASLanguageConstants;
import org.apache.flex.compiler.constants.IASLanguageConstants.BuiltinType;
import org.apache.flex.compiler.definitions.IAccessorDefinition;
import org.apache.flex.compiler.definitions.IConstantDefinition;
import org.apache.flex.compiler.definitions.IDefinition;
import org.apache.flex.compiler.definitions.ITypeDefinition;
import org.apache.flex.compiler.definitions.IVariableDefinition;
import org.apache.flex.compiler.exceptions.CodegenInterruptedException;
import org.apache.flex.compiler.exceptions.DuplicateLabelException;
import org.apache.flex.compiler.exceptions.UnknownControlFlowTargetException;
import org.apache.flex.compiler.internal.semantics.SemanticUtils;
import org.apache.flex.compiler.internal.tree.as.BaseVariableNode;
import org.apache.flex.compiler.internal.tree.as.VariableExpressionNode;
import org.apache.flex.compiler.problems.AmbiguousGotoTargetProblem;
import org.apache.flex.compiler.problems.AnyNamespaceCannotBeQualifierProblem;
import org.apache.flex.compiler.problems.CodegenInternalProblem;
import org.apache.flex.compiler.problems.DuplicateLabelProblem;
import org.apache.flex.compiler.problems.DuplicateNamespaceDefinitionProblem;
import org.apache.flex.compiler.problems.ICompilerProblem;
import org.apache.flex.compiler.problems.InvalidLvalueProblem;
import org.apache.flex.compiler.problems.InvalidNamespaceInitializerProblem;
import org.apache.flex.compiler.problems.MultipleSwitchDefaultsProblem;
import org.apache.flex.compiler.problems.NonConstantParamInitializerProblem;
import org.apache.flex.compiler.problems.PackageCannotBeUsedAsValueProblem;
import org.apache.flex.compiler.problems.UnexpectedReturnProblem;
import org.apache.flex.compiler.problems.UnknownGotoTargetProblem;
import org.apache.flex.compiler.problems.UnknownNamespaceProblem;
import org.apache.flex.compiler.problems.UnknownBreakTargetProblem;
import org.apache.flex.compiler.problems.UnknownContinueTargetProblem;
import org.apache.flex.compiler.problems.VoidTypeProblem;
import org.apache.flex.compiler.projects.ICompilerProject;
import org.apache.flex.compiler.tree.as.IASNode;
import org.apache.flex.compiler.tree.as.IDynamicAccessNode;
import org.apache.flex.compiler.tree.as.IBinaryOperatorNode;
import org.apache.flex.compiler.tree.as.ICatchNode;
import org.apache.flex.compiler.tree.as.IContainerNode;
import org.apache.flex.compiler.tree.as.IExpressionNode;
import org.apache.flex.compiler.tree.as.IForLoopNode;
import org.apache.flex.compiler.tree.as.IFunctionCallNode;
import org.apache.flex.compiler.tree.as.IFunctionNode;
import org.apache.flex.compiler.tree.as.IIdentifierNode;
import org.apache.flex.compiler.tree.as.IImportNode;
import org.apache.flex.compiler.tree.as.ILanguageIdentifierNode;
import org.apache.flex.compiler.tree.as.IParameterNode;
import org.apache.flex.compiler.tree.as.IScopedNode;
import org.apache.flex.compiler.tree.as.ITryNode;
import org.apache.flex.compiler.tree.as.ITypedExpressionNode;
import org.apache.flex.compiler.tree.as.IUnaryOperatorNode;
import org.apache.flex.compiler.tree.as.IWhileLoopNode;
import org.apache.flex.compiler.tree.as.IWithNode;
import org.apache.flex.compiler.tree.as.ILanguageIdentifierNode.LanguageIdentifierKind;
import org.apache.flex.compiler.tree.as.IOperatorNode.OperatorType;
import org.apache.flex.compiler.tree.mxml.IMXMLEventSpecifierNode;
import org.apache.flex.compiler.internal.as.codegen.LexicalScope.NestingState;
import org.apache.flex.compiler.internal.definitions.AccessorDefinition;
import org.apache.flex.compiler.internal.definitions.ClassDefinition;
import org.apache.flex.compiler.internal.definitions.DefinitionBase;
import org.apache.flex.compiler.internal.definitions.FunctionDefinition;
import org.apache.flex.compiler.internal.definitions.GetterDefinition;
import org.apache.flex.compiler.internal.definitions.NamespaceDefinition;
import org.apache.flex.compiler.internal.definitions.SetterDefinition;
import org.apache.flex.compiler.internal.definitions.TypeDefinitionBase;
import org.apache.flex.compiler.internal.tree.as.BaseDefinitionNode;
import org.apache.flex.compiler.internal.tree.as.BinaryOperatorInNode;
import org.apache.flex.compiler.internal.tree.as.DynamicAccessNode;
import org.apache.flex.compiler.internal.tree.as.EmbedNode;
import org.apache.flex.compiler.internal.tree.as.ExpressionNodeBase;
import org.apache.flex.compiler.internal.tree.as.ForLoopNode;
import org.apache.flex.compiler.internal.tree.as.FunctionNode;
import org.apache.flex.compiler.internal.tree.as.FunctionObjectNode;
import org.apache.flex.compiler.internal.tree.as.IdentifierNode;
import org.apache.flex.compiler.internal.tree.as.LabeledStatementNode;
import org.apache.flex.compiler.internal.tree.as.MemberAccessExpressionNode;
import org.apache.flex.compiler.internal.tree.as.NamespaceNode;
import org.apache.flex.compiler.internal.tree.as.RegExpLiteralNode;
import org.apache.flex.compiler.internal.tree.as.SwitchNode;
import org.apache.flex.compiler.internal.tree.as.TernaryOperatorNode;
import org.apache.flex.compiler.internal.tree.as.VariableNode;
/*
* Notes on changing the reducer:
*
* - Do not add OP_finddefinition, OP_finddefstrict or OP_getlex instructions directly. Instead use
* LexicalScope.findProperty() and LexicalScope.getPropertyValue(), as these methods will
* ensure the correct instructions are added when inlining a function body where the scope
* chain can not be depended on.
*/
public class ABCGeneratingReducer
{
/**
* A struct for the decoded pieces of a catch block.
*/
public static class CatchPrototype
{
Name catchType;
Name catchVarName;
InstructionList catchBody;
}
/**
* ConditionalFragment holds the disparate elements of a conditional statement fragment.
*/
public class ConditionalFragment
{
IASNode site;
/**
* condition is non-null when the conditional expression is not a constant.
* condition is null if an unconditional fragement, or if the fragement is
* a constant, in which case constantCondition is non-null.
*/
InstructionList condition;
/**
* constantCondition is non-null when the conditional expression is a constant.
* constantCondition is null if an unconditional fragement, or if the fragement is
* a non-constant, in which case condition is non-null.
*/
Object constantCondition;
InstructionList statement;
private Label statementLabel = null;
/**
* Construct a ConditionalFragment with a single statement.
*/
ConditionalFragment( IASNode site, InstructionList condition, InstructionList statement)
{
this.site = site;
this.condition = condition;
this.constantCondition = null;
this.statement = statement;
}
/**
* Construct a ConditionalFragment with a list of statements,
* coalescing them into a composite statement.
*/
ConditionalFragment( IASNode site, InstructionList condition, Vector<InstructionList> statements)
{
this(site, condition, null, statements);
}
/**
* Construct a constant conditional ConditionalFragment with a list of
* statements, coalescing them into a composite statement.
*/
ConditionalFragment(IASNode site, Object constantConditional, Vector<InstructionList> statements)
{
this(site, null, constantConditional, statements);
}
/**
* Private constructor called by public constructors
* @param site
* @param condition
* @param constantCondition
* @param statements
*/
private ConditionalFragment(IASNode site, InstructionList condition, Object constantCondition, Vector<InstructionList> statements)
{
assert (condition == null || constantCondition == null) : "condition and constantCondition can't both be non-null";
this.site = site;
this.condition = condition;
this.constantCondition = constantCondition;
this.statement = createInstructionList(site);
for (InstructionList stmt : statements)
{
this.statement.addAll(stmt);
}
}
/**
* @return the label of the fragment's condition, or
* its statement label if it's the default alternative.
*/
Label getLabel()
{
if ( !this.isUnconditionalAlternative() )
{
if ( this.condition != null )
return this.condition.getLabel();
else
return getStatementLabel();
}
else
{
return getStatementLabel();
}
}
/**
* Cache and return the label of this conditional fragment's
* statement so it can be retrieved after the statement's been
* added to the overall conditional statement and this.statement
* is invalidated.
*/
Label getStatementLabel()
{
if ( null == this.statementLabel )
this.statementLabel = this.statement.getLabel();
return this.statementLabel;
}
/**
* @return true if this is an unconditional alternative,
* i.e. a default case or the last else in an if/else if/else.
*/
boolean isUnconditionalAlternative()
{
return (null == this.condition) && (null == this.constantCondition);
}
void convertConstantConditionToInstruction()
{
if ((constantCondition == null && condition != null) || condition == null)
return;
condition = transform_constant_value(site, constantCondition);
constantCondition = null;
}
/**
* @return true if this is a constant conditonal fragement i.e. case 7:
*/
boolean isConstantConditional()
{
return this.constantCondition != null;
}
}
/**
* The RuntimeMultiname class holds the components of
* the various types of runtime multiname, and puts them
* together in the right order to generate the names and
* instruction sequences to jamble up the AVM.
*
* Only some permutations of the compile-time/runtime
* qualifier::name possibilities are valid:
* Name::expression generates MultinameL
* expression::expression generates RTQnameL
* expression::name generates RTQname
* (name::name is a plain Multiname)
*/
class RuntimeMultiname
{
/**
* The compile-time qualifier of a MultinameL.
* compileTimeName isn't valid (this would
* be a compile-time constant Multiname).
*/
Name compileTimeQualifier;
/**
* The runtime qualifier of a RTQname or RTQNameL.
* Compile-time and runtime names are valid.
*/
InstructionList runtimeQualifier;
/**
* The compile-time constant name of a RTQName.
* compileTimeQualifier isn't valid (this would
* be a compile-time constant Multiname).
*/
Name compileTimeName;
/**
* The runtime name of a MultinameL or RTQnameL.
*/
InstructionList runtimeName;
/**
* Construct a RTQnameL-type runtime name.
* @param qualifier - the runtime qualifier.
* @param name - the runtime name.
*/
RuntimeMultiname(InstructionList qualifier, InstructionList runtime_name)
{
this.runtimeQualifier = qualifier;
this.runtimeName = runtime_name;
}
/**
* Construct a RTQname-type runtime name.
* @param qualifier - the runtime qualifier.
* @param name - the compile-time name.
*/
RuntimeMultiname(InstructionList qualifier, Name name)
{
this.runtimeQualifier = qualifier;
this.compileTimeName = name;
}
/**
* Construct a MultinameL-type runtime name.
* @param qualifier - the Multiname. Note this
* is the only kind of runtime name that receives
* a qualifying name.
* @param nameL - the runtime expression that
* yields the base name.
*/
RuntimeMultiname(Name qualifier, InstructionList nameL)
{
assert(qualifier.getKind() == CONSTANT_MultinameL || qualifier.getKind() == CONSTANT_MultinameLA): "Bad qualifier kind " + qualifier.getKind() + " on name " + qualifier.toString();
this.compileTimeQualifier = qualifier;
this.runtimeName = nameL;
}
/**
* Assemble the ingredients into an expression.
* @param opcode - one of OP_getproperty or OP_setproperty.
* @param rhs - the value of a setproperty call. Passed to
* this routine because there may be name-specific
* instructions before and after the value.
*/
InstructionList generateGetOrSet(IASNode iNode, int opcode, InstructionList rhs)
{
InstructionList result = createInstructionList(iNode);
// Note: numerous microoptimization opportunities here
// to avoid storing values in temps by creative use of
// OP_dup and OP_swap, especially in getproperty gen.
if ( this.compileTimeQualifier != null && this.runtimeName != null )
{
// Generate MultinameL type code.
Binding name_temp = currentScope.allocateTemp();
result.addAll(this.runtimeName);
result.addInstruction(OP_dup);
result.addInstruction(name_temp.setlocal());
// findprop(MultinameL) consumes a name from the value stack.
result.addInstruction(OP_findpropstrict, this.compileTimeQualifier);
result.addInstruction(name_temp.getlocal());
if ( rhs != null )
result.addAll(rhs);
// get/setprop(MultinameL) consumes a name from the value stack.
result.addInstruction(opcode, this.compileTimeQualifier);
}
else if ( this.runtimeQualifier != null && this.runtimeName != null )
{
// Generate RTQnameL type code.
Binding name_temp = currentScope.allocateTemp();
Binding qual_temp = currentScope.allocateTemp();
Name rtqnl = new Name(CONSTANT_RTQnameL, null, null);
result.addAll(getRuntimeName(iNode));
result.addInstruction(name_temp.setlocal());
result.addAll(getRuntimeQualifier(iNode));
result.addInstruction(OP_dup);
result.addInstruction(qual_temp.setlocal());
result.addInstruction(name_temp.getlocal());
// findprop(RTQNameL) consumes namespace and name from the value stack.
result.addInstruction(OP_findpropstrict, rtqnl);
result.addInstruction(qual_temp.getlocal());
result.addInstruction(name_temp.getlocal());
if ( rhs != null )
result.addAll(rhs);
// get/setprop(RTQNameL) consumes namespace and name from the value stack.
result.addInstruction(opcode, rtqnl);
currentScope.releaseTemp(name_temp);
currentScope.releaseTemp(qual_temp);
}
else
{
// Last valid combination generates a RTQname.
assert(this.runtimeQualifier != null && this.compileTimeName != null) : "Unknown runtime name configuration: " + this.toString();
Name rtqn = new Name(CONSTANT_RTQname, null, this.compileTimeName.getBaseName());
result.addAll(getRuntimeQualifier(iNode));
result.addInstruction(OP_dup);
// findprop(RTQName) consumes a namespace from the value stack.
result.addInstruction(OP_findpropstrict, rtqn);
result.addInstruction(OP_swap);
if ( rhs != null )
result.addAll(rhs);
// get/setprop(RTQName) consumes a namespace from the value stack.
result.addInstruction(opcode, rtqn);
}
return result;
}
/**
* Generate the InstructionList that expresses this RuntimeName's qualifier.
* @param iNode - an IASNode to contribute debug info to the result InstructionList.
* @return the runtime qualifier setup instructions.
*/
public InstructionList getRuntimeQualifier(IASNode iNode)
{
assert(hasRuntimeQualifier());
InstructionList result = createInstructionList(iNode);
result.addAll(replicate(this.runtimeQualifier));
// Ensure the last instruction is an OP_coerce to Namespace.
Instruction last = result.lastElement();
if (
last.getOpcode() != OP_coerce ||
last.getOperandCount() == 0 ||
! namespaceType.equals(last.getOperand(0))
)
{
result.addInstruction(OP_coerce, namespaceType);
}
return result;
}
/**
* @return true if this RuntimeName has a runtime qualifier.
*/
public boolean hasRuntimeQualifier()
{
return this.runtimeQualifier != null;
}
/**
* @return true if this RuntimeName has a runtime name.
*/
public boolean hasRuntimeName()
{
return this.runtimeName != null;
}
/**
* Generate the InstructionList that expresses this RuntimeName's name.
* @param iNode - an IASNode to contribute debug info to the result InstructionList.
* @return the runtime name setup instructions.
*/
public InstructionList getRuntimeName(IASNode iNode)
{
assert(hasRuntimeName());
InstructionList result = createInstructionList(iNode);
result.addAll(replicate(this.runtimeName));
if ( result.lastElement().getOpcode() != OP_coerce_s)
result.addInstruction(OP_coerce_s);
return result;
}
/**
* Generate the runtime name appropriate to this qualifier/name combination.
* @return the runtime name appropriate to this qualifier/name combination.
*/
public Name generateName()
{
Name result;
if ( this.compileTimeQualifier != null )
{
result = this.compileTimeQualifier;
}
else if ( this.runtimeQualifier != null && this.runtimeName != null )
{
result = new Name(CONSTANT_RTQnameL, null, null);
}
else
{
// Last valid combination generates a RTQname.
assert(this.runtimeQualifier != null && this.compileTimeName != null) : "Unknown runtime name configuration: " + this.toString();
result = new Name(CONSTANT_RTQname, null, this.compileTimeName.getBaseName());
}
return result;
}
/**
* Convenience method generates an assignment
* @param value - the value to set.
* @return the instruction sequence to set a
* the given multiname's value.
*/
InstructionList generateAssignment(IASNode iNode, InstructionList value)
{
return generateGetOrSet(iNode, getAssignmentOpcode(iNode), value);
}
/**
* Deduce the correct assignment opcode for a property.
* @param iNode - the root of the reference to the property.
* @return OP_initproperty if the property is const, OP_setproperty if not.
*/
int getAssignmentOpcode(IASNode iNode)
{
if ( SemanticUtils.isConst(iNode, currentScope.getProject()) && ABCGeneratingReducer.this.inInitializingContext(iNode) )
return OP_initproperty;
else
return OP_setproperty;
}
/**
* Convenience method generates an r-value.
* @return the instruction sequence to look up
* the given multiname.
*/
InstructionList generateRvalue(IASNode iNode)
{
return generateGetOrSet(iNode, OP_getproperty, null);
}
/**
* Diagnostic toString() method,
* used primarily to debug the assertion in generate().
*/
@Override
public String toString()
{
return "\n\t" + compileTimeQualifier + ",\n\t" + runtimeQualifier + ",\n\t" + compileTimeName + ",\n\t" + runtimeName;
}
}
/**
* ForKeyValueLoopState holds the state of a for/in or for each/in loop:
* the Hasnext2Wrapper that tracks the state of the locals required to
* support the hasnext2 instruction, and the Labels that mark the top
* of the loop and the test.
*/
private class ForKeyValueLoopState
{
/**
* Label for the loop-test logic.
*/
Label test = new Label();
/**
* Label for the top of the loop body.
*/
Label loop = new Label();
/**
* Hasnext2 management structure.
*/
LexicalScope.Hasnext2Wrapper hasnext = currentScope.hasnext2();
/**
* Generate the loop prologue code.
* @return loop prologue code.
*/
InstructionList generatePrologue(IASNode iNode, InstructionList base)
{
InstructionList result = createInstructionList(iNode);
// Set up the object and index registers.
result.addInstruction(OP_pushbyte, 0);
result.addInstruction(hasnext.index_temp.setlocal());
result.addAll(base);
result.addInstruction(hasnext.stem_temp.setlocal());
// Go to the loop test.
result.addInstruction(OP_jump, test);
// Top of loop processing.
result.addInstruction(OP_label);
result.labelCurrent(loop);
return result;
}
/**
* Generate the instruction sequence that
* fetches the next key or value.
* @return the instruction sequence that
* fetches the next key or value.
*/
InstructionList generateKeyOrValue(int opcode)
{
InstructionList result = new InstructionList();
result.addInstruction(hasnext.stem_temp.getlocal());
result.addInstruction(hasnext.index_temp.getlocal());
result.addInstruction(opcode);
return result;
}
/**
* Generate the loop epilogue code.
* @return loop epilogue code.
*/
InstructionList generateEpilogue()
{
InstructionList result = new InstructionList();
result.addInstruction(hasnext.instruction);
result.labelCurrent(test);
currentScope.getFlowManager().resolveContinueLabel(result);
result.addInstruction(OP_iftrue, loop);
hasnext.release();
return result;
}
}
/**
* The current LexicalScope. Set by the caller,
* changes during reduction when a scoped construct
* such as an embedded function or a with statement
* is encountered.
*/
private LexicalScope currentScope;
/**
* Instructions sent by the caller to be added to
* a function definition. Usually these are field
* initialization expressions in a constructor.
*/
private InstructionList instanceInitializers;
/**
* "Mini scope" regions, i.e., blocks of the method body.
*/
Stack<InstructionList> miniScopes = new Stack<InstructionList>();
/**
* A shared name for the Namespace type.
*/
public static final Name namespaceType = new Name("Namespace");
/**
* A shared name for the XML type.
*/
public static final Name xmlType = new Name("XML");
/**
* A shared name for the XMLList type.
*/
public static final Name xmlListType = new Name("XMLList");
/**
* A shared name for the RegExp type.
*/
public static final Name regexType = new Name("RegExp");
/**
* A shared name for the void type.
*/
public static final Name voidType = new Name("void");
/**
* Generate code to push a numeric constant.
*/
public static void pushNumericConstant(long value, InstructionList result_list)
{
result_list.pushNumericConstant(value);
}
/**
* Generate code to push a numeric value onto the stack. This will take into account the type
* of the expression that generated the number - e.g. a numeric value produced from a const of type 'int'
* will produce at worst a pushint instruction
*
* Used by the constant folding routines so we don't lose type info when all we have is a Number.
*
* @param result_list IL to add the instruction.
* @param value the numeric value to push
* @param type the type of the expression that produced the value.
*/
public void pushNumericConstant(InstructionList result_list, Number value, IDefinition type)
{
ICompilerProject project = currentScope.getProject();
if( type == project.getBuiltinType(BuiltinType.INT) )
{
int val = ECMASupport.toInt32(value);
if( (byte)val == val )
{
result_list.addInstruction(OP_pushbyte, val);
}
else if( (short)val == val )
{
result_list.addInstruction(OP_pushshort, val);
}
else
{
result_list.addInstruction(OP_pushint, Integer.valueOf(val));
}
}
else if( type == project.getBuiltinType(BuiltinType.UINT) )
{
long uval = ECMASupport.toUInt32(value.doubleValue());
if ((uval & 0x7F) == uval) { // Pushbyte sign extends
result_list.addInstruction(OP_pushbyte, (int)uval);
}
else if ((uval & 0x7FFF) == uval) { // Pushshort sign extends
result_list.addInstruction(OP_pushshort, (int)uval);
}
else {
result_list.addInstruction(OP_pushuint, Long.valueOf(uval));
}
}
else
{
double dval = value.doubleValue();
if( ECMASupport.isNan(dval) )
{
result_list.addInstruction(OP_pushnan);
}
else if (!Double.isInfinite(dval) && (dval == ECMASupport.toInt32(value)) )
{
// distinguish pos/neg 0
// java treats -0 and 0 as equal, but divide by -0 results in NEG INFINITY, whereas pos
// 0 results in POS INFINITY
// positive 0 can be encoded with a pushbyte, but neg zero requires a pushdouble
if( dval == 0 && 1/dval == Double.NEGATIVE_INFINITY )
result_list.addInstruction(OP_pushdouble, dval);
else
// Integer
pushNumericConstant(result_list, ECMASupport.toInt32(value), project.getBuiltinType(BuiltinType.INT));
}
else if( Double.isNaN(dval) )
{
result_list.addInstruction(OP_pushnan);
}
else
{
result_list.addInstruction(OP_pushdouble, value.doubleValue());
}
}
}
/**
* @return the currently active collection of problems.
*/
public Collection<ICompilerProblem> getProblems()
{
return currentScope.getProblems();
}
/**
* 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.
*/
InstructionList binaryOp(IASNode iNode, InstructionList l, InstructionList r, int opcode)
{
checkBinaryOp(iNode, opcode);
return binaryOperatorBody(iNode, l, r, InstructionFactory.getInstruction(opcode));
}
/**
* Generate a conditional jump 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.
* The target is filled in by a downstream reduction.
*/
InstructionList conditionalJump(IASNode iNode, InstructionList l, InstructionList r, int opcode)
{
checkBinaryOp(iNode, opcode);
return binaryOperatorBody(iNode, l, r, InstructionFactory.getTargetableInstruction(opcode));
}
/**
* Generate a binary operator.
* @param l - the left-hand operand.
* @param r - the right-hand operand.
* @param operator - the operator, as an Instruction.
* @return the combined instruction sequence with the operator appended.
*/
InstructionList binaryOperatorBody(IASNode iNode, InstructionList l, InstructionList r, Instruction operator)
{
InstructionList result = createInstructionList(iNode, l.size() + r.size() + 1);
result.addAll(l);
result.addAll(r);
result.addInstruction(operator);
return result;
}
/**
* Perform semantic checks on a binary operator.
*/
public void checkBinaryOp (IASNode iNode, int opcode)
{
currentScope.getMethodBodySemanticChecker().checkBinaryOperator(iNode, opcode);
}
/**
* Resolve a dotted name, e.g., foo.bar.baz
*/
Binding dottedName(IASNode iNode, String qualifiers, String base_name)
{
if ( iNode instanceof IdentifierNode )
{
return currentScope.resolveName((IdentifierNode)iNode);
}
else if ( iNode instanceof ExpressionNodeBase )
{
ExpressionNodeBase expr = (ExpressionNodeBase) iNode;
Name n = expr.getMName(currentScope.getProject());
if ( n == null )
{
currentScope.addProblem(new CodegenInternalProblem(iNode, "Unable to resove member name: " + iNode.toString()));
n = new Name(CONSTANT_Qname, new Nsset(new Namespace(CONSTANT_PackageNs, qualifiers)), base_name);
}
return currentScope.getBinding(iNode, n, expr.resolve(currentScope.getProject()));
}
//else
currentScope.addProblem(new CodegenInternalProblem(iNode, "Unable to resove to a dotted name: " + iNode.toString()));
return new Binding(iNode, new Name(CONSTANT_Qname, new Nsset(new Namespace(CONSTANT_PackageNs, qualifiers)), base_name), null);
}
/**
* Resolve a dotted name, e.g., foo.bar.baz, where the whole dotted name is a package
* this is an error, and a diagnostic will be emitted
*/
Binding errorPackageName(IASNode iNode, String qualifiers, String base_name)
{
currentScope.addProblem(new PackageCannotBeUsedAsValueProblem(iNode, "'" + qualifiers + "." + base_name + "'"));
return new Binding(iNode, new Name(qualifiers + "." + base_name), null);
}
private void generateAssignmentOp(IASNode site, Binding target, InstructionList result)
{
boolean inlined = generateInlineSetterAccess(target, result, true);
if (!inlined)
result.addInstruction(getAssignmentOpcode(site, target), target.getName());
}
/**
* Deduce the correct assignment opcode for a Binding.
*
* @param b - the Binding of interest.
* @return the appropriate opcode to assign to the entity represented by the
* Binding.
*/
int getAssignmentOpcode(IASNode site, Binding b)
{
if (b.getDefinition() instanceof IConstantDefinition && this.inInitializingContext(site))
return OP_initproperty;
else if (b.isSuperQualified())
return OP_setsuper;
else
return OP_setproperty;
}
/**
* Is the generator in an initializing context?
* @param iNode - the i-node of interest.
* @return true if the generator is in a context where it should
* generate initializer calls, i.e., OP_initproperty to set properties.
*/
boolean inInitializingContext(IASNode iNode)
{
return SemanticUtils.isInVariableDeclaration(iNode) || SemanticUtils.isInConstructor(iNode);
}
/**
* Common routine used by reductions that
* need an empty list.
* @param iNode - the current AST node.
*/
public InstructionList createInstructionList(IASNode iNode)
{
return createInstructionList(iNode, 0);
}
/**
* Common routine used by reductions that
* need an empty list.
* @param iNode - the current AST node.
* @param capacity - requested capacity of the new list.
* May be adjusted to accomodate debug instructions.
*/
public InstructionList createInstructionList(IASNode iNode, int capacity)
{
DebugInfoInstructionList result;
String file_name = SemanticUtils.getFileName(iNode);
// Note: getLine() uses zero-based counting.
int line_num = iNode.getLine() + 1;
// Adjust the capacity requirement if debug
// instructions are to be emitted.
if ( currentScope.emitFile(file_name) )
capacity++;
if ( currentScope.emitLine(line_num) )
capacity++;
// If the required capacity is less than three
// instructions, the InstructionList can hold
// them organically. Specifying a capacity to
// the InstructionList ctor causes it to allocate
// a separate ArrayList.
if ( capacity > 3 )
result = new DebugInfoInstructionList(capacity);
else
result = new DebugInfoInstructionList();
if ( currentScope.emitFile(file_name) )
{
currentScope.setDebugFile(file_name);
result.addInstruction(OP_debugfile, currentScope.getDebugFile());
}
if ( currentScope.emitLine(line_num) )
{
// Set the line number in the instruction list - it will
// emit or not emit the debugline depending on how it's used
result.setDebugLine(line_num);
currentScope.setDebugLine(line_num);
}
return result;
}
/**
* Instruction list to help with emitting OP_debuglines.
*
* When given a line number, it will emit an OP_debugline when addInstruction is called with an
* executable instruction.
*
* If addAll is called, then the debugline will not be emitted as the IL passed in should already have
* any necessary debuglines if it contains executable instrucitons.
*
*/
private static class DebugInfoInstructionList extends InstructionList
{
/**
* Constant for we don't have a line number
*/
public static final int NO_LINE = -1;
/**
* The line number to use for an op_debugline when an executable instruction is added
*/
private int line_num = NO_LINE;
DebugInfoInstructionList (int capacity)
{
super(capacity);
}
DebugInfoInstructionList ()
{
super();
}
/**
* Set the line number for this IL
* @param line_num the line number
*/
void setDebugLine(int line_num)
{
this.line_num = line_num;
}
/**
* Add the instruction to the IL. If the instruction is
* an exectuable instruction, and we have not emitted the line number yet,
* then this will insert an OP_debugline with the line number before the instruction is
* added.
* @param insn the instruction to be added.
* @return the added instruction
*/
public Instruction addInstruction(Instruction insn)
{
if( line_num != NO_LINE && insn.isExecutable() )
{
// add the debugline instruction first
// reset the line number
// do this before adding the instruction so
// we don't infinitely recurse
int line = line_num;
line_num = NO_LINE;
addInstruction(OP_debugline, line);
}
return super.addInstruction(insn);
}
}
/**
* Error trap.
*/
public Binding error_namespaceAccess(IASNode iNode, IASNode raw_qualifier, Binding qualified_name)
{
String qualifier = ((IdentifierNode)raw_qualifier).getName();
// TODO: In some circumstances, the namespace qualifier
// may be an invalid attribute on a declaration.
currentScope.addProblem(new UnknownNamespaceProblem(raw_qualifier, qualifier));
return qualified_name;
}
/**
* Error trap.
*/
public InstructionList error_reduce_Op_AssignId(IASNode iNode, InstructionList non_lvalue, InstructionList rvalue)
{
currentScope.addProblem(new InvalidLvalueProblem(iNode));
InstructionList result = createInstructionList(iNode, 1);
// Since we are reducing to an expression, make sure the instruction
// list we return, produces a value on the operand stack.
result.addInstruction(ABCConstants.OP_pushundefined);
return result;
}
/**
* Generate access to a named entity.
* @param name - the entity's name.
* @return an instruction sequence to access the entity.
*/
InstructionList generateAccess(Binding name)
{
return generateAccess(name, AccessType.Strict);
}
/**
* Enumerate possible access types to a named entity;
* Lenient is used in typeof expressions to access
* variables referred to by simple name and for the
* member references of member access expressions.
* All other expressions use strict access.
*/
private enum AccessType { Strict, Lenient }
/**
* Generate access to a named entity.
* @param name - the entity's name.
* @param accessType - one of Lenient or Strict.
* @return an instruction sequence to access the entity.
*/
InstructionList generateAccess(Binding name, AccessType accessType)
{
InstructionList result = new InstructionList(2);
generateAccess(name, accessType, result);
return result;
}
/**
* Generate access to a named entity.
* @param name - the entity's name.
* @param result - the instruction sequence to generate into.
*/
void generateAccess(Binding binding, InstructionList result)
{
generateAccess(binding, AccessType.Strict, result);
}
/**
* Generate access to a named entity.
* @param name - the entity's name.
* @param accessType - one of Lenient or Strict.
* @param result - the instruction sequence to generate into.
*/
void generateAccess(Binding binding, AccessType accessType, InstructionList result)
{
if (binding.isLocal())
{
result.addInstruction(binding.getlocal());
}
else
{
assert (binding.getName() != null) : "non-local Binding " + binding + " must have a name";
currentScope.getMethodBodySemanticChecker().checkGetProperty(binding);
boolean inlined = generateInlineGetterAccess(binding, result, false);
if (!inlined)
generateAccess(binding, binding.isSuperQualified(), accessType, result);
}
}
/**
* Generate access to a named entity.
* @param binding - the entity's binding.
* @param is_super - set if the name was explicitly qualified with "super."
* @param accessType - one of Lenient or Strict.
* @param result - the instruction sequence to generate into.
*/
void generateAccess(Binding binding, final boolean is_super, AccessType accessType, InstructionList result)
{
final Name name = binding.getName();
assert (name != null) : "binding must have a name when calling generateAccess()";
final IASNode node = binding.getNode();
if ( name.isTypeName() )
{
// a type names node should always be a ITypedExpressionNode
ITypedExpressionNode typeNode = (ITypedExpressionNode)node;
IExpressionNode collectionNode = typeNode.getCollectionNode();
IDefinition collectionDefinition = SemanticUtils.getDefinition(collectionNode, currentScope.getProject());
Binding collectionBinding = currentScope.getBinding(collectionNode, name.getTypeNameBase(), collectionDefinition);
generateAccess(collectionBinding, is_super, AccessType.Strict, result);
IExpressionNode typeTypeNode = typeNode.getTypeNode();
IDefinition typeDefinition = SemanticUtils.getDefinition(typeTypeNode, currentScope.getProject());
Binding typeBinding = currentScope.getBinding(typeTypeNode, name.getTypeNameParameter(), typeDefinition);
generateTypeNameParameter(typeBinding, result);
result.addInstruction(OP_applytype, 1);
}
else
{
// Test whether we're refering to the class being initialized, for example:
// public class C {
// private static var v:Vector.<C> = new Vector.<C>();
// }
// as in this case we need to do a getlocal0 as the class
// hasn't been initialized yet
boolean useLocal0 = false;
if (node instanceof IdentifierNode)
{
IdentifierNode id = (IdentifierNode)node;
IDefinition def = id.resolve(currentScope.getProject());
if (SemanticUtils.isRefToClassBeingInited(id, def) && !currentScope.insideInlineFunction())
useLocal0 = true;
}
// TODO: use getslot when we can.
// TODO: we can at least do this when we're accessing something in an activation object
if (useLocal0)
{
result.addInstruction(OP_getlocal0);
}
else if (is_super)
{
result.addAll(currentScope.findProperty(binding, true));
result.addInstruction(OP_getsuper, name);
}
else if (accessType == AccessType.Lenient)
{
result.addAll(currentScope.findProperty(binding, false));
result.addInstruction(OP_getproperty, name);
}
else
{
result.addAll(currentScope.getPropertyValue(binding));
}
}
}
private boolean generateInlineGetterAccess(Binding binding, InstructionList result, boolean isQualified)
{
IDefinition def = binding.getDefinition();
if (!(def instanceof AccessorDefinition && currentScope.getMethodBodySemanticChecker().canGetterBeInlined((AccessorDefinition)def)))
return false;
AccessorDefinition accessorDefinition = (AccessorDefinition)def;
if (accessorDefinition instanceof SetterDefinition)
accessorDefinition = accessorDefinition.resolveCorrespondingAccessor(currentScope.getProject());
assert (accessorDefinition != null) : "generateInlineGetterAccess() called with no getter definition";
FunctionNode functionNode = (FunctionNode)accessorDefinition.getFunctionNode();
return inlineFunction(accessorDefinition, functionNode, result, isQualified);
}
private boolean generateInlineSetterAccess(Binding binding, InstructionList result, boolean isQualified)
{
IDefinition def = binding.getDefinition();
if (!(def instanceof AccessorDefinition && currentScope.getMethodBodySemanticChecker().canSetterBeInlined((AccessorDefinition)def)))
return false;
AccessorDefinition accessorDefinition = (AccessorDefinition)def;
if (accessorDefinition instanceof GetterDefinition)
accessorDefinition = accessorDefinition.resolveCorrespondingAccessor(currentScope.getProject());
assert (accessorDefinition != null) : "generateInlineSetterAccess() called with no setter definition";
FunctionNode functionNode = (FunctionNode)accessorDefinition.getFunctionNode();
return inlineFunction(accessorDefinition, functionNode, result, isQualified);
}
private boolean generateInlineFunctionCall(Binding binding, InstructionList result, boolean isQualified, Vector<InstructionList> args)
{
IDefinition def = binding.getDefinition();
if (!(def instanceof FunctionDefinition && (!(def instanceof IAccessorDefinition)) && currentScope.getMethodBodySemanticChecker().canFunctionBeInlined((FunctionDefinition)def)))
return false;
FunctionDefinition functionDef = (FunctionDefinition)binding.getDefinition();
FunctionNode functionNode = (FunctionNode)functionDef.getFunctionNode();
InstructionList insn = createInstructionList(functionNode);
for (InstructionList arg: args)
insn.addAll(arg);
if (inlineFunction(functionDef, functionNode, insn, isQualified))
{
result.addAll(insn);
return true;
}
else
{
return false;
}
}
private boolean inlineFunction(FunctionDefinition functionDef, FunctionNode functionNode, InstructionList result, boolean isQualified)
{
try
{
InlineFunctionLexicalScope inlineFunctionScope = currentScope.pushInlineFunctionFrame(functionDef.getContainingScope(), isQualified, functionNode);
currentScope = inlineFunctionScope;
// generate the instructions for the body of the function
IScopedNode body = functionNode.getScopedNode();
InstructionList insns = inlineFunctionScope.getGenerator().generateInstructions(body, CmcEmitter.__statement_NT, inlineFunctionScope);
currentScope = currentScope.popFrame();
final ICompilerProject project = currentScope.getProject();
if (currentScope.getMethodBodySemanticChecker().functionBodyHasNonInlineableInstructions(insns, functionDef.isInline(), functionDef.getBaseName()))
{
return false;
}
else
{
inlineFunctionScope.assignActualsToFormals(functionDef, result);
if (isQualified)
result.addInstruction(inlineFunctionScope.setContainingClass());
result.addAll(insns);
// test for a fallthrough when the return type is non-void, as we
// need coerce undefined to the return type to mimic returnvoid behavior
if (!(functionDef instanceof SetterDefinition) && result.canFallThrough() || result.hasPendingLabels())
{
TypeDefinitionBase returnType = (TypeDefinitionBase)functionDef.resolveReturnType(project);
if (returnType != currentScope.getProject().getBuiltinType(BuiltinType.VOID) &&
returnType != currentScope.getProject().getBuiltinType(BuiltinType.ANY_TYPE))
{
result.addInstruction(OP_pushundefined);
result.addInstruction(OP_coerce, returnType.getMName(project));
}
}
result.labelNext(inlineFunctionScope.getInlinedFunctionCallSiteLabel());
inlineFunctionScope.mergeIntoContainingScope(result);
}
}
finally
{
functionNode.discardFunctionBody();
}
return true;
}
/**
* Generate code to assign to a named entity.
* @param target - the entity to be assigned to.
* @param rvalue - the value to assign.
* @return an instruction sequence that stores
* the given rvalue in the target.
*
*/
InstructionList generateAssignment(IASNode iNode, Binding target, InstructionList rvalue)
{
return generateAssignment(iNode, target, rvalue, false);
}
/**
* Generate code to assign to a named entity.
* @param target - the entity to be assigned to.
* @param rvalue - the value to assign.
* @param need_value - when true,
* leave a DUP of the rvalue on the stack.
* @return an instruction sequence that stores
* the given rvalue in the target, and leaves
* a DUP of the rvalue on the stack if need_value is set.
*
*/
InstructionList generateAssignment(IASNode iNode, Binding target, InstructionList rvalue, boolean need_value)
{
InstructionList result = createInstructionList(iNode, rvalue.size() + 4);
// We may need to know if the RHS is in a local
// for some micro-optimizations; the rvalue instruction
// list is about to be invalidated, so speculatively
// determine that information here.
int rhsOpcode = rvalue.lastElement().getOpcode();
final boolean rhsIsLocal =
rhsOpcode == OP_getlocal ||
rhsOpcode == OP_getlocal0 ||
rhsOpcode == OP_getlocal1 ||
rhsOpcode == OP_getlocal2 ||
rhsOpcode == OP_getlocal3;
result.addAll(rvalue);
if ( need_value )
result.addInstruction(OP_dup);
// when assigning to a local or slot, we need to generate the type coerce and
// runtime illegal write to const checks, so combine in this if block.
if ( target.isLocal() || target.slotIdIsSet() )
{
if ( target.getDefinition() != null )
{
ITypeDefinition tgtType = target.getDefinition().resolveType(currentScope.getProject());
ITypeDefinition srcType = null;
srcType = SemanticUtils.resolveRHSTypeOfAssignment(currentScope.getProject(), iNode);
if (
tgtType != null &&
tgtType != ClassDefinition.getAnyTypeClassDefinition() &&
!(srcType == tgtType && rhsIsLocal)
)
{
coerce(result, tgtType);
}
}
// If the target is a const and this assignment occurs outside the const's declaration,
// emulate the AVM's behavior by compiling in a throw statement.
// Note that this behavior differs from ASC's until ASC-4376 is fixed.
// We need to keep this runtime check, as in strict mode this is a semantic error, but
// in non-strict mode it needs to be caught at run time.
if (
SemanticUtils.isConstDefinition(target.getDefinition()) &&
!SemanticUtils.isInVariableDeclaration(iNode) &&
target.getName() != null
)
{
result.addInstruction(OP_pushstring, "Illegal write to local const " + target.getName().getBaseName());
result.addInstruction(OP_throw);
}
else if (target.slotIdIsSet())
{
if (currentScope.needsActivation())
{
// Restore the activation object.
result.addInstruction(currentScope.getActivationStorage().getlocal());
result.addInstruction(OP_swap);
}
result.addInstruction(OP_setslot, target.getSlotId());
}
else
{
result.addInstruction(target.setlocal());
}
}
else
{
boolean inlined = generateInlineSetterAccess(target, result, false);
if (!inlined)
{
IDefinition def = target.getDefinition();
if (def instanceof GetterDefinition)
{
boolean isSuper = target.isSuperQualified();
SetterDefinition setter = (SetterDefinition)((GetterDefinition)def).
resolveCorrespondingAccessor(currentScope.getProject());
target = currentScope.getBinding(setter);
if (isSuper)
target.setSuperQualified(true);
}
result.addAll(currentScope.findProperty(target, false));
result.addInstruction(OP_swap);
result.addInstruction(getAssignmentOpcode(iNode, target), target.getName());
}
}
return result;
}
/**
* Generate a catch block.
* @param catch_proto - the catch block's prototype.
*/
InstructionList generateCatchBlock( Label try_start, Label try_end, CatchPrototype catch_proto)
{
InstructionList scope_reinit = currentScope.getFlowManager().getScopeStackReinit();
InstructionList current_catch = new InstructionList(catch_proto.catchBody.size() + scope_reinit.size() + 15);
// Common prologue code.
if ( currentScope.needsThis() )
{
current_catch.addInstruction(OP_getlocal0);
current_catch.addInstruction(OP_pushscope);
}
if( currentScope.needsActivation() )
{
// Restore the activation object.
current_catch.addInstruction(currentScope.getActivationStorage().getlocal());
current_catch.addInstruction(OP_pushscope);
}
// Re-establish enclosing exception scopes.
current_catch.addAll(scope_reinit);
int handler_number = currentScope.getMethodBodyVisitor().visitException(try_start, try_end, current_catch.getLabel(), catch_proto.catchType, catch_proto.catchVarName);
Binding exception_storage = currentScope.getFlowManager().getFinallyContext().getExceptionStorage();
current_catch.addInstruction(OP_newcatch, handler_number);
current_catch.addInstruction(OP_dup);
if ( exception_storage != null )
{
current_catch.addInstruction(exception_storage.setlocal());
current_catch.addInstruction(OP_dup);
}
current_catch.addInstruction(OP_pushscope);
current_catch.addInstruction(OP_swap);
current_catch.addInstruction(OP_setslot, 1);
current_catch.addAll(catch_proto.catchBody);
if ( current_catch.canFallThrough() || current_catch.hasPendingLabels() )
{
current_catch.addInstruction(OP_popscope);
}
return current_catch;
}
/**
* Generate a compound assignment statement.
*/
InstructionList generateCompoundAssignment(IASNode iNode, Binding lvalue, InstructionList expr, int opcode, boolean need_value)
{
InstructionList result = createInstructionList(iNode, expr.size() + (lvalue.isLocal()? 4 : 8));
currentScope.getMethodBodySemanticChecker().checkCompoundAssignment(iNode, lvalue, opcode);
if ( lvalue.isLocal() )
{
result.addInstruction(lvalue.getlocal());
result.addAll(expr);
result.addInstruction(opcode);
if ( need_value )
result.addInstruction(OP_dup);
// Coerce to the right type if the local has a type anno
if ( lvalue.getDefinition() != null )
{
ITypeDefinition type = lvalue.getDefinition().resolveType(currentScope.getProject());
if ( type != ClassDefinition.getAnyTypeClassDefinition() )
{
coerce(result, type);
}
}
result.addInstruction(lvalue.setlocal());
}
else
{
result.addAll(currentScope.findProperty(lvalue, true));
result.addInstruction(OP_dup);
result.addInstruction(OP_getproperty, lvalue.getName());
result.addAll(expr);
result.addInstruction(opcode);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(getAssignmentOpcode(iNode, lvalue), lvalue.getName());
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
}
return result;
}
InstructionList generateCompoundBracketAssignment(IASNode iNode, InstructionList stem, InstructionList index, InstructionList expr, int opcode, boolean need_value)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IBinaryOperatorNode)iNode).getLeftOperandNode();
InstructionList result = createInstructionList(iNode, stem.size() * 2 + index.size() + expr.size() + 11 );
// Although ASC evaluates the stem twice, it only evaluates the index once.
// TODO: Inspect the index expression for side effects so the temp can be
// elided in most cases.
Binding index_temp = currentScope.allocateTemp();
result.addAll(index);
result.addInstruction(index_temp.setlocal());
result.addAll(replicate(stem));
result.addInstruction(index_temp.getlocal());
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
result.addAll(expr);
result.addInstruction(opcode);
Binding value_temp = currentScope.allocateTemp();
result.addInstruction(value_temp.setlocal());
result.addAll(stem);
result.addInstruction(index_temp.getlocal());
result.addInstruction(value_temp.getlocal());
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
if ( need_value )
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
currentScope.releaseTemp(index_temp);
return result;
}
InstructionList generateCompoundAssignmentToRuntimeName(IASNode iNode, RuntimeMultiname name, InstructionList expr, int opcode, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(name.generateRvalue(iNode));
result.addAll(expr);
result.addInstruction(opcode);
if ( need_value )
{
// TODO: In many cases this temp can be avoided by more sophisticated analysis.
// TODO: See also comments in RuntimeMultiname.generateGetOrSet().
Binding temp = currentScope.allocateTemp();
result.addInstruction(temp.setlocal());
InstructionList temp_rhs = new InstructionList();
temp_rhs.addInstruction(temp.getlocal());
result.addAll(name.generateAssignment(iNode, temp_rhs));
result.addInstruction(temp.getlocal());
currentScope.releaseTemp(temp);
}
else
{
result = name.generateAssignment(iNode, result);
}
return result;
}
InstructionList generateCompoundMemberAssignment(IASNode iNode, InstructionList stem, Binding member, InstructionList expr, int fetch_opcode, int assign_opcode, boolean need_value)
{
InstructionList result = createInstructionList(iNode, stem.size() * 2 + expr.size() + 5 );
currentScope.getMethodBodySemanticChecker().checkCompoundAssignment(iNode, member, assign_opcode);
// TODO: Depending on the resolution of ASC-4159 and
// the corresponding Falcon backwards compatibility
// issue, cache the stem expression in a local to avoid
// multiple evaluations.
result.addAll(replicate(stem));
result.addInstruction(fetch_opcode, member.getName());
result.addAll(expr);
result.addInstruction(assign_opcode);
if ( need_value )
{
result.addInstruction(OP_dup);
}
result.addAll(stem);
result.addInstruction(OP_swap);
result.addInstruction(getAssignmentOpcode(iNode, member), member.getName());
return result;
}
/**
* Generate a compound logical assignment expression to a named lvalue.
* @param iNode - the assignment operator (root of the subtree).
* @param lvalue - the lvalue's name.
* @param expr - the expression to assign.
* @param is_and - true if the expression is &&=, false if it's ||=.
* @param need_value - true if the expression's not used in a void context.
*/
InstructionList generateCompoundLogicalAssignment(IASNode iNode, Binding lvalue, InstructionList expr, boolean is_and, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
int failure_test = is_and? OP_iffalse : OP_iftrue;
currentScope.getMethodBodySemanticChecker().checkCompoundAssignment(iNode, lvalue, failure_test);
Label tail = new Label();
if ( lvalue.isLocal() )
{
// Fetch and test the current value.
result.addInstruction(lvalue.getlocal());
// The current value may not be the result value,
// but for now assume it is.
if ( need_value )
result.addInstruction( OP_dup);
result.addInstruction( failure_test, tail );
// Test succeeded: reset the value, but first
// pop the value speculatively dup'd above.
if ( need_value )
result.addInstruction(OP_pop);
result.addAll(expr);
if ( need_value )
result.addInstruction(OP_dup);
result.addInstruction(lvalue.setlocal());
}
else
{
// Fetch, speculatively dup, and test the current value.
result.addAll(currentScope.getPropertyValue(lvalue));
if ( need_value )
result.addInstruction(OP_dup);
result.addInstruction(failure_test, tail);
if ( need_value )
result.addInstruction(OP_pop);
result.addAll(expr);
if ( need_value )
{
result.addInstruction(OP_dup);
}
result.addAll(currentScope.findProperty(lvalue, true));
result.addInstruction(OP_swap);
result.addInstruction(getAssignmentOpcode(iNode, lvalue), lvalue.getName());
}
result.labelNext(tail);
return result;
}
/**
* Generate compound logical assignment to a runtime name, e.g., n::x ||= foo;
* @param iNode - the root of the assignment subtree.
* @param name - the runtime name.
* @param expr - the second operand of the implied binary expression.
* @param is_and - true if the result is set to the second operand iff the first operand is true.
* @param need_value - true if the value of the assignment is required.
*/
InstructionList generateCompoundLogicalRuntimeNameAssignment(IASNode iNode, RuntimeMultiname name, InstructionList expr, boolean is_and, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
Label tail = new Label();
int failure_test = is_and? OP_iffalse : OP_iftrue;
Binding rhs_temp = null;
InstructionList rhs_fetch = null;
// Fetch, speculatively dup, and test the current value.
result.addAll(name.generateRvalue(iNode));
if ( need_value )
result.addInstruction(OP_dup);
result.addInstruction(failure_test, tail);
if ( need_value )
{
// Clear the speculative dup.
result.addInstruction(OP_pop);
}
result.addAll(expr);
if ( need_value )
{
// The runtime multiname instruction sequence
// doesn't allow the rhs expression to travel
// on the stack.
rhs_temp = currentScope.allocateTemp();
rhs_fetch = createInstructionList(iNode);
result.addInstruction(OP_dup);
result.addInstruction(rhs_temp.setlocal());
rhs_fetch.addInstruction(rhs_temp.getlocal());
result.addAll(name.generateAssignment(iNode, rhs_fetch));
currentScope.releaseTemp(rhs_temp);
}
else
{
result = (name.generateAssignment(iNode, result));
}
result.labelNext(tail);
return result;
}
/**
* Generate a compound logical assignment expression to a a[i] type lvalue.
* @param iNode - the assignment operator (root of the subtree).
* @param stem - the expression that generates the lvalue's stem, e.g., a in a[i]
* @param index - the index expression.
* @param expr - the expression to assign.
* @param is_and - true if the expression is &&=, false if it's ||=.
* @param need_value - true if the expression's not used in a void context.
*/
InstructionList generateCompoundLogicalBracketAssignment(IASNode iNode, InstructionList stem, InstructionList index, InstructionList expr, boolean is_and, boolean need_value)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IBinaryOperatorNode)iNode).getLeftOperandNode();
InstructionList result = createInstructionList(iNode, stem.size() * 2 + index.size() + expr.size() + 11 );
Label tail = new Label();
int failure_test = is_and? OP_iffalse : OP_iftrue;
// Although ASC evaluates the stem twice, it only evaluates the index once.
// TODO: Inspect the index expression for side effects so the temp can be
// elided in most cases.
Binding index_temp = currentScope.allocateTemp();
result.addAll(index);
result.addInstruction(index_temp.setlocal());
result.addAll(replicate(stem));
result.addInstruction(index_temp.getlocal());
result.addAll(stem);
result.addInstruction(index_temp.getlocal());
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
// Assume this is the result.
result.addInstruction(OP_dup);
result.addInstruction(failure_test, tail);
// Pop the speculative result and assign the correct one.
result.addInstruction(OP_pop);
result.addAll(expr);
result.labelNext(tail);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
currentScope.releaseTemp(index_temp);
return result;
}
/**
* Generate a compound logical assignment expression to a foo.bar type lvalue
* @param iNode - the assignment operator (root of the subtree).
* @param stem - the expression that generates the lvalue's stem, e.g., a in a[i]
* @param index - the index expression.
* @param expr - the expression to assign.
* @param is_and - true if the expression is &&=, false if it's ||=.
* @param need_value - true if the expression's not used in a void context.
*/
InstructionList generateCompoundLogicalMemberAssignment(IASNode iNode, InstructionList stem, Binding member, InstructionList expr, int fetch_opcode, boolean is_and, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
int failure_test = is_and? OP_iffalse : OP_iftrue;
currentScope.getMethodBodySemanticChecker().checkCompoundAssignment(iNode, member, failure_test);
Label tail = new Label();
result.addAll(replicate(stem));
result.addAll(stem);
result.addInstruction(OP_getproperty, member.getName());
// Assume this is the result.
result.addInstruction(OP_dup);
result.addInstruction(failure_test, tail);
result.addInstruction(OP_pop);
result.addAll(expr);
result.labelNext(tail);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(getAssignmentOpcode(iNode, member), member.getName());
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
return result;
}
/**
* generateFunctionBody() wrapper suitable for calling from the BURM.
* See JBurg ENHRQ <N> : the grammar that accepts the BURM's parameters
* to a JBurg.Reduction routine doesn't grok function calls, so the BURM
* cannot call generateFunctionBody(body, name.getName());
*/
InstructionList generateFunctionBody(IASNode iNode, InstructionList function_body, Binding return_type)
{
return generateFunctionBody(iNode, function_body, return_type != null? return_type.getName(): null);
}
/**
* Generate boilerplate function prolog/epilog code.
* @param block - the actual CFG.
* @param return_type - the function's return type.
* @return the function body.
*/
InstructionList generateFunctionBody(IASNode iNode, InstructionList function_body, Name return_type)
{
currentScope.getMethodBodySemanticChecker().checkFunctionBody(iNode);
currentScope.getMethodInfo().setReturnType(return_type);
InstructionList result = currentScope.finishMethodDeclaration( !function_body.isEmpty() || haveInstanceInitializers(), SemanticUtils.getFileName(iNode));
// Constructor-specific processing: add the instance initializers,
// add a constructsuper call if none exists.
if ( haveInstanceInitializers() && currentScope.getNestingState() == NestingState.NotNested)
{
result.addAll(this.instanceInitializers);
// If this is a constructor and there's no explicit
// super() call, synthesize one.
// Note that this may be a semantic error if the
// superclass' constructor needs arguments.
if ( !function_body.hasSuchInstruction(OP_constructsuper) )
{
currentScope.getMethodBodySemanticChecker().checkDefaultSuperCall(iNode);
// Call the superclass' constructor after the instance
// init instructions; this doesn't seem like an abstractly
// correct sequence, but it's what ASC does.
result.addInstruction(OP_getlocal0);
result.addInstruction(OP_constructsuper, 0);
}
}
result.addAll(function_body);
// Epilog code.
if ( result.canFallThrough() || result.hasPendingLabels() )
{
// Synthesize a returnvoid instruction, using the
// single-purpose returnvoid so the caller can
// search for it.
// If, at some point, the MBSC walks all functions' CFGs,
// then all returnvoid processing can be centralized and
// this specialized Instruction will be unnecessary.
result.addInstruction(synthesizedReturnVoid);
}
return result;
}
/**
* This returnvoid instruction is used when the reducer injects a returnvoid at
* the end of a method body; the caller (with access to the MethodBodyInfo) can
* create a control flow graph and search it to emit a diagnostic as appropriate.
*/
public static final Instruction synthesizedReturnVoid = new NoOperandsInstruction(OP_returnvoid);
/**
* Generate a named nested function.
*
* This will generate init instructions either in controlFlow?Sensitive?Destination, or in the current scopes hoisted init instructions.
* Most of the time the instuctions will go in the hoisted init instructions, but if the nested function is declared
* in a 'with' or 'catch' block then the init instructions need to go into the normal controlFlow?Sensitive?Destination.
*
* @param iNode - the function node for the nested function.
* @param controlFlowSensitiveDestination - the instruction list to add instructions to
* @param func_name - the function's name.
* @param return_type - the function's return type.
* @param function_body - the body of the function.
* @pre the function's lexical scope must be at the
* top of the lexical scope stack, with the declaring
* function's lexical scope under it.
* @post the nested function's MethodInfo is filled in,
* the function body is attached to its MethodBodyInfo,
* and the declaring function's initialization sequence
* gets code to declare the function.
*/
private void generateNestedFunction(IASNode iNode, InstructionList controlFlowSensitiveDestination, Binding func_name, Name return_type, InstructionList function_body)
{
currentScope.setFunctionName(func_name.getName().getBaseName());
currentScope.generateNestedFunction(generateFunctionBody(iNode, function_body, return_type));
// Pull the nested function's MethodInfo out of its scope before we pop it.
MethodInfo nested_method_info = currentScope.getMethodInfo();
currentScope = currentScope.popFrame();
// Initialize the nested function; add a variable
// to the containing function scope and add
// newfunction/setproperty logic to the containing
// function's hoisted initialization instructions.
currentScope.makeVariable(func_name);
InstructionList init_insns = SemanticUtils.canNestedFunctionBeHoisted(iNode) ? currentScope.getHoistedInitInstructions() : controlFlowSensitiveDestination;
// The containing function must be marked needsActivation() so the
// binding cannot be local.
assert(!func_name.isLocal());
init_insns.addInstruction(OP_findproperty, func_name.getName());
init_insns.addInstruction(OP_newfunction, nested_method_info);
init_insns.addInstruction(OP_setproperty, func_name.getName());
}
/**
* Generate a try/catch/finally (or try/finally) compound statement.
* @param try_stmt - the body of the try block.
* @param catch_blocks - associated catch blocks.
* May be null if no catch blocks are present.
* @param finally_stmt - the body of the finally block.
*/
InstructionList generateTryCatchFinally ( InstructionList try_stmt, Vector<CatchPrototype> catch_blocks, InstructionList finally_stmt)
{
InstructionList normal_flow_fixup = new InstructionList();
InstructionList catch_insns = new InstructionList();
InstructionList final_catch = new InstructionList();
InstructionList finally_insns = new InstructionList();
InstructionList final_throw = new InstructionList();
ExceptionHandlingContext finally_context = currentScope.getFlowManager().getFinallyContext();
Label final_catch_target = final_catch.getLabel();
// We need a local to store the caught exception.
Binding exception_storage = finally_context.getExceptionStorage();
Collection<Label> pending_normal_control_flow = try_stmt.stripPendingLabels();
if ( try_stmt.canFallThrough() || pending_normal_control_flow != null )
{
normal_flow_fixup.addInstruction(OP_jump, finally_context.finallyBlock);
}
else
{
// Extend the region past a terminating
// throw statement to give the AVM a
// little buffer to figure out its
// exception-handling regions.
normal_flow_fixup.addInstruction(OP_nop);
}
Label try_start = try_stmt.getLabel();
Label try_end = normal_flow_fixup.getLastLabel();
Label finally_region_end = null;
if ( null == catch_blocks )
{
finally_region_end = try_end;
}
else
{
for ( CatchPrototype catch_proto: catch_blocks )
{
InstructionList catch_body = generateCatchBlock(try_start, try_end, catch_proto);
boolean is_last_catch = catch_proto.equals(catch_blocks.lastElement());
if ( catch_body.canFallThrough() )
{
// Signal the finally block that this execution succeeded.
catch_body.addInstruction(OP_pushbyte, 0);
catch_body.addInstruction(finally_context.finallyReturnStorage.setlocal());
catch_body.addInstruction(OP_jump, finally_context.finallyBlock);
}
else if ( is_last_catch )
{
// Extend the region past a terminating throw
// insn to give the AVM a little buffer.
catch_body.addInstruction(OP_nop);
}
if ( is_last_catch )
finally_region_end = catch_body.getLastLabel();
catch_insns.addAll(catch_body);
}
}
// Set up the exception handler for the finally block.
currentScope.getMethodBodyVisitor().visitException(try_start, finally_region_end, final_catch_target, null, null);
// The final catch block only needs to save the
// caught exception for a rethrow.
if ( currentScope.needsThis() )
{
final_catch.addInstruction(OP_getlocal0);
final_catch.addInstruction(OP_pushscope);
}
if( currentScope.needsActivation() )
{
// Restore the activation object
final_catch.addInstruction(currentScope.getActivationStorage().getlocal());
final_catch.addInstruction(OP_pushscope);
}
final_catch.addAll(currentScope.getFlowManager().getScopeStackReinit());
final_catch.addInstruction(exception_storage.setlocal());
// Signal the finally epilog that this execution failed
// and should rethrow.
final_catch.addInstruction(OP_pushbyte, currentScope.getFlowManager().getFinallyAlternativesSize() + 1);
final_catch.addInstruction(finally_context.finallyReturnStorage.setlocal());
// falls through
// final_catch.addInstruction(OP_jump, finally_head);
finally_insns.addInstruction(finally_context.finallyReturnStorage.getlocal());
finally_insns.addInstruction(OP_convert_i);
finally_insns.addAll(currentScope.getFlowManager().getFinallySwitch());
// Label the start of the final set of instructions.
if (!finally_stmt.isEmpty())
{
finally_stmt.labelFirst(finally_context.finallyBlock);
}
else
// This is just an expedient for this degenerate finally.
finally_insns.labelFirst(finally_context.finallyBlock);
final_throw.addInstruction(exception_storage.getlocal());
final_throw.labelCurrent(finally_context.finallyDoRethrow);
final_throw.addInstruction(OP_throw);
// Assemble the statement.
InstructionList result = new InstructionList();
result.addInstruction(OP_pushbyte, 0);
result.addInstruction(finally_context.finallyReturnStorage.setlocal());
result.addAll(try_stmt);
// Send all "next statement" type control flow into the finally block.
result.addAllPendingLabels(pending_normal_control_flow);
result.addAll(normal_flow_fixup);
result.addAll(catch_insns);
result.addAll(final_catch);
result.addAll(finally_stmt);
result.addAll(finally_insns);
result.addAll(final_throw);
for ( ExceptionHandlingContext.FinallyReturn retblock: finally_context.finallyReturns )
result.addAll(retblock.getInstructions());
// TODO: Need more analysis of how this temp travels through
// the system before it can be safely released. For now
// just leak it.
// currentScope.releaseTemp(exception_storage);
// TODO: Removing a hanging kill exposed a latent bug
// in hasPendingLabels() and end-of-routine processing.
// Give the CG a harmless instruction that will generate
// a returnvoid if this is the last statement in the routine.
result.addInstruction(OP_nop);
// Fallthrough out of the finally block.
result.labelNext(finally_context.finallyDoFallthrough);
return result;
}
/**
* Reduce a name to an instruction list that can be used in a parameterized type expression.
* This is different from the normal name -> expression because '*' maps to pushnull.
* @param iNode the node
* @param param_name the name to reduce
* @return IL with instructions to push the appropriate value on the stack
*/
public InstructionList reduce_typeNameParameter(IASNode iNode, Binding param_name)
{
InstructionList result = createInstructionList(iNode);
generateTypeNameParameter(param_name, result);
return result;
}
/**
* Generate the instruction sequence that designates
* the parameter of a parameterized type, e.g.,
* String in Vector.<String> or * in Vector.<*>.
* @param param_node - the type parameter's node.
* @param param_name - the type parameter's name.
* May be null in the * case.
* @param result - the instruction sequence to generate into.
*/
private void generateTypeNameParameter(Binding param, InstructionList result)
{
if ( param == null || param.getName() == null || param.getName().couldBeAnyType() )
result.addInstruction(OP_pushnull);
else
generateAccess(param, false, AccessType.Strict, result);
}
/**
* @return A
* {@link ControlFlowContextManager.ControlFlowContextSearchCriteria} that
* will find the control context that a break statement without a label in
* the current control flow context refers to. This should always be a
* control flow context for any of:
* <ul>
* <li>a labeled statement</li>
* <li>a loop</li>
* <li>a switch statement</li>
* </ul>
*/
private ControlFlowContextManager.ControlFlowContextSearchCriteria getBreakCriteria()
{
return ControlFlowContextManager.breakWithOutLabelCriteria;
}
/**
* @return A
* {@link ControlFlowContextManager.ControlFlowContextSearchCriteria} that
* will find the control context that a continue statement without a label
* in the current control flow context refers to. This should always be a
* control flow context for a loop.
*/
private ControlFlowContextManager.ControlFlowContextSearchCriteria getContinueCriteria()
{
return ControlFlowContextManager.continueWithOutLabelCriteria;
}
/**
* @param Label name in a break statement with a label.
* @return A
* {@link ControlFlowContextManager.ControlFlowContextSearchCriteria} that
* will find the control context that a break statement with a label in the
* current control flow context refers to. This should always be a control
* flow context for labeled statement.
*/
private ControlFlowContextManager.ControlFlowContextSearchCriteria getBreakCriteria(String label)
{
return currentScope.getFlowManager().breakWithLabelCriteria(label);
}
/**
* @param Label name in a continue statement with a label.
* @return A
* {@link ControlFlowContextManager.ControlFlowContextSearchCriteria} that
* will find the control context that a continue statement with a label
* in the current control flow context refers to. This should always be a
* control flow context for a loop.
*/
private ControlFlowContextManager.ControlFlowContextSearchCriteria getContinueCriteria(String label)
{
return currentScope.getFlowManager().continueWithLabelCriteria(label);
}
/**
* @param Label name in a goto statement.
* @return A
* {@link ControlFlowContextManager.ControlFlowContextSearchCriteria} that
* will find the control context that a goto statement in the
* current control flow context refers to. This should always be a control
* flow context for labeled statement.
*/
private ControlFlowContextManager.ControlFlowContextSearchCriteria getGotoCriteria(String label)
{
return currentScope.getFlowManager().gotoLabelCriteria(label, false);
}
/**
* Constructs a sequence of code that will jump to the proper location in the
* control flow context matched by the criteria object. The returned code will
* run finally blocks and adjust the scope stack if needed.
* @param criteria Criteria object that matches the control flow context and specifies the location
* in that context to which the generated code will jump to.
* @return An {@link InstructionList} that will jump to the proper location in the
* control flow context matched by the criteria object
* @throws UnknownControlFlowTargetException
*/
private InstructionList getBranchTarget(ControlFlowContextManager.ControlFlowContextSearchCriteria criteria)
throws UnknownControlFlowTargetException
{
return currentScope.getFlowManager().getBranchTarget(criteria);
}
/**
* @return the double content of a numeric literal.
* @param iNode - the literal node.
*/
Double getDoubleContent(IASNode iNode)
{
return SemanticUtils.getDoubleContent(iNode);
}
/**
* @return the name of an identifier.
* @param iNode - the IIdentifier node.
*/
String getIdentifierContent(IASNode iNode)
{
return SemanticUtils.getIdentifierContent(iNode);
}
/**
* @return the int content of a numeric literal.
* @param iNode - the literal node.
*/
Integer getIntegerContent(IASNode iNode)
{
return SemanticUtils.getIntegerContent(iNode);
}
/**
* @return always zero.
* @param iNode - the literal node.
*/
Integer getIntegerZeroContent(IASNode iNode)
{
return 0;
}
/**
* @return always zero.
* @param iNode - the literal node.
*/
Long getIntegerZeroContentAsLong(IASNode iNode)
{
return 0L;
}
/**
* @return a node cast to MXMLEventSpecifierNode type.
* @param iNode - the MXMLEventSpecifierNode node.
*/
IMXMLEventSpecifierNode getMXMLEventSpecifierContent(IASNode iNode)
{
return SemanticUtils.getMXMLEventSpecifierContent(iNode);
}
/**
* Find all active exception handling blocks or scopes,
* and set up finally return sequences and/or popscopes.
* @param original - the original control-flow sequence.
* @param criterion - the search criterion that identifies
* the boundary of the region to be exited.
* @return a control-flow sequence that is either the
* original sequence or the start of a trampoline of
* finally blocks, popscopes, and whatever else is
* necessary to exit the control-flow region.
* @throws UnknownControlFlowTargetException if the criterion is not on the control-flow stack.
*/
private InstructionList getNonLocalControlFlow(InstructionList original, ControlFlowContextManager.ControlFlowContextSearchCriteria criterion)
throws UnknownControlFlowTargetException
{
return currentScope.getFlowManager().getNonLocalControlFlow(original, criterion);
}
/**
* Find all active exception handling blocks or scopes,
* and set up finally return sequences and/or popscopes.
* @param criterion - the search criterion that identifies
* the boundary of the region to be exited and the target
* in the found region to jump to.
* @return a control-flow sequence that is either the
* original sequence or the start of a trampoline of
* finally blocks, popscopes, and whatever else is
* necessary to exit the control-flow region.
* @throws UnknownControlFlowTargetException if the criterion is not on the control-flow stack.
*/
private InstructionList getNonLocalControlFlow(ControlFlowContextManager.ControlFlowContextSearchCriteria criterion)
throws UnknownControlFlowTargetException
{
return currentScope.getFlowManager().getNonLocalControlFlow(getBranchTarget(criterion), criterion);
}
/**
* @return a parameter's definition.
* @param iNode - the parameter node.
*/
IDefinition getParameterContent(IASNode iNode)
{
return SemanticUtils.getParameterContent(iNode);
}
/**
* @return the string content of a literal.
* @param iNode - the literal node.
*/
String getStringLiteralContent(IASNode iNode)
{
return SemanticUtils.getStringLiteralContent(iNode);
}
/**
* @return the uint content of a numeric literal.
* @param iNode - the literal node.
*/
Long getUintContent(IASNode iNode)
{
return SemanticUtils.getUintContent(iNode);
}
/**
* @return the Boolean content of a BOOLEAN literal.
* @param iNode - the literal node.
*/
boolean getBooleanContent(IASNode iNode)
{
return SemanticUtils.getBooleanContent(iNode);
}
/**
* @return true if instance initialization instructions are present.
*/
private boolean haveInstanceInitializers()
{
return instanceInitializers != null;
}
/*
*
* *******************************
* ** Cost/Decision Functions **
* *******************************
*
*/
/**
* 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)
{
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)
{
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)
{
IdentifierNode qualifier = (IdentifierNode)SemanticUtils.getNthChild(iNode, 0);
IDefinition def = qualifier.resolve(currentScope.getProject());
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 ( SemanticUtils.transformNameToConstantValue(iNode, currentScope.getProject()) != null )
return 1;
else
return Integer.MAX_VALUE;
}
/**
* Check a Binding to decide if its referent
* is statically known to be a Namespace.
* @param b - the Binding to check.
* @return true if the given Binding refers to a namespace.
*/
private boolean isNamespace(Binding b)
{
return b.getDefinition() instanceof NamespaceDefinition;
}
/**
* Check a Binding to see if it's defined as the ANY namespace.
* @param b - the Binding to check.
* @return true if the Binding's definition is the ANY namespace definition.
*/
private boolean isAnyNamespace(Binding b)
{
return b.getDefinition().equals(NamespaceDefinition.getAnyNamespaceReference());
}
/**
* @return a feasible cost (1) if the node is for 'new Array()'
*/
int isEmptyArrayConstructor(IASNode iNode)
{
ICompilerProject project = currentScope.getProject();
IIdentifierNode identifierNode = (IIdentifierNode)SemanticUtils.getNthChild(iNode, 1);
if (identifierNode.resolve(project) == project.getBuiltinType(BuiltinType.ARRAY))
return 1;
return Integer.MAX_VALUE;
}
/**
* @return a feasible cost (1) if the node is for 'new Object()'
*/
int isEmptyObjectConstructor(IASNode iNode)
{
ICompilerProject project = currentScope.getProject();
IIdentifierNode identifierNode = (IIdentifierNode)SemanticUtils.getNthChild(iNode, 1);
if (identifierNode.resolve(project) == project.getBuiltinType(BuiltinType.OBJECT))
return 1;
return Integer.MAX_VALUE;
}
/*
* ************************
* ** Reduction prologues
* ************************
*/
public void prologue_anonymousFunction(IASNode iNode)
{
// TODO: The current scope may not
// need an activation if the anonymous
// function doesn't access any of the
// current scope's locals.
currentScope = currentScope.pushFrame();
currentScope.declareAnonymousFunction();
currentScope.setInitialControlFlowRegionNode(((FunctionObjectNode)iNode).getFunctionNode().getScopedNode());
}
public void prologue_functionObject(IASNode iNode)
{
final FunctionNode innerFunctionNode = ((FunctionObjectNode)iNode).getFunctionNode();
currentScope = currentScope.pushFrame();
currentScope.declareFunctionObject(innerFunctionNode.getName());
currentScope.setInitialControlFlowRegionNode(innerFunctionNode.getScopedNode());
prologue_function(iNode);
}
public void prologue_blockStmt(IASNode iNode)
{
// Note: don't create an InstructionList with
// line number information here; this IL is
// a pure placeholder.
this.miniScopes.push(new InstructionList());
}
public void prologue_blockStmt_to_finally_clause(IASNode iNode)
{
currentScope.getFlowManager().startFinallyContext(iNode);
}
public void prologue_catchBlock(IASNode iNode)
{
currentScope.getFlowManager().startCatchContext((ICatchNode)iNode);
}
private void loop_prologue_common(IASNode loopNode, IASNode loopContents)
{
currentScope.getFlowManager().startLoopControlFlowContext(loopContents);
}
public void prologue_countedForStmt(IASNode iNode)
{
loop_prologue_common(iNode, ((IForLoopNode)iNode).getStatementContentsNode());
}
public void prologue_doStmt(IASNode iNode)
{
loop_prologue_common(iNode, ((IWhileLoopNode)iNode).getStatementContentsNode());
}
public void prologue_forEachStmt(IASNode iNode)
{
loop_prologue_common(iNode, ((IForLoopNode)iNode).getStatementContentsNode());
}
public void prologue_forInStmt(IASNode iNode)
{
loop_prologue_common(iNode, ((IForLoopNode)iNode).getStatementContentsNode());
}
void prologue_function(IASNode n)
{
FunctionDefinition func = null;
IFunctionNode funcNode = null;
if ( n instanceof IFunctionNode )
funcNode = (IFunctionNode)n;
else if( n instanceof FunctionObjectNode )
funcNode = ((FunctionObjectNode)n).getFunctionNode();
// Add any parse problems which might have been encountered while lazily parsing the function
if( funcNode instanceof FunctionNode )
{
Collection<ICompilerProblem> parseProblems = ((FunctionNode) funcNode).getParsingProblems();
for( ICompilerProblem problem : parseProblems )
currentScope.addProblem(problem);
}
assert funcNode != null : n + " has no FunctionNode child";
func = (FunctionDefinition)funcNode.getDefinition();
assert(func != null): n + " has no definition.";
currentScope.setLocalASScope(func.getContainedScope());
currentScope.resetDebugInfo();
// Set the current file name - the function body will always start with an OP_debugfile
// so we never need emit another one unless the method body spans multiple files
currentScope.setDebugFile(SemanticUtils.getFileName(n));
currentScope.getMethodBodySemanticChecker().checkFunctionDefinition(funcNode, func);
for ( int i = 0; i < funcNode.getChildCount(); i++ )
scanFunctionBodyForActivations(funcNode.getChild(i));
}
public void prologue_labeledStmt(IASNode iNode)
{
// Since the Prologue code runs before the subtrees have been reduced,
// we can't get the label string via the non_resolving_identifier reduction.
try
{
currentScope.getFlowManager().startLabeledStatementControlFlowContext((LabeledStatementNode) iNode);
}
catch ( DuplicateLabelException dup_label )
{
currentScope.addProblem(new DuplicateLabelProblem(iNode));
}
}
public void prologue_mxmlEventSpecifier(IASNode iNode)
{
// The method that implements an event specifier has a single parameter.
// Its name is "event" (which is discovered from the ParameterDefinition
// that the event node creates).
// Its type, such as flash.events.MouseEvent, has already been determined
// when we created the MethodInfo, so we access it there
// rather than creatinga another equivalent Name.
currentScope.makeParameter(
getMXMLEventSpecifierContent(iNode).getEventParameterDefinition(),
currentScope.getMethodInfo().getParamTypes().get(0));
}
public void prologue_switchStmt(IASNode iNode)
{
// Establish a switch context so that breaks inside the switch statement will work.
currentScope.getFlowManager().startSwitchContext((SwitchNode)iNode);
}
public void prologue_tryCatchFinallyStmt(IASNode iNode)
{
currentScope.getFlowManager().startExceptionContext((ITryNode) iNode);
currentScope.getFlowManager().getFinallyContext().setHasFinallyBlock(true);
}
public void prologue_tryCatchStmt(IASNode iNode)
{
currentScope.getFlowManager().startExceptionContext((ITryNode) iNode);
}
public void prologue_tryFinallyStmt(IASNode iNode)
{
currentScope.getFlowManager().startExceptionContext((ITryNode) iNode);
currentScope.getFlowManager().getFinallyContext().setHasFinallyBlock(true);
}
public void prologue_typedFunction_to_statement(IASNode iNode)
{
// Note: A named nested function does
// always need an activation record.
currentScope = currentScope.pushFrame();
currentScope.declareNestedFunction();
currentScope.setInitialControlFlowRegionNode(((IFunctionNode)iNode).getScopedNode());
prologue_function(iNode);
}
public void prologue_typelessFunction_to_statement(IASNode iNode)
{
// Note: A named nested function does
// always need an activation record.
currentScope = currentScope.pushFrame();
currentScope.declareNestedFunction();
currentScope.setInitialControlFlowRegionNode(((IFunctionNode)iNode).getScopedNode());
prologue_function(iNode);
}
/**
* Count the number of typeof levels active.
*/
private int typeofCount = 0;
/**
* Before reducing the operands of a typeof,
* we need to increment the typeof counter.
* It will be decremented by the reduction's
* epilogue.
*/
public void prologue_typeof(IASNode iNode)
{
this.typeofCount++;
}
public void prologue_whileStmt(IASNode iNode)
{
currentScope.getFlowManager().startLoopControlFlowContext(((IWhileLoopNode)iNode).getStatementContentsNode());
}
public void prologue_withStmt(IASNode iNode)
{
currentScope.getFlowManager().startWithContext(((IWithNode)iNode).getStatementContentsNode());
}
/*
* *************************
* ** Reduction actions **
* *************************
*/
public InstructionList reduce_anonymousFunction(IASNode iNode, InstructionList function_body)
{
InstructionList result = createInstructionList(iNode, 1);
currentScope.generateNestedFunction(function_body);
result.addInstruction(OP_newfunction, currentScope.getMethodInfo());
currentScope = currentScope.popFrame();
return result;
}
public InstructionList reduce_functionObject(IASNode iNode, IASNode function_name, InstructionList plist, Binding return_binding, InstructionList function_body)
{
InstructionList result = createInstructionList(iNode);
Binding nestedFunctionName = currentScope.resolveName((IdentifierNode)function_name);
Name return_type;
if ( return_binding != null )
return_type = return_binding.getName();
else
return_type = null;
currentScope.generateNestedFunction(generateFunctionBody(iNode, function_body, return_type));
// Pull the nested function's MethodInfo out of its scope before we pop it.
MethodInfo nested_method_info = currentScope.getMethodInfo();
currentScope = currentScope.popFrame();
// Create a wrapper routine that returns the named
// routine wrapped in a closure; it's an anonymous
// function with an activation record.
currentScope = currentScope.pushFrame();
currentScope.declareAnonymousFunction();
currentScope.setInitialControlFlowRegionNode(((FunctionObjectNode)iNode).getFunctionNode().getScopedNode());
currentScope.setNeedsActivation();
currentScope.makeVariable(
nestedFunctionName,
SemanticUtils.getAETName(currentScope.getProject().getBuiltinType(BuiltinType.FUNCTION), currentScope.getProject()),
null, // no meta tags
null, // no initializer
LexicalScope.VariableMutability.Constant
);
InstructionList wrapper_insns = createInstructionList(iNode);
wrapper_insns.addInstruction(OP_newfunction, nested_method_info);
wrapper_insns.addInstruction(OP_dup);
wrapper_insns.addInstruction(OP_findproperty, nestedFunctionName.getName());
wrapper_insns.addInstruction(OP_swap);
wrapper_insns.addInstruction(OP_setslot, 1);
wrapper_insns.addInstruction(OP_returnvalue);
currentScope.generateNestedFunction(generateFunctionBody(iNode, wrapper_insns, LexicalScope.anyType));
MethodInfo wrapper_method_info = currentScope.getMethodInfo();
currentScope = currentScope.popFrame();
result.addInstruction(OP_newfunction, wrapper_method_info);
// Doesn't matter much what we use as "this" --
// the store acts on the activation.
result.addInstruction(OP_getlocal0);
result.addInstruction(OP_call, 0);
return result;
}
public InstructionList reduce_arrayIndexExpr(IASNode iNode, InstructionList stem, boolean is_super, InstructionList index)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)iNode;
if ( is_super )
currentScope.getMethodBodySemanticChecker().checkSuperAccess(arrayIndexNode);
InstructionList result;
if ( !is_super )
{
result = createInstructionList(arrayIndexNode, stem.size() + index.size() + 1);
result.addAll(stem);
}
else
{
result = createInstructionList(arrayIndexNode, index.size() + 2);
// Use "this" as the stem.
result.addInstruction(OP_getlocal0);
}
result.addAll(index);
result.addInstruction(arrayAccess(arrayIndexNode, is_super? OP_getsuper: OP_getproperty));
return result;
}
public InstructionList reduce_arrayLiteral(IASNode iNode, Vector<InstructionList> elements)
{
// No semantic restrictions on array literals.
// TODO: Investigate optimizing.
InstructionList result = createInstructionList(iNode);
for ( InstructionList element: elements )
result.addAll(element);
result.addInstruction(OP_newarray, elements.size());
return result;
}
public InstructionList reduce_assignToBracketExpr_to_expression(IASNode iNode, InstructionList stem, InstructionList index, InstructionList r, boolean is_super)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IBinaryOperatorNode)iNode).getLeftOperandNode();
currentScope.getMethodBodySemanticChecker().checkAssignToBracketExpr(iNode);
Binding local = currentScope.allocateTemp();
InstructionList result = createInstructionList(iNode, (is_super ? 1:stem.size()) + index.size() + r.size() + 5);
if( is_super )
result.addInstruction(OP_getlocal0);
else
result.addAll(stem);
result.addAll(index);
result.addAll(r);
result.addInstruction(OP_dup);
result.addInstruction(local.setlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, is_super ? OP_setsuper : OP_setproperty));
result.addInstruction(local.getlocal() );
currentScope.releaseTemp(local);
return result;
}
public InstructionList reduce_assignToBracketExpr_to_void_expression(IASNode iNode, InstructionList stem, InstructionList index, InstructionList r, boolean is_super)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IBinaryOperatorNode)iNode).getLeftOperandNode();
/*
ITypeDefinition destinationType = arrayIndexNode.resolveType(currentScope.getProject());
IExpressionNode valueNode = ((IBinaryOperatorNode)iNode).getRightOperandNode();
IDefinition type_def = valueNode.resolveType(currentScope.getProject()); //SemanticUtils.getDefinitionOfUnderlyingType(,
// true, currentScope.getProject());
boolean need_coerce = !type_def.equals(destinationType) || (valueNode instanceof TernaryOperatorNode);
*/
currentScope.getMethodBodySemanticChecker().checkAssignToBracketExpr(iNode);
int num_ins = /*need_coerce ? 2 :*/ 1;
InstructionList result = createInstructionList(iNode, (is_super ? num_ins : stem.size()) + index.size() + r.size() + num_ins);
if( is_super )
result.addInstruction(OP_getlocal0);
else
result.addAll(stem);
result.addAll(index);
result.addAll(r);
/*
if (need_coerce)
coerce(result, destinationType);
*/
result.addInstruction(arrayAccess(arrayIndexNode, is_super ? OP_setsuper : OP_setproperty));
return result;
}
public InstructionList reduce_assignToMemberExpr_to_expression(IASNode iNode, InstructionList stem, Binding member, InstructionList r)
{
currentScope.getMethodBodySemanticChecker().checkAssignment(iNode, member);
Binding local = currentScope.allocateTemp();
InstructionList result = createInstructionList(iNode, stem.size() + r.size() + 5);
result.addAll(stem);
result.addAll(r);
result.addInstruction(OP_dup);
result.addInstruction(local.setlocal() );
generateAssignmentOp(iNode, member, result);
result.addInstruction(local.getlocal() );
currentScope.releaseTemp(local);
return result;
}
public InstructionList reduce_assignToMemberExpr_to_void_expression(IASNode iNode, InstructionList stem, Binding member, InstructionList r)
{
currentScope.getMethodBodySemanticChecker().checkAssignment(iNode, member);
InstructionList result = createInstructionList(iNode, stem.size() + r.size() + 1);
result.addAll(stem);
result.addAll(r);
generateAssignmentOp(iNode, member, result);
return result;
}
public InstructionList reduce_assignToDescendantsExpr(IASNode iNode, InstructionList stem, Binding member, InstructionList r, boolean need_value)
{
// Note: This code doesn't assign to descendants!
// While one might think it should, it does in fact
// mirror the bytecode ASC emitted.
currentScope.getMethodBodySemanticChecker().checkAssignment(iNode, member);
Binding local = null;
InstructionList result = createInstructionList(iNode, stem.size() + r.size() + 5);
result.addAll(stem);
result.addAll(r);
if ( need_value )
{
local = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(local.setlocal() );
}
generateAssignmentOp(iNode, member, result);
if ( need_value )
{
result.addInstruction(local.getlocal());
currentScope.releaseTemp(local);
}
return result;
}
public InstructionList reduce_assignToNameExpr_to_void_expression(IASNode iNode, Binding lvalue, InstructionList r)
{
currentScope.getMethodBodySemanticChecker().checkAssignment(iNode, lvalue);
return generateAssignment(iNode, lvalue, r);
}
public InstructionList reduce_assignToNameExpr_to_expression(IASNode iNode, Binding lvalue, InstructionList r)
{
currentScope.getMethodBodySemanticChecker().checkAssignment(iNode, lvalue);
return generateAssignment(iNode, lvalue, r, true);
}
public InstructionList reduce_assignToQualifiedMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, InstructionList rhs, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( !isNamespace(qualifier) )
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
}
// else the qualifier's namespace is already present in the name.
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
generateAssignmentOp(iNode, member, result);
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
return result;
}
public InstructionList reduce_assignToQualifiedRuntimeMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, InstructionList rhs, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( isNamespace(qualifier) )
{
result.addAll(runtime_member_selector);
// Extract the URI from the namespace and use it to construct a qualified name.
NamespaceDefinition ns_def = (NamespaceDefinition)qualifier.getDefinition();
Name qualified_name = new Name(CONSTANT_MultinameL, new Nsset(ns_def.resolveAETNamespace(currentScope.getProject())), null);
result.addAll(rhs);
result.addInstruction(OP_setproperty, qualified_name);
}
else
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addAll(runtime_member_selector);
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(OP_setproperty, new Name(CONSTANT_RTQnameL, null, null));
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
}
return result;
}
public InstructionList reduce_assignToQualifiedAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, InstructionList rhs, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( !isNamespace(qualifier) )
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
}
// else the qualifier's namespace is already present in the name.
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
generateAssignmentOp(iNode, member, result);
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
return result;
}
public InstructionList reduce_assignToQualifiedRuntimeAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, InstructionList rhs, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( isAnyNamespace(qualifier) )
{
IASNode site = qualifier.getNode() != null? qualifier.getNode(): iNode;
currentScope.addProblem(new AnyNamespaceCannotBeQualifierProblem(site));
}
else if ( ! isNamespace(qualifier) )
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addAll(runtime_member_selector);
result.addInstruction(OP_coerce_s);
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(OP_setproperty, new Name(CONSTANT_RTQnameLA, null, null));
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
}
else
{
result.addAll(runtime_member_selector);
// Extract the URI from the namespace and use it to construct a qualified name.
NamespaceDefinition ns_def = (NamespaceDefinition)qualifier.getDefinition();
Name qualified_name = new Name(CONSTANT_MultinameLA, new Nsset(ns_def.resolveAETNamespace(currentScope.getProject())), null);
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(OP_setproperty, qualified_name);
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
}
return result;
}
public InstructionList reduce_assignToRuntimeNameExpr(IASNode iNode, RuntimeMultiname lval, InstructionList r, final boolean need_value)
{
InstructionList result;
if ( need_value )
{
// TODO: In many cases this temp can be avoided by more sophisticated analysis.
// TODO: See also comments in RuntimeMultiname.generateGetOrSet().
Binding temp = currentScope.allocateTemp();
result = createInstructionList(iNode);
result.addAll(r);
result.addInstruction(temp.setlocal());
InstructionList temp_rhs = new InstructionList();
temp_rhs.addInstruction(temp.getlocal());
result.addAll(lval.generateAssignment(iNode, temp_rhs));
result.addInstruction(temp.getlocal());
currentScope.releaseTemp(temp);
}
else
{
result = lval.generateAssignment(iNode, r);
}
return result;
}
public InstructionList reduce_assignToUnqualifiedRuntimeAttributeExpr(IASNode iNode, InstructionList stem, InstructionList rt_attr, InstructionList rhs, boolean need_value)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addAll(rt_attr);
result.addAll(rhs);
Binding value_temp = null;
if ( need_value )
{
value_temp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal());
}
result.addInstruction(OP_setproperty, new Name(CONSTANT_MultinameLA, new Nsset(new Namespace(CONSTANT_PackageNs)), null));
if ( need_value )
{
result.addInstruction(value_temp.getlocal());
currentScope.releaseTemp(value_temp);
}
return result;
}
public Binding reduce_attributeName(IASNode iNode, Binding attr_name)
{
// do nothing - just return the contained name
// which will already be set up correctly for an attribute name
return attr_name;
}
public InstructionList reduce_blockStmt_to_finally_clause(IASNode iNode, Vector<InstructionList> stmts)
{
InstructionList result = createInstructionList(iNode);
for ( InstructionList stmt: stmts )
result.addAll(stmt);
currentScope.getFlowManager().endFinallyContext();
return result;
}
public InstructionList reduce_blockStmt_to_statement(IASNode iNode, Vector<InstructionList> stmts)
{
InstructionList result = createInstructionList(iNode);
result.addAll(this.miniScopes.pop());
for ( InstructionList stmt: stmts )
{
// Some statement-level reductions return null.
if ( stmt != null )
{
result.addAll(stmt);
}
}
return result;
}
public Boolean reduce_booleanLiteral(IASNode iNode)
{
return SemanticUtils.getBooleanContent(iNode);
}
public InstructionList reduce_breakStmt(IASNode iNode)
{
try
{
ControlFlowContextManager.ControlFlowContextSearchCriteria criterion = getBreakCriteria();
return getNonLocalControlFlow(criterion);
}
catch ( UnknownControlFlowTargetException no_target )
{
currentScope.addProblem(new UnknownBreakTargetProblem(iNode));
return createInstructionList(iNode);
}
}
public String reduce_by_concatenation(IASNode iNode, String first, String second)
{
return first + "." + second;
}
public CatchPrototype reduce_catchBlockTyped(IASNode iNode, Binding var_name, Binding exception, InstructionList action)
{
CatchPrototype result = new CatchPrototype();
result.catchVarName = var_name.getName();
result.catchType = exception.getName();
result.catchBody = action;
currentScope.getFlowManager().endCatchContext();
return result;
}
public CatchPrototype reduce_catchBlockUntyped(IASNode iNode, Binding var_name, InstructionList action)
{
CatchPrototype result = new CatchPrototype();
result.catchVarName = var_name.getName();
result.catchType = null;
result.catchBody = action;
currentScope.getFlowManager().endCatchContext();
return result;
}
public InstructionList reduce_commaExpr(IASNode iNode, InstructionList payload_expr, Vector<InstructionList> exprs)
{
// TODO: Investigate optimizing this.
InstructionList result = createInstructionList(iNode);
for ( InstructionList other_expr: exprs )
result.addAll(other_expr);
// The payload expression is the last expression in the
// comma list. It was inverted by IASNodeAdapter into
// the 0th position to work around limitations of the
// BURG's n-ary operand processor.
result.addAll(payload_expr);
return result;
}
public ConditionalFragment reduce_conditionalFragment(IASNode iNode, InstructionList condition, Vector<InstructionList> consequents)
{
return new ConditionalFragment(iNode, condition, consequents);
}
public ConditionalFragment reduce_constantConditionalFragment(IASNode iNode, Object constantCondition, Vector<InstructionList> consequents)
{
return new ConditionalFragment(iNode, constantCondition, consequents);
}
/**
* reduce a concatenation of two strings to a string constant
* @param iNode the node
* @param l the left string
* @param r the right string
* @return the concatenated string
*/
public String reduce_constantStringConcatenation(IASNode iNode, String l, String r)
{
return l + r;
}
/**
* reduce a concatenation of a string and a constant value to a string constant. The constant
* value will be converted to a string according to the ECMA spec, and then will be concatenated with the
* string.
* @param iNode the node
* @param l the left string
* @param r the right value
* @return the concatenated string
*/
public String reduce_constantStringConcatenation(IASNode iNode, String l, Object r)
{
return reduce_constantStringConcatenation(iNode, l, ECMASupport.toString(r));
}
/**
* reduce a concatenation of a constant value and a string to a string constant. The constant
* value will be converted to a string according to the ECMA spec, and then will be concatenated with the
* string.
* @param iNode the node
* @param l the left value
* @param r the right string
* @return the concatenated string
*/
public String reduce_constantStringConcatenation(IASNode iNode, Object l, String r)
{
return reduce_constantStringConcatenation(iNode, ECMASupport.toString(l), r);
}
/**
* reduce addition of two constant values. If either of the constants is a String, then string
* concatenation will be performed. OTherwise the constants will be converted to Numbers, according to the
* ECMA spec, and added
* @param iNode the node
* @param l the left value
* @param r the right value
* @return the result of adding the two values
*/
public Object reduce_constantAddition(IASNode iNode, Object l, Object r)
{
checkBinaryOp(iNode, OP_add);
if( l instanceof String )
return reduce_constantStringConcatenation(iNode, (String)l, r);
else if( r instanceof String )
return reduce_constantStringConcatenation(iNode, l, (String)r);
else
return ECMASupport.toNumeric(l).doubleValue() + ECMASupport.toNumeric(r).doubleValue();
}
public InstructionList reduce_continueStmt(IASNode iNode)
{
try
{
ControlFlowContextManager.ControlFlowContextSearchCriteria criterion = getContinueCriteria();
return getNonLocalControlFlow(criterion);
}
catch ( UnknownControlFlowTargetException no_target )
{
currentScope.addProblem(new UnknownContinueTargetProblem(iNode));
return createInstructionList(iNode);
}
}
public InstructionList reduce_countedForStmt(IASNode iNode, InstructionList init, InstructionList test_insns, InstructionList incr, InstructionList body)
{
InstructionList test_insns_with_debug_ops = ensureInstructionListHasDebugInfo(test_insns, init);
InstructionList result = createInstructionList(iNode, init.size() + test_insns_with_debug_ops.size() + incr.size() + body.size() + 5);
// Initialize counters, jump to test
result.addAll(init);
result.addInstruction(OP_jump, test_insns_with_debug_ops.getLabel());
// Loop body
InstructionList loop_body = new InstructionList();
Label loop_head = new Label();
loop_body.addInstruction(OP_label);
loop_body.labelCurrent(loop_head);
loop_body.addAll(body);
// Set the continue target on the correct instruction.
if ( !incr.isEmpty() )
currentScope.getFlowManager().resolveContinueLabel(incr);
else
currentScope.getFlowManager().resolveContinueLabel(loop_body);
result.addAll(loop_body);
// Now add the loop counter increments.
// The continue context needs to be set
// first for InstructionList hygiene.
result.addAll(incr);
// Add the test; a successful test branches
// back to the loop head. The test generation
// rules guarantee this last instruction is a
// branch instruction that needs a target.
test_insns_with_debug_ops.lastElement().setTarget(loop_head);
result.addAll(test_insns_with_debug_ops);
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
/**
* Check that the dest InstructionList contains debug information. If not, a new InstructionList
* will be returned with the debug information extracted from the src InstructionLevel.
*
* @param dest the InstructionList to ensure has debug information
* @param src the InstructionList from which to obtain debug information if needed
* @return the resulting InstructionList with debug information
*/
private static InstructionList ensureInstructionListHasDebugInfo(final InstructionList dest, final InstructionList src)
{
// the condition has some debug info, so nothing to do here.
if (dest.hasSuchInstruction(OP_debugline))
return dest;
// If we don't have any debug info on the condition IL, get it from the init IL.
String debugFile = null;
int debugLine = LexicalScope.DEBUG_LINE_UNKNOWN;
final ArrayList<Instruction> srcInstructions = src.getInstructions();
for (int i = 0; i < srcInstructions.size(); i++)
{
final Instruction insn = srcInstructions.get(i);
if (insn.getOpcode() == OP_debugfile)
{
debugFile = (String)insn.getOperand(0);
}
else if (insn.getOpcode() == OP_debugline)
{
debugLine = insn.getImmediate();
break;
}
}
InstructionList result = new DebugInfoInstructionList(dest.size() + 2);
if (debugFile != null)
result.addInstruction(OP_debugfile, debugFile);
if (debugLine != LexicalScope.DEBUG_LINE_UNKNOWN)
result.addInstruction(OP_debugline, debugLine);
result.addAll(dest);
return result;
}
public InstructionList reduce_defaultXMLNamespace(IASNode iNode, InstructionList ns_expr)
{
InstructionList result = createInstructionList(iNode);
// TODO: This could be optimized for the string constant case,
// but ASC doesn't do so, which means it's future and probably
// also not well tested in the AVM.
result.addAll(ns_expr);
result.addInstruction(OP_dxnslate);
currentScope.setSetsDxns();
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 InstructionList reduce_deleteBracketExpr(IASNode iNode, InstructionList stem, InstructionList index)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IUnaryOperatorNode)iNode).getOperandNode();
// ASC doesn't check bracket expressions, and it's difficult
// to see what could usefully be done in any case.
// currentScope.getMethodBodySemanticChecker().checkDeleteExpr(iNode);
InstructionList result = createInstructionList(iNode, stem.size() + index.size() + 1);
result.addAll(stem);
result.addAll(index);
result.addInstruction(arrayAccess(arrayIndexNode, OP_deleteproperty));
return result;
}
/**
* 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 InstructionList reduce_deleteAtBracketExpr(IASNode iNode, InstructionList stem, InstructionList index)
{
final InstructionList result = createInstructionList(iNode, stem.size() + index.size() + 1);
result.addAll(stem);
result.addAll(index);
// The namespace is ignored by AVM. We choose to use the default
// namespace at the current scope.
final Namespace ns = NamespaceDefinition
.getDefaultNamespaceDefinition(currentScope.getLocalASScope())
.resolveAETNamespace(currentScope.getProject());
final Name multinameLA = new Name(
CONSTANT_MultinameLA,
new Nsset(ns),
null);
result.addInstruction(OP_deleteproperty, multinameLA);
return result;
}
public InstructionList reduce_deleteDescendantsExpr(IASNode iNode, InstructionList stem, Binding field)
{
// TODO: Investigate semantics of this.
// This special case should get a warning or some indication it's a tautology.
InstructionList result = createInstructionList(iNode, stem.size() + 1);
result.addAll(stem);
result.addInstruction(OP_pop);
result.addInstruction(OP_pushtrue);
return result;
}
public InstructionList reduce_deleteExprExprExpr(IASNode iNode, InstructionList expr)
{
// The expression must be run to allow for side effects.
InstructionList result = createInstructionList(iNode, expr.size() + 2);
result.addInstruction(OP_getlocal0);
result.addAll(expr);
result.addInstruction(arrayAccess(iNode, OP_deleteproperty));
return result;
}
public InstructionList reduce_deleteMemberExpr(IASNode iNode, InstructionList stem, Binding field)
{
currentScope.getMethodBodySemanticChecker().checkDeleteExpr(iNode, field);
InstructionList result = createInstructionList(iNode, stem.size() + 1);
result.addAll(stem);
result.addInstruction(OP_deleteproperty, field.getName());
return result;
}
public InstructionList reduce_deleteRuntimeNameExpr(IASNode iNode, InstructionList stem, RuntimeMultiname rt_name)
{
// TODO: Any relevant semantic checks?
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( rt_name.hasRuntimeQualifier() )
result.addAll(rt_name.getRuntimeQualifier(iNode));
if ( rt_name.hasRuntimeName() )
result.addAll(rt_name.getRuntimeName(iNode));
result.addInstruction(OP_deleteproperty, rt_name.generateName());
return result;
}
public InstructionList reduce_deleteNameExpr(IASNode iNode, Binding n)
{
currentScope.getMethodBodySemanticChecker().checkDeleteExpr(iNode, n);
InstructionList result = createInstructionList(iNode, 2);
result.addAll(currentScope.findProperty(n, false));
result.addInstruction(OP_deleteproperty, n.getName());
return result;
}
public InstructionList reduce_doStmt(IASNode iNode, InstructionList body, InstructionList cond)
{
InstructionList result = createInstructionList(iNode, cond.size() + body.size() + 1);
currentScope.getFlowManager().resolveContinueLabel(cond);
if ( body.isEmpty() || body.firstElement().getOpcode() != OP_label )
result.addInstruction(OP_label);
result.addAll(body);
result.addAll(cond);
result.addInstruction(OP_iftrue, result.getLabel());
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
public InstructionList reduce_e4xFilter(IASNode iNode, InstructionList stem, InstructionList filter)
{
InstructionList result = createInstructionList(iNode);
LexicalScope.Hasnext2Wrapper hasnext = currentScope.hasnext2();
// Cache each value of e.employee.
Binding value_temp = currentScope.allocateTemp();
// Cache the result XMLList.
Binding result_temp = currentScope.allocateTemp();
// Emit the stem expression and cache
// the stem object in a local register.
result.addAll(stem);
result.addInstruction(OP_checkfilter);
result.addInstruction(hasnext.stem_temp.setlocal() );
// Initialize the index register.
result.addInstruction(OP_pushbyte, 0);
result.addInstruction(hasnext.index_temp.setlocal());
// Create the result XMLList.
result.addAll(currentScope.getPropertyValue(xmlListType, currentScope.getProject().getBuiltinType(BuiltinType.XMLLIST)));
result.addInstruction(OP_pushstring, "");
result.addInstruction(OP_construct, 1);
result.addInstruction(result_temp.setlocal());
// Jump to the loop test.
Label test = new Label();
result.addInstruction(OP_jump, test);
// Top of the loop: put an AET Label on
// the ABC OP_Label.
Label loop = new Label();
result.labelNext(loop);
result.addInstruction(OP_label);
// Get the next value and cache it.
result.addInstruction(hasnext.stem_temp.getlocal());
result.addInstruction(hasnext.index_temp.getlocal());
result.addInstruction(OP_nextvalue);
result.addInstruction(OP_dup);
result.addInstruction(value_temp.setlocal() );
// See ECMA-357 11.2.4
result.addInstruction(OP_pushwith);
result.addAll(filter);
Label no_match = new Label();
result.addInstruction(OP_iffalse, no_match);
result.addInstruction(result_temp.getlocal() );
result.addInstruction(hasnext.index_temp.getlocal() );
result.addInstruction(value_temp.getlocal() );
result.addInstruction(arrayAccess(iNode, OP_setproperty));
result.labelNext(no_match);
// See ECMA-357 11.2.4
result.addInstruction(OP_popscope);
result.labelNext(test);
result.addInstruction(hasnext.instruction);
result.addInstruction(OP_iftrue, loop);
result.addInstruction(result_temp.getlocal());
hasnext.release();
currentScope.releaseTemp(value_temp);
currentScope.releaseTemp(result_temp);
return result;
}
public InstructionList reduce_embed(IASNode iNode)
{
String name = "";
try
{
name = ((EmbedNode)iNode).getName(currentScope.getProject(), getProblems());
}
catch (InterruptedException e)
{
throw new CodegenInterruptedException(e);
}
// the parent of an embed node is always a variable
final VariableNode variableNode = (VariableNode)iNode.getParent();
final IVariableDefinition variableDef = (IVariableDefinition)variableNode.getDefinition();
final ITypeDefinition variableType = variableDef.resolveType(currentScope.getProject());
final String typeName = variableType.getQualifiedName();
InstructionList result;
if ("Class".equals(typeName))
{
result = createInstructionList(iNode);
Name embedName = new Name(name);
result.addInstruction(OP_getlex, embedName);
}
else if ("String".equals(typeName))
{
result = createInstructionList(iNode);
result.addInstruction(OP_pushstring, name);
}
else
{
assert false : "this problem should have been caught already at EmbedNode construction time";
result = null;
}
return result;
}
public InstructionList reduce_forKeyValueStmt(IASNode iNode, Binding it, InstructionList base, InstructionList body, int opcode)
{
currentScope.getMethodBodySemanticChecker().checkLValue(iNode, it);
InstructionList result = createInstructionList(iNode, body.size() + base.size() + 15);
ForKeyValueLoopState fkv = new ForKeyValueLoopState();
result.addAll(fkv.generatePrologue(iNode, base));
result.addAll(
generateAssignment(
iNode,
it,
fkv.generateKeyOrValue(opcode)
)
);
result.addAll(body);
result.addAll(fkv.generateEpilogue());
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
/**
* Reduce {@code for(it in base)} or {@code for each(it in base)} loop with
* variable initializer.
*
* @param iNode {@code ForLoopNode}
* @param single_decl Instructions to initialize a loop variable.
* @param base Instructions to create a loop base.
* @param body For loop body instructions.
* @param opcode Use {@code OP_nextname} for "for" loops; use
* {@code OP_nextvalue} for "for each" loops.
* @return Instructions generated for the "for" loop node.
*/
public InstructionList reduce_forVarDeclInStmt(IASNode iNode, InstructionList single_decl, InstructionList base, InstructionList body, int opcode)
{
final InstructionList result = createInstructionList(iNode);
result.addAll(single_decl);
final VariableNode var_node = findIteratorVariable((ForLoopNode)iNode);
final Binding it = currentScope.resolveName((IdentifierNode)var_node.getNameExpressionNode());
currentScope.getMethodBodySemanticChecker().checkLValue(iNode, it);
final ForKeyValueLoopState fkv = new ForKeyValueLoopState();
result.addAll(fkv.generatePrologue(iNode, base));
result.addAll(generateAssignment(iNode, it, fkv.generateKeyOrValue(opcode)));
result.addAll(body);
result.addAll(fkv.generateEpilogue());
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
/**
* Find the iterator {@code VariableNode} in a {@code ForLoopNode}.
*
* <pre>
* for (var it : String = "hello" in array) {...}
* for each (var it : String = "hello" in array) {...}
* </pre>
*
* @param for_loop_node "for" loop node.
* @return {@code VariableNode} of the iterator variable.
*/
private static VariableNode findIteratorVariable(final ForLoopNode for_loop_node)
{
assert for_loop_node != null : "'for' loop node can't be null";
final IASNode conditionalStatement = for_loop_node.getConditionalsContainerNode().getChild(0);
final BinaryOperatorInNode in_node = (BinaryOperatorInNode)conditionalStatement;
final VariableExpressionNode var_expr_node = (VariableExpressionNode)in_node.getLeftOperandNode();
final VariableNode var_node = (VariableNode)var_expr_node.getChild(0);
return var_node;
}
/**
* Reduce statement like:<br>
* {@code for (a[it] in base) body;}
*
* @param iNode Tree node for the for-in loop.
* @param stem Instructions for creating a {@code DynamicAccessNode}.
* @param index Instructions for initializing the index expression.
* @param base Instructions for initializing the base object of the <code>in</code> expression.
* @param body Instructions for initializing the body of the for-loop.
* @param opcode Opcode for <code>nextname</code> or ,code>nextvalue</code> instruction.
* @param is_super Flag indicating whether the stem of the array index expression is <code>super</code>.
* @return Instructions for executing the {@code for-in} statement.
*/
public InstructionList reduce_forKeyValueArrayStmt(IASNode iNode, InstructionList stem, InstructionList index, InstructionList base, InstructionList body, int opcode, boolean is_super)
{
IContainerNode conditionalStatementsNode = ((IForLoopNode)iNode).getConditionalsContainerNode();
IBinaryOperatorNode inNode = (IBinaryOperatorNode)SemanticUtils.getNthChild(conditionalStatementsNode, 0);
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)inNode.getLeftOperandNode();
ForKeyValueLoopState fkv = new ForKeyValueLoopState();
InstructionList result = createInstructionList(iNode, body.size() + base.size() + 15);
result.addAll(fkv.generatePrologue(iNode, base));
if( is_super )
result.addInstruction(OP_getlocal0);
else
result.addAll(stem);
result.addAll(index);
result.addAll(fkv.generateKeyOrValue(opcode));
result.addInstruction(arrayAccess(arrayIndexNode, is_super ? OP_setsuper : OP_setproperty));
result.addAll(body);
result.addAll(fkv.generateEpilogue());
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
public InstructionList reduce_forKeyValueMemberStmt(IASNode iNode, InstructionList stem, Binding member, InstructionList base, InstructionList body, int opcode, boolean is_super)
{
currentScope.getMethodBodySemanticChecker().checkLValue(iNode, member);
ForKeyValueLoopState fkv = new ForKeyValueLoopState();
InstructionList result = createInstructionList(iNode, body.size() + base.size() + 15);
result.addAll(fkv.generatePrologue(iNode, base));
if( is_super )
result.addInstruction(OP_getlocal0);
else
result.addAll(stem);
result.addAll(fkv.generateKeyOrValue(opcode));
generateAssignmentOp(iNode, member, result);
result.addAll(body);
result.addAll(fkv.generateEpilogue());
currentScope.getFlowManager().finishLoopControlFlowContext(result);
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 InstructionList reduce_functionAsBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, Vector<InstructionList> args)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IFunctionCallNode)iNode).getNameNode();
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
result.addAll(index);
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
result.addInstruction(OP_swap);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_call, args.size() ); // note: args.size() is an immediate operand to OP_call
return result;
}
public InstructionList reduce_functionAsMemberExpr(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)
{
// Perform general function call checks and specific member checks
currentScope.getMethodBodySemanticChecker().checkFunctionCall(iNode, method_name, args);
// TODO: Investigate optimizing this.
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
boolean inlined = generateInlineFunctionCall(method_name, result, true, args);
if (!inlined)
{
for (InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_callproperty, new Object[] {method_name.getName(), args.size() } );
}
return result;
}
public InstructionList reduce_functionAsRandomExpr(IASNode iNode, InstructionList random_expr, Vector<InstructionList> args)
{
// TODO: Investigate optimizing this.
InstructionList result = createInstructionList(iNode);
result.addAll(random_expr);
// TODO: currentScope.getThis() or sth similar
result.addInstruction(OP_getlocal0);
for( InstructionList arg: args )
result.addAll(arg);
result.addInstruction(OP_call, args.size());
return result;
}
public InstructionList reduce_functionCallExpr_to_expression(IASNode iNode, Binding method_name, Vector<InstructionList> args)
{
return reduce_functionCall_common(iNode, method_name, args, true);
}
public InstructionList reduce_functionCallExpr_to_void_expression(IASNode iNode, Binding method_name, Vector<InstructionList> args)
{
return reduce_functionCall_common(iNode, method_name, args, false);
}
private InstructionList reduce_functionCall_common(IASNode iNode, Binding method_name, Vector<InstructionList> args, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkFunctionCall(iNode, method_name, args);
InstructionList result = createInstructionList(iNode);
if (method_name.isLocal())
{
result.addInstruction(method_name.getlocal());
result.addInstruction(OP_getlocal0);
for (InstructionList arg : args)
result.addAll(arg);
result.addInstruction(OP_call, args.size());
if (!need_result)
{
result.addInstruction(OP_pop);
}
}
else if ( SemanticUtils.isMethodBinding(method_name.getDefinition()) )
{
// A call to a class' method.
boolean inlined = generateInlineFunctionCall(method_name, result, false, args);
if (!inlined)
{
result.addAll(currentScope.findProperty(method_name, true));
for (InstructionList arg : args)
result.addAll(arg);
int opcode = need_result ? OP_callproperty : OP_callpropvoid;
result.addInstruction(opcode, new Object[] {method_name.getName(), args.size()});
}
}
else if ( method_name.getDefinition() != null )
{
// We're in some context where the method can be found lexically.
assert ( ! method_name.getName().isRuntimeName() );
boolean inlined = generateInlineGetterAccess(method_name, result, false);
if (!inlined)
result.addAll(currentScope.getPropertyValue(method_name));
result.addInstruction(OP_getglobalscope);
for (InstructionList arg : args)
result.addAll(arg);
result.addInstruction(OP_call, args.size());
if ( ! need_result )
result.addInstruction(OP_pop);
}
else
{
// Probably in a with or filter block.
result.addInstruction(OP_findpropstrict, method_name.getName());
for (InstructionList arg : args)
result.addAll(arg);
int opcode = need_result ? OP_callproperty : OP_callpropvoid;
result.addInstruction(opcode, new Object[] {method_name.getName(), args.size()});
}
return result;
}
public InstructionList reduce_functionCallOfSuperclassMethod_to_expression(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkSuperAccess(iNode);
InstructionList result = createInstructionList(iNode);
if ( stem != null )
result.addAll(stem);
else
// Implicit stem is "this".
result.addInstruction(OP_getlocal0);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_callsuper, new Object[] {method_name.getName(), args.size() } );
return result;
}
public InstructionList reduce_functionCallOfSuperclassMethod_to_void_expression(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkSuperAccess(iNode);
InstructionList result = createInstructionList(iNode);
if ( stem != null )
result.addAll(stem);
else
// Implicit stem is "this"
result.addInstruction(OP_getlocal0);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_callsupervoid, new Object[] {method_name.getName(), args.size() } );
return result;
}
public InstructionList reduce_groupedVoidExpression(IASNode iNode, Vector<InstructionList> contents)
{
InstructionList result = createInstructionList(iNode);
for ( InstructionList expr: contents )
result.addAll(expr);
return result;
}
public InstructionList reduce_ifElseIf(IASNode iNode, InstructionList test, InstructionList then, Vector<ConditionalFragment> if_elseif)
{
// need to convert any constant values back
// to a conditional expression when not generating
// a lookup switch.
// TODO: CMP-1762 make use of any constant values to optimize away
// constant if/else ifs.
convertConstantValueConditionsToInstructions(if_elseif);
// TODO: Experiment with optimizing this.
// Iterating twice over the arms of the if
// might cost more than it helps.
InstructionList result = createInstructionList(iNode);
boolean has_else = !if_elseif.isEmpty();
// Label to the "next statement."
Label tail = null;
// TODO: Use conditionalJump style tests.
result.addAll(test);
if ( has_else )
result.addInstruction(OP_iffalse, if_elseif.firstElement().getLabel());
else
tail = addBranch(result, tail, OP_iffalse);
result.addAll(then);
if ( has_else )
{
tail = addInterstitialControlFlow(result, tail);
for ( int i = 0; i < if_elseif.size() - 1; i++ )
{
ConditionalFragment alternative = if_elseif.elementAt(i);
if ( !alternative.isUnconditionalAlternative() )
{
// Add the test and conditional jump to the next alternative.
result.addAll(alternative.condition);
ConditionalFragment next_alternative = if_elseif.elementAt(i+1);
result.addInstruction(OP_iffalse, next_alternative.getLabel());
}
result.addAll(alternative.statement);
tail = addInterstitialControlFlow(result, tail);
}
ConditionalFragment last_clause = if_elseif.lastElement();
if ( !last_clause.isUnconditionalAlternative() )
{
result.addAll(last_clause.condition);
tail = addBranch(result, tail, OP_iffalse);
result.addAll(last_clause.statement);
}
else
{
result.addAll(last_clause.statement);
}
}
if ( tail != null )
result.labelNext(tail);
return result;
}
/**
* Add a branch instruction to an InstructionList.
* @param insns - the InstructionList.
* @param previousLabel - any existing label that targets the jump destination.
* @param opcode - the opcode of the branch (e.g., OP_jump, OP_iffalse, etc.)
* @return a label that targets the jump destination; if previousLabel was
* not null, then previousLabel, otherwise a new Label. The caller is
* responsible for saving this label and applying it appropriately at
* the destination point.
*/
private Label addBranch(InstructionList insns, Label previousLabel, int opcode)
{
Label result = previousLabel != null? previousLabel: new Label();
insns.addInstruction(opcode, result);
return result;
}
/**
* Add jumps from one bit of a control-flow statement to the next,
* if they're necessary.
* @param insns - the InstructionList that's building up the statement.
* @param previousLabel - any existing Label that targets the next part of
* the statement. May be null if this is the first interstitial jump.
* @return previousLabel if previousLabel was not null;
* null if previousLabel was null and no jump is necessary;
* otherwise a new Label that the caller must use to label the next
* part of the statement.
*/
private Label addInterstitialControlFlow(InstructionList insns, Label previousLabel)
{
Label result;
if ( insns.canFallThrough() )
{
result = addBranch(insns, previousLabel, OP_jump);
}
else if ( insns.hasPendingLabels() )
{
// TODO: InstructionList needs a way to "alias"
// labels; with such a facility, this jump could be elided.
result = addBranch(insns, previousLabel, OP_jump);
}
else
{
result = previousLabel;
}
return result;
}
public InstructionList reduce_importDirective(IASNode iNode)
{
currentScope.getMethodBodySemanticChecker().checkImportDirective(((IImportNode)iNode));
return createInstructionList(iNode);
}
public InstructionList reduce_labeledBreakStmt(IASNode iNode)
{
String target = ((IdentifierNode)SemanticUtils.getNthChild(iNode, 0)).getName();
try
{
ControlFlowContextManager.ControlFlowContextSearchCriteria criterion = getBreakCriteria(target);
return getNonLocalControlFlow(criterion);
}
catch ( UnknownControlFlowTargetException no_target )
{
currentScope.addProblem(new UnknownBreakTargetProblem(SemanticUtils.getNthChild(iNode, 0)));
return createInstructionList(iNode);
}
}
public InstructionList reduce_labeledContinueStmt(IASNode iNode)
{
String target = ((IdentifierNode)SemanticUtils.getNthChild(iNode, 0)).getName();
try
{
ControlFlowContextManager.ControlFlowContextSearchCriteria criterion = getContinueCriteria(target);
return getNonLocalControlFlow(criterion);
}
catch ( UnknownControlFlowTargetException no_target )
{
currentScope.addProblem(new UnknownContinueTargetProblem(SemanticUtils.getNthChild(iNode, 0)));
return createInstructionList(iNode);
}
}
public InstructionList reduce_gotoStmt(IASNode iNode)
{
IdentifierNode labelIdentifierNode = (IdentifierNode)SemanticUtils.getNthChild(iNode, 0);
String target = labelIdentifierNode.getName();
try
{
ControlFlowContextManager.ControlFlowContextSearchCriteria criterion = getGotoCriteria(target);
return getNonLocalControlFlow(criterion);
}
catch ( UnknownControlFlowTargetException no_target )
{
Collection<LabeledStatementNode> gotoLabels = currentScope.getFlowManager().getGotoLabels(target);
if (gotoLabels.isEmpty())
currentScope.addProblem(new UnknownGotoTargetProblem(labelIdentifierNode));
else
currentScope.addProblem(new AmbiguousGotoTargetProblem(labelIdentifierNode, gotoLabels));
return createInstructionList(iNode);
}
}
public InstructionList reduce_labeledStmt(IASNode iNode, String label, InstructionList substatement)
{
InstructionList result = createInstructionList(iNode, 1);
Label gotoLabel = currentScope.getFlowManager().getGotoLabel(label);
// Since duplicate labels are invisible to goto statements,
// we can fail to find a goto context for a label.
if (gotoLabel != null)
{
result.labelNext(gotoLabel);
result.addInstruction(OP_label);
}
result.addAll(substatement);
currentScope.getFlowManager().finishLabeledStatementControlFlowContext(result);
return result;
}
public ConditionalFragment reduce_lastElse(IASNode iNode, InstructionList else_clause)
{
return new ConditionalFragment(iNode, null, else_clause);
}
public InstructionList reduce_logicalAndExpr(IASNode iNode, InstructionList l, InstructionList r)
{
InstructionList result = createInstructionList(iNode, l.size() + r.size() + 3);
Label tail = new Label();
result.addAll(l);
result.addInstruction(OP_dup);
result.addInstruction(OP_iffalse, tail);
result.addInstruction(OP_pop);
result.addAll(r);
result.labelNext(tail);
return result;
}
public InstructionList reduce_logicalNotExpr(IASNode iNode, InstructionList expr)
{
InstructionList result = createInstructionList(iNode, expr.size() + 1);
result.addAll(expr);
result.addInstruction(OP_not);
return result;
}
public InstructionList reduce_logicalOrExpr(IASNode iNode, InstructionList l, InstructionList r)
{
InstructionList result = createInstructionList(iNode, l.size() + r.size() + 3);
Label tail = new Label();
result.addAll(l);
result.addInstruction(OP_dup);
result.addInstruction(OP_iftrue, tail);
result.addInstruction(OP_pop);
result.addAll(r);
result.labelNext(tail);
return result;
}
public InstructionList reduce_memberAccessExpr(IASNode iNode, InstructionList stem, Binding member, int opcode)
{
currentScope.getMethodBodySemanticChecker().checkMemberAccess(iNode, member, opcode);
InstructionList result = createInstructionList(iNode, stem.size() + 1);
result.addAll(stem);
boolean inlined = generateInlineGetterAccess(member, result, true);
if (!inlined)
result.addInstruction(opcode, member.getName());
return result;
}
public InstructionList reduce_qualifiedMemberAccessExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, int opcode)
{
currentScope.getMethodBodySemanticChecker().checkMemberAccess(iNode, member, opcode);
InstructionList result = createInstructionList(iNode);
Name member_name = member.getName();
result.addAll(stem);
if ( isNamespace(qualifier) )
{
result.addInstruction(opcode, member_name);
}
else
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addInstruction(opcode, member_name);
}
return result;
}
public InstructionList reduce_qualifiedAttributeRuntimeMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, int opcode)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( isNamespace(qualifier) )
{
result.addAll(runtime_member_selector);
// Extract the URI from the namespace and use it to construct a qualified name.
NamespaceDefinition ns_def = (NamespaceDefinition)qualifier.getDefinition();
Name qualified_name = new Name(CONSTANT_MultinameLA, new Nsset(ns_def.resolveAETNamespace(currentScope.getProject())), null);
result.addInstruction(opcode, qualified_name);
}
else
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addAll(runtime_member_selector);
result.addInstruction(OP_coerce_s);
result.addInstruction(opcode, new Name(CONSTANT_RTQnameLA, null, null));
}
return result;
}
public InstructionList reduce_qualifiedMemberRuntimeNameExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( isNamespace(qualifier) )
{
result.addAll(runtime_member_selector);
// Extract the URI from the namespace and use it to construct a qualified name.
NamespaceDefinition ns_def = (NamespaceDefinition)qualifier.getDefinition();
Name qualified_name = new Name(CONSTANT_MultinameL, new Nsset(ns_def.resolveAETNamespace(currentScope.getProject())), null);
result.addInstruction(OP_getproperty, qualified_name);
}
else
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addAll(runtime_member_selector);
result.addInstruction(OP_coerce_s);
result.addInstruction(OP_getproperty, new Name(CONSTANT_RTQnameL, null, null));
}
return result;
}
public InstructionList reduce_qualifiedAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, int opcode)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
if ( !isNamespace(qualifier) )
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addInstruction(opcode, member.getName());
}
else
{
// the qualifier's namespace is already present in the name.
result.addInstruction(opcode, member.getName());
}
return result;
}
public InstructionList reduce_unqualifiedAttributeExpr(IASNode iNode, InstructionList stem, InstructionList rt_attr, int opcode)
{
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addAll(rt_attr);
result.addInstruction(opcode, new Name(CONSTANT_MultinameLA, new Nsset(new Namespace(CONSTANT_PackageNs)), null));
return result;
}
/**
* 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 InstructionList reduce_runtimeAttributeExp(IASNode iNode, InstructionList rt_attr)
{
InstructionList result = createInstructionList(iNode);
result.addAll(rt_attr);
final Nsset qualifiers = SemanticUtils.getOpenNamespaces(iNode, currentScope.getProject());
result.addInstruction(OP_getproperty, new Name(CONSTANT_MultinameLA, qualifiers, null));
return result;
}
public InstructionList reduce_mxmlEventSpecifier(IASNode iNode, Vector<InstructionList> stmts)
{
// TODO: Investigate optimizing.
InstructionList body = createInstructionList(iNode);
// An MXMLEventSpecifierNode can have N child nodes which are statements.
// We need to codegen all of them as an effective method body.
for ( InstructionList stmt: stmts )
body.addAll(stmt);
return generateFunctionBody(iNode, body, LexicalScope.anyType);
}
public Binding reduce_namespaceAccess(IASNode iNode, IASNode qualifier, Binding qualified_name)
{
currentScope.getMethodBodySemanticChecker().checkQualifier(qualifier);
// All the qualifying syntax nodes are just concrete.
return qualified_name;
}
public RuntimeMultiname reduce_namespaceAccess_to_runtime_name(IASNode iNode, Binding qualified_name)
{
InstructionList qualifier = createInstructionList(iNode);
generateAccess(reduce_simpleName(iNode.getChild(0)), qualifier);
qualifier.addInstruction(OP_coerce, namespaceType);
return new RuntimeMultiname(qualifier, qualified_name.getName());
}
public InstructionList reduce_namespaceAsName_to_expression(IASNode iNode)
{
InstructionList result = createInstructionList(iNode);
Binding b = reduce_simpleName(iNode);
generateAccess(b, result);
result.addInstruction(OP_coerce, namespaceType);
return result;
}
public Name reduce_namespaceAsName_to_multinameL(IASNode iNode)
{
return reduce_namespaceAsName_to_multinameL(iNode, false);
}
public Name reduce_namespaceAsName_to_multinameL(IASNode iNode, final boolean is_attribute)
{
IdentifierNode qualifier = (IdentifierNode)iNode;
NamespaceDefinition ns = (NamespaceDefinition) qualifier.resolve(currentScope.getProject());
int name_kind = is_attribute? CONSTANT_MultinameLA: CONSTANT_MultinameL;
return new Name(name_kind, new Nsset( ns.resolveAETNamespace(currentScope.getProject())), null);
}
public Binding reduce_namespaceAsName_to_name(IASNode iNode)
{
// Note: unresolved namespaces are trapped by a bespoke rule.
return currentScope.resolveName((org.apache.flex.compiler.internal.tree.as.IdentifierNode)iNode);
}
public InstructionList reduce_namespaceDeclaration(IASNode iNode, Binding ns_name)
{
// Get the AET Namespace from the namespace's definition.
NamespaceDefinition def = ((NamespaceNode)iNode).getDefinition();
return reduce_namespaceDeclarationConstantInitializer(iNode, ns_name, def.resolveAETNamespace(currentScope.getProject()));
}
public InstructionList reduce_namespaceDeclarationConstantInitializer(IASNode iNode, Binding ns_name, String uri)
{
// Make a new CONSTANT_Namespace with the given URI - all user defined namespaces initialized with a
// String literal become CONSTANT_Namespaces
return reduce_namespaceDeclarationConstantInitializer(iNode, ns_name, new Namespace(CONSTANT_Namespace, uri));
}
/**
* Does the work for the various reduce_namespaceDecl methods. Creates a new property, with an initial value
* of the Namespace passed in.
*/
public InstructionList reduce_namespaceDeclarationConstantInitializer(IASNode iNode, Binding ns_name, Namespace initializer)
{
currentScope.getMethodBodySemanticChecker().checkNamespaceDeclaration(iNode, ns_name);
NamespaceDefinition def = ((NamespaceNode)iNode).getDefinition();
switch (SemanticUtils.getMultiDefinitionType(def, currentScope.getProject()))
{
case AMBIGUOUS:
currentScope.addProblem(new DuplicateNamespaceDefinitionProblem(iNode));
break;
case NONE:
break;
default:
assert false; // I don't think namespaces can have other type of multiple definitions
}
if( initializer == null )
{
// Can't declare a namespace if we don't know what its initial value is
getProblems().add( new InvalidNamespaceInitializerProblem(iNode) );
return null;
}
currentScope.makeNamespace(ns_name, initializer);
if ( ns_name.isLocal() )
{
// Locals have no initializer, so the variable
// needs explicit initialization code.
currentScope.getHoistedInitInstructions().addInstruction(OP_pushnamespace, initializer);
currentScope.getHoistedInitInstructions().addInstruction(ns_name.setlocal());
}
return null;
}
public InstructionList reduce_namespaceDeclarationInitializer(IASNode iNode, Binding ns_name, Binding second_ns)
{
Namespace ns_init = null;
if ( second_ns.getDefinition() instanceof NamespaceDefinition )
{
NamespaceDefinition ns_def = (NamespaceDefinition)second_ns.getDefinition();
// Grab the AET namespace from the initializer
ns_init = ns_def.resolveAETNamespace(currentScope.getProject());
}
return reduce_namespaceDeclarationConstantInitializer(iNode, ns_name, ns_init);
}
public RuntimeMultiname reduce_namespaceMultinameL(IASNode iNode, IASNode qualifier_node, InstructionList expr)
{
currentScope.getMethodBodySemanticChecker().checkQualifier(qualifier_node);
Name qualifier = reduce_namespaceAsName_to_multinameL(qualifier_node);
return new RuntimeMultiname(qualifier, expr);
}
public RuntimeMultiname reduce_namespaceRTQName(IASNode iNode, InstructionList qualifier, Binding qualified_name)
{
return new RuntimeMultiname(qualifier, qualified_name.getName());
}
public RuntimeMultiname reduce_namespaceRTQNameL(IASNode iNode, InstructionList qualifier, InstructionList expr)
{
return new RuntimeMultiname(qualifier, expr);
}
public InstructionList reduce_neqExpr(IASNode iNode, InstructionList l, InstructionList r)
{
InstructionList result = binaryOp(iNode, l, r, OP_equals);
result.addInstruction(OP_not);
return result;
}
public Binding reduce_nameToTypeName(Binding name, boolean check_name)
{
if ( check_name )
currentScope.getMethodBodySemanticChecker().checkTypeName(name);
return name;
}
public InstructionList reduce_newMemberProperty(IASNode iNode, InstructionList stem, Binding member, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkNewExpr(iNode);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_constructprop, new Object[] { member.getName(), args.size() } );
return result;
}
public InstructionList reduce_newAsRandomExpr(IASNode iNode, InstructionList random_expr, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkNewExpr(iNode);
InstructionList result = createInstructionList(iNode);
result.addAll(random_expr);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_construct, args.size() );
return result;
}
public InstructionList reduce_newEmptyArray(IASNode iNode)
{
// Codegen 'new Array()' efficiently like an array literal
// rather than like a constructor call. That is,
// newarray [0]
// rather than
// findpropstrict :Array
// constructprop :Array, (0)
InstructionList result = createInstructionList(iNode);
result.addInstruction(OP_newarray, 0);
return result;
}
public InstructionList reduce_newEmptyObject(IASNode iNode)
{
// Codegen 'new Object()' efficiently like an object literal
// rather than like a constructor call. That is,
// newobject {0}
// rather than
// findpropstrict :Object
// constructprop :Object, (0)
InstructionList result = createInstructionList(iNode);
result.addInstruction(OP_newobject, 0);
return result;
}
public InstructionList reduce_newExpr(IASNode iNode, Binding class_binding, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkNewExpr(iNode, class_binding, args);
// TODO: Investigate optimizing this.
InstructionList result = createInstructionList(iNode);
Name class_name = class_binding.getName();
if ( class_binding.isLocal() || class_name.isTypeName() )
{
generateAccess(class_binding, result);
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_construct, args.size());
}
else
{
result.addAll(currentScope.findProperty(class_binding, true));
for ( InstructionList arg: args)
result.addAll(arg);
result.addInstruction(OP_constructprop, new Object[] { class_name, args.size() } );
}
return result;
}
public InstructionList reduce_newVectorLiteral(IASNode iNode, InstructionList literal)
{
return literal;
}
public InstructionList reduce_nilExpr_to_conditionalJump(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(InstructionFactory.getTargetableInstruction(OP_jump));
return result;
}
public InstructionList reduce_nilExpr_to_expression(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushundefined);
return result;
}
public Object reduce_nullLiteral_to_constant_value(IASNode iNode)
{
return ABCConstants.NULL_VALUE;
}
public InstructionList reduce_nullLiteral_to_object_literal(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushnull);
return result;
}
public InstructionList reduce_objectLiteral(IASNode iNode, Vector<InstructionList> elements)
{
// TODO: Investigate optimizing.
InstructionList result = createInstructionList(iNode);
for ( InstructionList element: elements )
{
result.addAll(element);
}
result.addInstruction(OP_newobject, elements.size());
return result;
}
public InstructionList reduce_objectLiteralElement(IASNode iNode, InstructionList id, InstructionList value)
{
InstructionList result = createInstructionList(iNode, value.size() + 1);
result.addAll(id);
// TODO: Push type analysis up through the CG,
// so that string constants don't go through
// convert_s. See http://bugs.adobe.com/jira/browse/CMP-118
result.addInstruction(OP_convert_s);
result.addAll(value);
return result;
}
public InstructionList reduce_optionalParameter(IASNode iNode, Name param_name, Binding param_type, Object raw_default_value)
{
IParameterNode parameter_node = (IParameterNode)iNode;
PooledValue transformed_default_value;
// raw_default_value will be null if the parameter's default value was not a constant expression.
if( raw_default_value == null )
{
currentScope.addProblem(new NonConstantParamInitializerProblem(parameter_node.getAssignedValueNode()));
// re-write non-constant expression to undefined, so resulting ABC will pass the verifier.
transformed_default_value = new PooledValue(ABCConstants.UNDEFINED_VALUE);
}
else
{
PooledValue default_value = new PooledValue(raw_default_value);
transformed_default_value =
currentScope.getMethodBodySemanticChecker().checkInitialValue(parameter_node, param_type, default_value);
}
currentScope.makeParameter(getParameterContent(iNode), param_type.getName());
currentScope.addDefaultValue(transformed_default_value);
return null;
}
public Binding reduce_parameterizedName(IASNode iNode, Binding base, Binding param)
{
Name param_name = param.getName();
return new Binding(iNode, new Name(base.getName(), param_name), null);
}
public InstructionList reduce_parameterizedTypeExpression(IASNode iNode, InstructionList base, InstructionList param)
{
InstructionList result = createInstructionList(iNode);
result.addAll(base);
result.addAll(param);
result.addInstruction(OP_applytype, 1);
return result;
}
public InstructionList reduce_plist(IASNode iNode, Vector<InstructionList> pdecl)
{
// Parameter processing is done by side effect
// in the parameter reduction.
return null;
}
public InstructionList reduce_postDecBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IUnaryOperatorNode)iNode).getOperandNode();
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
Binding stem_tmp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(stem_tmp.setlocal() );
result.addAll(index);
result.addInstruction(OP_dup);
// Get the initial value, and dup a copy
// onto the stack as the value of this expression.
Binding index_tmp = currentScope.allocateTemp();
result.addInstruction(index_tmp.setlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_decrement);
Binding result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal() );
result.addInstruction(stem_tmp.getlocal() );
result.addInstruction(index_tmp.getlocal() );
result.addInstruction(result_tmp.getlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
currentScope.releaseTemp(stem_tmp);
currentScope.releaseTemp(index_tmp);
currentScope.releaseTemp(result_tmp);
return result;
}
public InstructionList reduce_postDecMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false, field);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
result.addInstruction(OP_getproperty, field.getName());
result.addInstruction(op_unplus());
// Save a copy of the original value to use as the value of this expression.
Binding orig_tmp = null;
if( need_result )
{
result.addInstruction(OP_dup);
orig_tmp = currentScope.allocateTemp();
result.addInstruction(orig_tmp.setlocal() );
}
result.addInstruction(OP_decrement);
generateAssignmentOp(iNode, field, result);
if( need_result )
{
result.addInstruction(orig_tmp.getlocal() );
currentScope.releaseTemp(orig_tmp);
}
return result;
}
public InstructionList reduce_postDecNameExpr(IASNode iNode, Binding unary, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false, unary);
InstructionList result = createInstructionList(iNode);
if ( unary.isLocal() ) {
ICompilerProject project = currentScope.getProject();
IDefinition inType = SemanticUtils.resolveUnaryExprType(iNode, project);
IDefinition intType = project.getBuiltinType(BuiltinType.INT);
IDefinition numberType = project.getBuiltinType(BuiltinType.NUMBER);
if( inType == intType)
{
// Decrementing a local, typed as int
// we can use declocal_i since we know the result will be stored in an int
if( need_result )
result.addInstruction(unary.getlocal());
result.addInstruction(unary.declocal_i());
}
else if( inType == numberType)
{
// Decrementing a local, typed as Number
// we can use declocal since we know the result will be stored in a Number
if( need_result )
result.addInstruction(unary.getlocal());
result.addInstruction(unary.declocal());
}
else
{
result.addInstruction(unary.getlocal());
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_decrement);
coerce(result, inType);
result.addInstruction(unary.setlocal());
}
}
else
{
Name n = unary.getName();
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_getproperty,n);
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_decrement);
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_swap);
result.addInstruction(OP_setproperty,n);
}
return result;
}
public InstructionList reduce_postIncBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IUnaryOperatorNode)iNode).getOperandNode();
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
Binding stem_tmp = currentScope.allocateTemp();
result.addInstruction(stem_tmp.setlocal() );
result.addAll(index);
result.addInstruction(OP_dup);
// Get the initial value, and dup a copy
// onto the stack as the value of this expression.
Binding index_tmp = currentScope.allocateTemp();
result.addInstruction(index_tmp.setlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_increment);
Binding result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal());
result.addInstruction(stem_tmp.getlocal() );
result.addInstruction(index_tmp.getlocal() );
result.addInstruction(result_tmp.getlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
currentScope.releaseTemp(stem_tmp);
currentScope.releaseTemp(index_tmp);
currentScope.releaseTemp(result_tmp);
return result;
}
public InstructionList reduce_postIncMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true, field);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
result.addInstruction(OP_getproperty, field.getName());
result.addInstruction(op_unplus());
// Save a copy of the original value to use as the value of this expression.
Binding orig_tmp = null;
if( need_result )
{
result.addInstruction(OP_dup);
orig_tmp = currentScope.allocateTemp();
result.addInstruction(orig_tmp.setlocal() );
}
result.addInstruction(OP_increment);
result.addInstruction(OP_setproperty, field.getName());
if( need_result )
{
result.addInstruction(orig_tmp.getlocal() );
currentScope.releaseTemp(orig_tmp);
}
return result;
}
public InstructionList reduce_postIncNameExpr(IASNode iNode, Binding unary, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true, unary);
InstructionList result = createInstructionList(iNode);
if ( unary.isLocal() ) {
ICompilerProject project = currentScope.getProject();
IDefinition inType = SemanticUtils.resolveUnaryExprType(iNode, project);
IDefinition intType = project.getBuiltinType(BuiltinType.INT);
IDefinition numberType = project.getBuiltinType(BuiltinType.NUMBER);
if( inType == intType)
{
// Incrementing a local, typed as int
// we can use inclocal_i since we know the result will be stored in an int
if( need_result )
result.addInstruction(unary.getlocal());
result.addInstruction(unary.inclocal_i());
}
else if( inType == numberType)
{
// Incrementing a local, typed as Number
// we can use inclocal since we know the result will be stored in a Number
if( need_result )
result.addInstruction(unary.getlocal());
result.addInstruction(unary.inclocal());
}
else
{
result.addInstruction(unary.getlocal());
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_increment);
coerce(result, inType);
result.addInstruction(unary.setlocal());
}
}
else
{
Name n = unary.getName();
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_getproperty,n);
result.addInstruction(op_unplus());
if( need_result )
result.addInstruction(OP_dup);
result.addInstruction(OP_increment);
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_swap);
result.addInstruction(OP_setproperty,n);
}
return result;
}
public InstructionList reduce_preDecBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IUnaryOperatorNode)iNode).getOperandNode();
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
Binding stem_tmp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(stem_tmp.setlocal() );
result.addAll(index);
result.addInstruction(OP_dup);
// Get the initial value.
Binding index_tmp = currentScope.allocateTemp();
result.addInstruction(index_tmp.setlocal());
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
// Increment, and dup a copy onto
// the stack as the value of this expression.
result.addInstruction(OP_decrement);
if( need_result )
result.addInstruction(OP_dup);
Binding result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal());
result.addInstruction(stem_tmp.getlocal() );
result.addInstruction(index_tmp.getlocal() );
result.addInstruction(result_tmp.getlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
currentScope.releaseTemp(stem_tmp);
currentScope.releaseTemp(index_tmp);
currentScope.releaseTemp(result_tmp);
return result;
}
public InstructionList reduce_preDecMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false, field);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
result.addInstruction(OP_getproperty, field.getName());
result.addInstruction(OP_decrement);
Binding result_tmp = null;
// Save a copy of the result to use as the value of this expression.
if( need_result )
{
result.addInstruction(OP_dup);
result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal() );
}
result.addInstruction(OP_setproperty, field.getName());
if( need_result )
{
result.addInstruction(result_tmp.getlocal() );
currentScope.releaseTemp(result_tmp);
}
return result;
}
public InstructionList reduce_preDecNameExpr(IASNode iNode, Binding unary, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, false, unary);
InstructionList result = createInstructionList(iNode);
if ( unary.isLocal() ) {
ICompilerProject project = currentScope.getProject();
IDefinition inType = SemanticUtils.resolveUnaryExprType(iNode, project);
IDefinition intType = project.getBuiltinType(BuiltinType.INT);
IDefinition numberType = project.getBuiltinType(BuiltinType.NUMBER);
if( inType == intType)
{
// Decrementing a local, typed as int
// we can use declocal_i since we know the result will be stored in an int
result.addInstruction(unary.declocal_i());
if( need_result )
result.addInstruction(unary.getlocal());
}
else if( inType == numberType)
{
// Decrementing a local, typed as Number
// we can use declocal since we know the result will be stored in a Number
result.addInstruction(unary.declocal());
if( need_result )
result.addInstruction(unary.getlocal());
}
else
{
result.addInstruction(unary.getlocal());
result.addInstruction(OP_decrement);
if( need_result )
result.addInstruction(OP_dup);
coerce(result, inType);
result.addInstruction(unary.setlocal());
}
}
else
{
Name n = unary.getName();
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_getproperty,n);
result.addInstruction(OP_decrement);
if( need_result )
result.addInstruction(OP_dup);
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_swap);
result.addInstruction(OP_setproperty,n);
}
return result;
}
public InstructionList reduce_preIncBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)((IUnaryOperatorNode)iNode).getOperandNode();
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
Binding stem_tmp = currentScope.allocateTemp();
result.addInstruction(OP_dup);
result.addInstruction(stem_tmp.setlocal() );
result.addAll(index);
result.addInstruction(OP_dup);
// Get the initial value.
Binding index_tmp = currentScope.allocateTemp();
result.addInstruction(index_tmp.setlocal() );
result.addInstruction(arrayAccess(arrayIndexNode, OP_getproperty));
// Increment, and dup a copy onto
// the stack as the value of this expression.
result.addInstruction(OP_increment);
if( need_result )
result.addInstruction(OP_dup);
Binding result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal() );
result.addInstruction(stem_tmp.getlocal() );
result.addInstruction(index_tmp.getlocal());
result.addInstruction(result_tmp.getlocal());
result.addInstruction(arrayAccess(arrayIndexNode, OP_setproperty));
currentScope.releaseTemp(stem_tmp);
currentScope.releaseTemp(index_tmp);
currentScope.releaseTemp(result_tmp);
return result;
}
public InstructionList reduce_preIncMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true, field);
InstructionList result = createInstructionList(iNode);
result.addAll(stem);
result.addInstruction(OP_dup);
result.addInstruction(OP_getproperty, field.getName());
result.addInstruction(OP_increment);
Binding result_tmp = null;
// Save a copy of the result to use as the value of this expression.
if( need_result )
{
result.addInstruction(OP_dup);
result_tmp = currentScope.allocateTemp();
result.addInstruction(result_tmp.setlocal());
}
result.addInstruction(OP_setproperty, field.getName());
if( need_result )
{
result.addInstruction(result_tmp.getlocal());
currentScope.releaseTemp(result_tmp);
}
return result;
}
public InstructionList reduce_preIncNameExpr(IASNode iNode, Binding unary, boolean need_result)
{
currentScope.getMethodBodySemanticChecker().checkIncDec(iNode, true, unary);
InstructionList result = createInstructionList(iNode);
if ( unary.isLocal() ) {
ICompilerProject project = currentScope.getProject();
IDefinition inType = SemanticUtils.resolveUnaryExprType(iNode, project);
IDefinition intType = project.getBuiltinType(BuiltinType.INT);
IDefinition numberType = project.getBuiltinType(BuiltinType.NUMBER);
if( inType == intType)
{
// Incrementing a local, typed as int
// we can use inclocal_i since we know the result will be stored in an int
result.addInstruction(unary.inclocal_i());
if( need_result )
result.addInstruction(unary.getlocal());
}
else if( inType == numberType)
{
// Incrementing a local, typed as Number
// we can use inclocal since we know the result will be stored in a Number
result.addInstruction(unary.inclocal());
if( need_result )
result.addInstruction(unary.getlocal());
}
else
{
result.addInstruction(unary.getlocal());
result.addInstruction(OP_increment);
if( need_result )
result.addInstruction(OP_dup);
coerce(result, inType);
result.addInstruction(unary.setlocal());
}
}
else
{
Name n = unary.getName();
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_getproperty,n);
result.addInstruction(OP_increment);
if( need_result )
result.addInstruction(OP_dup);
result.addAll(currentScope.findProperty(unary, true));
result.addInstruction(OP_swap);
result.addInstruction(OP_setproperty,n);
}
return result;
}
/**
* Add instructions to the instructionlist passed in to coerce the top value of the stack
* to the given type.
*
* This will generate a generic OP_coerce, or one of the more specific coercion/conversion opcodes
* such as convert_d for Number, coerce_s for String, etc.
*
* Matches ASCs behavior.
*
* @param il the InstructionList to add the instruction to
* @param toType the type you want to coerce the top stack value to
*/
public void coerce(InstructionList il, IDefinition toType )
{
if ( toType == null )
return;
assert toType instanceof ITypeDefinition;
ICompilerProject project = currentScope.getProject();
if( toType == project.getBuiltinType(BuiltinType.ANY_TYPE) )
{
il.addInstruction(OP_coerce_a);
}
else if ( toType == project.getBuiltinType(BuiltinType.STRING) )
{
il.addInstruction(OP_coerce_s);
}
else if ( toType == project.getBuiltinType(BuiltinType.BOOLEAN) )
{
il.addInstruction(OP_convert_b);
}
else if( toType == project.getBuiltinType(BuiltinType.NUMBER) )
{
il.addInstruction(OP_convert_d);
}
else if( toType == project.getBuiltinType(BuiltinType.INT) )
{
il.addInstruction(OP_convert_i);
}
else if( toType == project.getBuiltinType(BuiltinType.UINT) )
{
il.addInstruction(OP_convert_u);
}
else
{
il.addInstruction(OP_coerce, ((DefinitionBase)toType).getMName(project));
}
}
public InstructionList reduce_regexLiteral(IASNode iNode)
{
String flags = ((RegExpLiteralNode) iNode).getFlagString();
// If flags are defined, additional pushstring instruction is needed
InstructionList result = createInstructionList(iNode, (flags.isEmpty()) ? 4 : 5);
result.addAll(currentScope.getPropertyValue(regexType, currentScope.getProject().getBuiltinType(BuiltinType.REGEXP)));
result.addInstruction(OP_pushstring, getStringLiteralContent(iNode));
if (!flags.isEmpty())
{
result.addInstruction(OP_pushstring, flags);
result.addInstruction(OP_construct, 2);
}
else
{
result.addInstruction(OP_construct, 1);
}
return result;
}
public InstructionList reduce_requiredParameter(IASNode iNode, Name param_name, Binding param_type)
{
currentScope.makeParameter(getParameterContent(iNode), param_type.getName());
return null;
}
public InstructionList reduce_restParameter(IASNode iNode, Name param_name, Binding param_type)
{
currentScope.getMethodBodySemanticChecker().checkRestParameter(iNode, param_type);
currentScope.makeParameter(getParameterContent(iNode), param_type.getName());
return null;
}
public InstructionList reduce_returnVoidSideEffect(IASNode iNode, InstructionList value)
{
currentScope.getMethodBodySemanticChecker().checkReturnValue(iNode);
// Evaluate the expression for possible side effects.
InstructionList result = createInstructionList(iNode);
result.addAll(value);
result.addInstruction(OP_returnvoid);
return result;
}
public InstructionList reduce_returnValue(IASNode iNode, InstructionList value)
{
currentScope.getMethodBodySemanticChecker().checkReturnValue(iNode);
return reduce_returnWithSideEffects(iNode, value, OP_returnvalue);
}
public InstructionList reduce_returnVoidValue(IASNode iNode, InstructionList no_value)
{
currentScope.getMethodBodySemanticChecker().checkReturnVoid(iNode);
return reduce_returnWithSideEffects(iNode, no_value, OP_returnvoid);
}
/**
* Reduce a return statement that may have side effects
* (either mutation or reading volatile state).
* @param iNode - the root IASNode of the return statement.
* @param value - the value to be returned, or just computed.
* @param opcode - OP_returnvalue or OP_returnvoid.
*/
private InstructionList reduce_returnWithSideEffects(IASNode iNode, InstructionList value, int opcode)
{
// Create two InstructionLists; the first, result list
// goes in the body of the try block. It computes the
// result value and stores it in a temp -- this allows
// the control-flow unwinding code to pop scopes, etc.,
// with no effect on the AS3 program's observable computation.
// The second IL is a control-flow stub that fetches the
// return value from the temp and returns it; this stub
// goes to the control-flow manager to be massaged into
// the control-flow unwinding code required by the current
// control flow contexts, if any.
// HOWEVER: as an optimization, the temp and the stub IL
// are only used when the flow manager says they're needed.
InstructionList result = createInstructionList(iNode);
result.addAll(value);
Binding result_temp = null;
boolean need_temp = currentScope.getFlowManager().hasNontrivialFlowCharacteristics();
if ( need_temp )
{
result_temp = currentScope.allocateTemp();
result.addInstruction(result_temp.setlocal());
}
InstructionList controlFlowStub = null;
FunctionDefinition function_def = SemanticUtils.getFunctionDefinition(iNode);
if ( need_temp )
{
controlFlowStub = createInstructionList(iNode);
controlFlowStub.addInstruction(result_temp.getlocal());
addRelevantReturnOpcode(function_def, opcode, controlFlowStub);
}
else
{
addRelevantReturnOpcode(function_def, opcode, result);
}
try
{
if ( need_temp )
{
// The controlFlowStub may be replaced by code that
// branches to some context unwinding.
result.addAll(getNonLocalControlFlow(controlFlowStub, ControlFlowContextManager.FIND_ALL_CONTEXTS));
}
else
{
// Ensure we get back the same IL as sent in,
// or the ABC will be incorrect.
InstructionList prev_result = result;
result = getNonLocalControlFlow(result, ControlFlowContextManager.FIND_ALL_CONTEXTS);
assert result == prev_result;
}
}
catch ( UnknownControlFlowTargetException cant_return )
{
currentScope.addProblem(new UnexpectedReturnProblem(iNode));
return createInstructionList(iNode);
}
return result;
}
public InstructionList reduce_returnVoid(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
currentScope.getMethodBodySemanticChecker().checkReturnVoid(iNode);
FunctionDefinition functionDef = SemanticUtils.getFunctionDefinition(iNode);
addRelevantReturnOpcode(functionDef, OP_returnvoid, result);
try
{
return getNonLocalControlFlow(result, ControlFlowContextManager.FIND_ALL_CONTEXTS);
}
catch ( UnknownControlFlowTargetException cant_return )
{
currentScope.addProblem(new UnexpectedReturnProblem(iNode));
return createInstructionList(iNode);
}
}
/**
* When inlining a method, a jump opcode must be emitted rather than a return
*
* @param functionDef the function definition from which we're returning
* @param opcode the original opcode which may be translated when inlining a function
* @param result the InstructionList onto which the instruction will be added
*/
private void addRelevantReturnOpcode(FunctionDefinition functionDef, int opcode, InstructionList result)
{
if (currentScope.insideInlineFunction())
{
Label inlinedFunctionCallSiteLabel = ((InlineFunctionLexicalScope)currentScope).getInlinedFunctionCallSiteLabel();
switch (opcode)
{
case OP_returnvoid:
{
// returnvoid pushes undefined onto the stack, so mimic that behavior
result.addInstruction(OP_pushundefined);
// if the function returns a type, undefined is coerced to that type
if (functionDef != null)
{
TypeDefinitionBase returnType = (TypeDefinitionBase)functionDef.resolveReturnType(currentScope.getProject());
if (returnType != null &&
!returnType.equals(ClassDefinition.getVoidClassDefinition()) &&
!returnType.equals(ClassDefinition.getAnyTypeClassDefinition()))
{
result.addInstruction(OP_coerce, returnType.getMName(currentScope.getProject()));
}
}
result.addInstruction(OP_jump, inlinedFunctionCallSiteLabel);
break;
}
case OP_returnvalue:
result.addInstruction(OP_jump, inlinedFunctionCallSiteLabel);
break;
default:
result.addInstruction(opcode);
}
}
else
{
result.addInstruction(opcode);
}
}
public InstructionList reduce_runtimeNameExpression(IASNode iNode, InstructionList expr)
{
return expr;
}
public Binding reduce_simpleName(IASNode iNode)
{
final Binding result;
final IdentifierNode identifier = (IdentifierNode)iNode;
if (identifier.getName().equals(IASLanguageConstants.ANY_TYPE) && SemanticUtils.isE4XWildcardProperty(identifier))
{
// TODO: This is a specific fix for CMP-1731. CMP-696 should be able
// to cover this use case in a more generic and robust way. Revisit
// this implementation when CMP-696 is fixed.
final ICompilerProject project = currentScope.getProject();
final Nsset qualifiers = SemanticUtils.getOpenNamespaces(iNode, project);
final Name name = new Name(CONSTANT_Multiname, qualifiers, null);
result = new Binding(iNode, name, identifier.resolve(project));
}
else
{
result = currentScope.resolveName(identifier);
currentScope.getMethodBodySemanticChecker().checkSimpleName(iNode, result);
}
return result;
}
public Name reduce_declName(IASNode iNode )
{
// We are the name of a declaration, get the containing DefinitionNode and grab the
// name from there
BaseDefinitionNode bdn = (BaseDefinitionNode)iNode.getAncestorOfType(BaseDefinitionNode.class);
DefinitionBase db = bdn.getDefinition();
Name n = db.getMName(currentScope.getProject());
return n;
}
public InstructionList reduce_strictneqExpr(IASNode iNode, InstructionList l, InstructionList r)
{
InstructionList result = binaryOp(iNode, l, r, OP_strictequals);
result.addInstruction(OP_not);
return result;
}
public Binding reduce_superAccess(IASNode iNode, Binding qualified_name)
{
currentScope.getMethodBodySemanticChecker().checkSuperAccess(iNode);
qualified_name.setSuperQualified(true);
return qualified_name;
}
public InstructionList reduce_superCallExpr(IASNode iNode, Vector<InstructionList> args)
{
currentScope.getMethodBodySemanticChecker().checkExplicitSuperCall(iNode, args);
// TODO: Investigate optimizing this.
InstructionList result = createInstructionList(iNode);
// Special case first part: don't look for the "super" name,
// push "this" on the stack.
result.addInstruction(OP_getlocal0);
for ( InstructionList arg: args)
result.addAll(arg);
// Special case second part: call constructsuper.
result.addInstruction(OP_constructsuper, args.size() );
return result;
}
private static class LookupSwitchInfo
{
public int minCase = Integer.MAX_VALUE;
public int maxCase = Integer.MIN_VALUE;
public ConditionalFragment defaultCase;
}
public InstructionList reduce_switchStmt(IASNode iNode, InstructionList switch_expr, Vector<ConditionalFragment> cases)
{
if (cases.size() == 0)
{
return reduce_trivial_switchStmt(iNode, switch_expr);
}
else
{
IExpressionNode conditional = ((SwitchNode)iNode).getConditionalNode();
LookupSwitchInfo lookupSwitchInfo = getLookupSwitchInfo(conditional, cases);
if (lookupSwitchInfo != null)
return reduce_lookup_switchStmt(iNode, switch_expr, cases, lookupSwitchInfo);
else
return reduce_ifelse_switchStmt(iNode, switch_expr, cases);
}
}
/**
* Inspect the switch cases to determine if a lookup switch can be used. Any criteria
* for using a lookup switch or if/else chain should be adjusted here.
*
* @param conditional
* @param cases
* @return LookupSwitchInfo if a lookup switch can be used, otherwise null
*/
private LookupSwitchInfo getLookupSwitchInfo(IExpressionNode conditional, Vector<ConditionalFragment> cases)
{
// only generate a lookup switch if the conditional type is of type int or uint
IDefinition conditionalType = conditional.resolveType(currentScope.getProject());
if (!SemanticUtils.isBuiltin(conditionalType, BuiltinType.INT, currentScope.getProject()) &&
!SemanticUtils.isBuiltin(conditionalType, BuiltinType.UINT, currentScope.getProject()))
return null;
LookupSwitchInfo lookupSwitchInfo = new LookupSwitchInfo();
boolean hasConditionalCases = false;
for (ConditionalFragment currentCase : cases)
{
if (currentCase.isUnconditionalAlternative())
{
lookupSwitchInfo.defaultCase = currentCase;
continue;
}
if (currentCase.constantCondition == null)
return null;
assert (SemanticUtils.isBuiltin(conditionalType, BuiltinType.INT, currentScope.getProject()) ||
SemanticUtils.isBuiltin(conditionalType, BuiltinType.UINT, currentScope.getProject())) : "only switching on type int or uint supported";
long value;
if (SemanticUtils.isBuiltin(conditionalType, BuiltinType.UINT, currentScope.getProject()))
value = ECMASupport.toUInt32(currentCase.constantCondition);
else
value = ECMASupport.toInt32(currentCase.constantCondition);
// We could potentially use longs here, but for now just fallback to an if/else
// jump in the case where a value is outside the integeger range unless we find
// real world code where it makes sense to handle longs too.
if (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE)
return null;
lookupSwitchInfo.minCase = Math.min((int)value, lookupSwitchInfo.minCase);
lookupSwitchInfo.maxCase = Math.max((int)value, lookupSwitchInfo.maxCase);
hasConditionalCases = true;
}
// if there are no conditional cases, don't generate lookup switch
if (!hasConditionalCases)
return null;
int range = lookupSwitchInfo.maxCase - lookupSwitchInfo.minCase;
// if the range is greater than 20 and if less than 50% ranges dense, then use if/else
if ((range > 20) && (range < cases.size() * 2))
return null;
// limit the size of the jump table to cut down on compile time
// memory building up the table, and avoid any potential player
// bugs with massive lookup switches
if (range > (2 ^ 16))
return null;
return lookupSwitchInfo;
}
private InstructionList reduce_lookup_switchStmt(IASNode iNode, InstructionList switch_expr, Vector<ConditionalFragment> cases, LookupSwitchInfo lookupSwitchInfo)
{
InstructionList result = createInstructionList(iNode);
result.addAll(switch_expr);
result.addInstruction(OP_convert_i);
// save some space in the case table, by not generating entries
// for any values between 0 and the min case value
int caseOffset = 0;
if (lookupSwitchInfo.minCase > 0)
{
caseOffset = lookupSwitchInfo.minCase;
lookupSwitchInfo.minCase = 0;
lookupSwitchInfo.maxCase = lookupSwitchInfo.maxCase - caseOffset;
result.addInstruction(OP_pushint, Integer.valueOf(caseOffset));
result.addInstruction(OP_subtract_i);
}
// if we have negative values in the case expression, need
// to offset from zero
else if (lookupSwitchInfo.minCase < 0)
{
caseOffset = lookupSwitchInfo.minCase;
lookupSwitchInfo.minCase = 0;
lookupSwitchInfo.maxCase = lookupSwitchInfo.maxCase - caseOffset;
result.addInstruction(OP_pushint, new Integer(lookupSwitchInfo.minCase + 1));
result.addInstruction(OP_add_i);
}
Label switchTail = null;
Label defaultLabel;
if (lookupSwitchInfo.defaultCase != null)
defaultLabel = lookupSwitchInfo.defaultCase.getLabel();
else
defaultLabel = switchTail = new Label();
// generate the case table, maxCase+2, as count from zero
// and add one for the default label at the end
Label[] caseLabels = new Label[lookupSwitchInfo.maxCase + 2];
// pre-fill the case label table with the default label.
Arrays.fill(caseLabels, defaultLabel);
// fill in specific labels for any specified values
for (ConditionalFragment current_case : cases)
{
if (current_case.isUnconditionalAlternative())
continue;
Object caseValue = current_case.constantCondition;
// a constant of value 90000 was in a SWC as a double even though
// the type of the constant was int
if (caseValue instanceof Double)
caseValue = new Integer(((Double)caseValue).intValue());
assert (caseValue instanceof Integer) : "reduce_lookup_switchStmt called on non integer case value";
final int index = (Integer)caseValue - caseOffset;
// if there is already a non-default value for this
// index, ignore it, as only the first case counts
if (caseLabels[index] != defaultLabel)
continue;
caseLabels[index] = current_case.getLabel();
}
result.addInstruction(OP_lookupswitch, caseLabels);
Label default_case_label = null;
for (ConditionalFragment current_case : cases)
{
if (current_case.isUnconditionalAlternative())
{
// The parser rejects duplicate default alternatives
// in some situations, but not in others.
if (default_case_label == null)
default_case_label = current_case.statement.getLabel();
else
currentScope.addProblem(new MultipleSwitchDefaultsProblem(current_case.site));
}
result.addAll(current_case.statement);
}
switchTail = addInterstitialControlFlow(result, switchTail);
// No continue here, and thus there is no need
// to check for previous labeled flow contexts.
currentScope.getFlowManager().finishSwitchControlFlowContext(result);
if ( switchTail != null )
result.labelNext(switchTail);
return result;
}
private InstructionList reduce_ifelse_switchStmt(IASNode iNode, InstructionList switch_expr, Vector<ConditionalFragment> cases)
{
assert (cases.size() > 0) : "reduce_ifelse_switchStmt called on switch stmt with no cases";
// need to convert any constant values back
// to a conditional expression when not generating
// a lookup switch
convertConstantValueConditionsToInstructions(cases);
// TODO: Optimize InstructionList size.
InstructionList result = createInstructionList(iNode);
Label default_case_label = null;
Label switch_tail = null;
// Get the switch value and save it in a temp.
Binding switch_temp = currentScope.allocateTemp();
result.addAll(switch_expr);
result.addInstruction(switch_temp.setlocal());
// First, jump to the switch table.
if ( ! cases.elementAt(0).isUnconditionalAlternative() || cases.size() == 1 )
result.addInstruction(OP_jump, cases.elementAt(0).getLabel());
else
result.addInstruction(OP_jump, cases.elementAt(1).getLabel());
for ( ConditionalFragment current_case: cases )
{
// Ensure the case begins with a OP_label instruction
// so we can branch back to it.
if ( current_case.statement.isEmpty() || current_case.statement.firstElement().getOpcode() != OP_label )
{
InstructionList labeled_list = createInstructionList(iNode);
labeled_list.addInstruction(OP_label);
labeled_list.addAll(current_case.statement);
current_case.statement = labeled_list;
}
if ( current_case.isUnconditionalAlternative() )
{
// The parser rejects duplicate default alternatives
// in some situations, but not in others.
if ( default_case_label == null )
default_case_label = current_case.statement.getLabel();
else
currentScope.addProblem(new MultipleSwitchDefaultsProblem(current_case.site));
}
// no need to check for duplicate cases, as the first case is always chosen in this situation
current_case.getStatementLabel(); // Touch the label so it will be properly recorded.
result.addAll(current_case.statement);
}
// Jump to the tail.
switch_tail = addInterstitialControlFlow(result, null);
// Emit the "switch table" as if/else statements.
for ( ConditionalFragment current_case: cases )
{
if ( !current_case.isUnconditionalAlternative() )
{
result.addAll(current_case.condition);
result.addInstruction(switch_temp.getlocal());
result.addInstruction(OP_ifstricteq, current_case.getStatementLabel() );
}
}
// Emit the jump to the default case.
if ( default_case_label != null )
{
result.addInstruction(OP_jump, default_case_label);
}
currentScope.releaseTemp(switch_temp);
// No continue here, and thus there is no need
// to check for previous labeled flow contexts.
currentScope.getFlowManager().finishSwitchControlFlowContext(result);
if ( switch_tail != null )
result.labelNext(switch_tail);
return result;
}
private InstructionList reduce_trivial_switchStmt(IASNode iNode, InstructionList switch_expr)
{
InstructionList result = createInstructionList(iNode);
result.addAll(switch_expr);
// Balance the stack!
result.addInstruction(OP_pop);
currentScope.getFlowManager().finishSwitchControlFlowContext(result);
return result;
}
/**
* If the optimized constant case of conditional fragements are not being used, need to go through
* all cases and convert any constant conditionals back to a conditional instruction list for codegen.
*
* @param cases
*/
private void convertConstantValueConditionsToInstructions(Vector<ConditionalFragment> cases)
{
for (ConditionalFragment current_case : cases)
{
current_case.convertConstantConditionToInstruction();
if (current_case.isConstantConditional())
{
current_case.condition = transform_constant_value(current_case.site, current_case.constantCondition);
}
}
}
public InstructionList reduce_ternaryExpr(IASNode iNode, InstructionList test, InstructionList when_true, InstructionList when_false)
{
// AIR (and not FlashPlayer) requires a coerce_a at the end of each clause if the results will be
// assigned to a Dictionary.
IBinaryOperatorNode binaryNode = (IBinaryOperatorNode)iNode.getAncestorOfType(IBinaryOperatorNode.class);
boolean isBracketAssign = binaryNode != null && binaryNode.getOperator() == OperatorType.ASSIGNMENT
&& binaryNode.getLeftOperandNode() instanceof DynamicAccessNode;
ITypeDefinition destinationType = null;
if (isBracketAssign)
destinationType = binaryNode.getLeftOperandNode().resolveType(currentScope.getProject());
TernaryOperatorNode ternaryNode = (TernaryOperatorNode)iNode;
IExpressionNode valueNode;
IDefinition type_def; //= valueNode.resolveType(currentScope.getProject()); //SemanticUtils.getDefinitionOfUnderlyingType(,
// true, currentScope.getProject());
boolean need_coerce = false;
InstructionList result = createInstructionList(iNode, test.size() + when_true.size() + when_false.size() + 2);
Label tail = new Label();
result.addAll(test);
result.addInstruction(OP_iffalse, when_false.getLabel());
result.addAll(when_true);
valueNode = ternaryNode.getLeftOperandNode();
type_def = valueNode.resolveType(currentScope.getProject());
need_coerce = type_def != null && !type_def.equals(destinationType);
if (need_coerce && isBracketAssign)
coerce(result, destinationType);
result.addInstruction(OP_jump, tail);
result.addAll(when_false);
valueNode = ternaryNode.getRightOperandNode();
type_def = valueNode.resolveType(currentScope.getProject());
need_coerce = type_def != null && !type_def.equals(destinationType);
if (need_coerce && isBracketAssign)
coerce(result, destinationType);
result.labelNext(tail);
return result;
}
public InstructionList reduce_throwStmt(IASNode iNode, InstructionList tossable)
{
currentScope.getMethodBodySemanticChecker().checkThrow(iNode);
InstructionList result = createInstructionList(iNode, tossable.size() + 1);
result.addAll(tossable);
result.addInstruction(OP_throw);
return result;
}
public InstructionList reduce_tryCatchFinallyStmt(IASNode iNode, InstructionList try_stmt, InstructionList finally_stmt, Vector<CatchPrototype> catch_blocks)
{
InstructionList result = generateTryCatchFinally(try_stmt, catch_blocks, finally_stmt);
currentScope.getFlowManager().finishExceptionContext();
return result;
}
public InstructionList reduce_tryCatchStmt(IASNode iNode, InstructionList try_stmt, Vector<CatchPrototype> catch_blocks)
{
// TODO: Optimize.
InstructionList result = createInstructionList(iNode);
if ( try_stmt.isEmpty() )
{
// TODO: The catch clause gen may have
// side effects, so we can't skip this.
try_stmt = createInstructionList(iNode);
try_stmt.addInstruction(OP_nop);
}
Label catch_tail = new Label();
result.addAll(try_stmt);
result.addInstruction(OP_jump, catch_tail);
// Get labels for the start and end of the try block.
Label try_start = result.getLabel();
Label try_end = result.getLastLabel();
for ( CatchPrototype catch_proto: catch_blocks )
{
boolean is_last_catch = catch_proto.equals(catch_blocks.lastElement());
InstructionList catch_body = generateCatchBlock(try_start, try_end, catch_proto);
if( !is_last_catch && catch_body.canFallThrough() )
catch_body.addInstruction(OP_jump, catch_tail);
result.addAll(catch_body);
}
currentScope.getFlowManager().finishExceptionContext();
result.labelNext(catch_tail);
return result;
}
public InstructionList reduce_tryFinallyStmt(IASNode iNode, InstructionList try_stmt, InstructionList finally_stmt)
{
InstructionList result = generateTryCatchFinally(try_stmt, null, finally_stmt);
currentScope.getFlowManager().finishExceptionContext();
return result;
}
public InstructionList reduce_typedFunction_to_statement(IASNode iNode, InstructionList plist, Binding return_type, InstructionList block)
{
Binding nestedFunctionName = currentScope.resolveName((IdentifierNode)SemanticUtils.getNthChild(iNode, 0));
InstructionList result = createInstructionList(iNode);
this.generateNestedFunction(
iNode,
this.miniScopes.empty()? result: this.miniScopes.peek(),
nestedFunctionName,
return_type.getName(),
block
);
currentScope.getMethodBodySemanticChecker().checkNestedFunctionDecl((IFunctionNode)iNode);
return result;
}
public InstructionList reduce_typedVariableDecl(IASNode iNode, Name var_name, Binding var_type, Vector<InstructionList> chained_decls)
{
BaseVariableNode var_node = (BaseVariableNode)iNode;
currentScope.getMethodBodySemanticChecker().checkVariableDeclaration(iNode);
// Must check for this before we call makeVariable, but need to emit the instructions after
// makeVariable so that Bindings are set up correctly with the right local register indexes.
boolean needsHoistedInitInsns = currentScope.needsHoistedInitInsns(var_name, false);
Binding var = currentScope.resolveName((IdentifierNode)var_node.getNameExpressionNode());
currentScope.makeVariable(var, var_type.getName(), ((BaseDefinitionNode)iNode).getMetaInfos());
// Now that makeVariable is done, emit the hoisted instructions if we needed them.
if(needsHoistedInitInsns)
addHoistedInstructionsForVarDecl(var_name, var_type);
InstructionList result = createInstructionList(iNode);
for ( InstructionList decl: chained_decls )
result.addAll(decl);
return result;
}
/**
* Helper method to add hoisted init instructions for a given variable.
*
* This is neccessary when local vars live in registers, and they are referenced before they are inited.
* If we don't emit the init insns at the top of the method, then the locals could have the wrong values/types
* when they're referenced resulting in incorrect behavior at runtime
* @param var_name the name of the local var
* @param var_type the type of the local var
*/
private void addHoistedInstructionsForVarDecl (Name var_name, Binding var_type)
{
Binding var_binding = currentScope.getLocalBinding(var_name);
if ( var_binding != null && var_binding.isLocal() )
{
// Add initializer code to the init instructions.
InstructionList init_insns = currentScope.getHoistedInitInstructions();
ICompilerProject project = currentScope.getProject();
IDefinition type_def = var_type.getDefinition();
if (
type_def == project.getBuiltinType(BuiltinType.INT) ||
type_def == project.getBuiltinType(BuiltinType.UINT)
)
{
init_insns.addInstruction(OP_pushbyte, 0);
init_insns.addInstruction(var_binding.setlocal());
}
else if ( type_def == project.getBuiltinType(BuiltinType.BOOLEAN) )
{
init_insns.addInstruction(OP_pushfalse);
init_insns.addInstruction(var_binding.setlocal());
}
else if ( type_def == project.getBuiltinType(BuiltinType.NUMBER) )
{
init_insns.addInstruction(OP_pushnan);
init_insns.addInstruction(var_binding.setlocal());
}
else if ( type_def == project.getBuiltinType(BuiltinType.ANY_TYPE) )
{
init_insns.addInstruction(OP_pushundefined);
init_insns.addInstruction(var_binding.setlocal());
}
else if (
type_def instanceof ITypeDefinition &&
((ITypeDefinition)type_def).isInstanceOf((ITypeDefinition)project.getBuiltinType(BuiltinType.OBJECT), project)
)
{
init_insns.addInstruction(OP_pushnull);
init_insns.addInstruction(var_binding.setlocal());
}
else
{
init_insns.addInstruction(OP_pushundefined);
init_insns.addInstruction(var_binding.setlocal());
}
}
}
public InstructionList reduce_typedVariableDeclWithInitializer(IASNode iNode, Name var_name, Binding var_type, InstructionList var_initializer, Vector<InstructionList> chained_decls)
{
BaseVariableNode var_node = (BaseVariableNode)iNode;
currentScope.getMethodBodySemanticChecker().checkVariableDeclaration(iNode);
// Must check for this before we call makeVariable, but need to emit the instructions after
// makeVariable so that Bindings are set up correctly with the right local register indexes.
boolean refedBeforeInited = currentScope.needsHoistedInitInsns(var_name, true);
Binding var = currentScope.resolveName((IdentifierNode)var_node.getNameExpressionNode());
currentScope.makeVariable(var, var_type.getName(), ((BaseDefinitionNode)iNode).getMetaInfos());
// If the binding has already been referenced, then we need to emit some hoisted init instructions
// so that the initial value will be correct.
if( refedBeforeInited )
addHoistedInstructionsForVarDecl(var_name, var_type);
currentScope.getMethodBodySemanticChecker().checkInitialization(iNode, var);
InstructionList result = generateAssignment(iNode, var, var_initializer);
for ( InstructionList decl: chained_decls )
result.addAll(decl);
return result;
}
public InstructionList reduce_typedVariableDeclWithConstantInitializer(IASNode iNode, Name var_name, Binding var_type, Object constant_var_initializer, Vector<InstructionList> chained_decls)
{
BaseVariableNode var_node = (BaseVariableNode)iNode;
PooledValue transformed_constant_initializer =
currentScope.getMethodBodySemanticChecker().checkInitialValue(var_node, var_type, new PooledValue(constant_var_initializer));
// if this definition isn't a const, then just use the normal variable initialization, as
// we only initialize the const slots and not var slots
if (!SemanticUtils.isConst(iNode, currentScope.getProject()))
{
InstructionList var_initializer = transform_pooled_value(iNode, transformed_constant_initializer);
return reduce_typedVariableDeclWithInitializer(iNode, var_name, var_type, var_initializer, chained_decls);
}
currentScope.getMethodBodySemanticChecker().checkVariableDeclaration(iNode);
InstructionList result = createInstructionList(iNode);
Binding var = currentScope.resolveName((IdentifierNode)var_node.getNameExpressionNode());
currentScope.makeVariable(var, var_type.getName(), ((BaseDefinitionNode)iNode).getMetaInfos(), transformed_constant_initializer.getValue());
// If the variable is in a local, then it needs to be initialized at the start of the method.
if ( var.isLocal() )
{
InstructionList var_initializer = transform_pooled_value(iNode, transformed_constant_initializer);
currentScope.getHoistedInitInstructions().addAll(reduce_typedVariableDeclWithInitializer(iNode, var_name, var_type, var_initializer, new Vector<InstructionList>()));
}
for ( InstructionList decl: chained_decls )
result.addAll(decl);
return result;
}
public InstructionList reduce_typedBindableVariableDecl(IASNode iNode, Name name, Binding var_type, Vector<InstructionList> chained_decls)
{
BaseVariableNode vn = (BaseVariableNode)iNode;
currentScope.getMethodBodySemanticChecker().checkBindableVariableDeclaration(iNode, vn.getDefinition());
InstructionList result = createInstructionList(iNode);
Binding var = currentScope.resolveName((IdentifierNode)vn.getNameExpressionNode());
currentScope.makeBindableVariable(var, var_type.getName(), vn.getMetaInfos());
for ( InstructionList decl: chained_decls )
result.addAll(decl);
return result;
}
public InstructionList reduce_typedBindableVariableDeclWithInitializer(IASNode iNode, Name var_name, Binding var_type, InstructionList var_initializer, Vector<InstructionList> chained_decls)
{
BaseVariableNode vn = (BaseVariableNode)iNode;
currentScope.getMethodBodySemanticChecker().checkBindableVariableDeclaration(iNode, vn.getDefinition());
Binding var = currentScope.resolveName((IdentifierNode)vn.getNameExpressionNode());
currentScope.makeBindableVariable(var, var_type.getName(), vn.getMetaInfos());
// pass in null as definition so the assignment goes to the backing var and not the setter
// maybe we'll have to get the actual var def someday.
InstructionList result = generateAssignment(iNode, new Binding(iNode, BindableHelper.getBackingPropertyName(var_name), null), var_initializer);
for ( InstructionList decl: chained_decls )
result.addAll(decl);
return result;
}
public Binding reduce_typedVariableExpression(IASNode iNode, Name var_name, Binding var_type)
{
VariableExpressionNode var_expr_node = (VariableExpressionNode)iNode;
BaseVariableNode var_node = (BaseVariableNode) var_expr_node.getTargetVariable();
currentScope.getMethodBodySemanticChecker().checkVariableDeclaration(SemanticUtils.getNthChild(iNode, 0));
Binding var = currentScope.resolveName((IdentifierNode)var_node.getNameExpressionNode());
currentScope.makeVariable(var, var_type.getName(), var_node.getMetaInfos());
return var;
}
public InstructionList reduce_typelessFunction(IASNode iNode, InstructionList plist, InstructionList block)
{
Binding nestedFunctionName = currentScope.resolveName((IdentifierNode)SemanticUtils.getNthChild(iNode, 0));
InstructionList result = createInstructionList(iNode);
this.generateNestedFunction(
iNode,
this.miniScopes.empty()? result: this.miniScopes.peek(),
nestedFunctionName,
null,
block
);
currentScope.getMethodBodySemanticChecker().checkNestedFunctionDecl((IFunctionNode)iNode);
return result;
}
public InstructionList reduce_typeof_expr(IASNode iNode, InstructionList operand)
{
InstructionList result = unaryOp(iNode, operand, OP_typeof);
this.typeofCount--;
return result;
}
public InstructionList reduce_typeof_name(IASNode iNode, Binding binding)
{
InstructionList result = null;
if ( binding.getDefinition() != null )
{
ITypeDefinition typezo = binding.getDefinition().resolveType(currentScope.getProject());
ICompilerProject project = currentScope.getProject();
if ( typezo == project.getBuiltinType(BuiltinType.STRING) )
{
result = createInstructionList(iNode);
result.addInstruction(OP_pushstring, "string");
}
else if (
typezo == project.getBuiltinType(BuiltinType.NUMBER) ||
typezo == project.getBuiltinType(BuiltinType.INT) ||
typezo == project.getBuiltinType(BuiltinType.UINT)
)
{
result = createInstructionList(iNode);
result.addInstruction(OP_pushstring, "number");
}
else if ( typezo == project.getBuiltinType(BuiltinType.BOOLEAN) )
{
result = createInstructionList(iNode);
result.addInstruction(OP_pushstring, "boolean");
}
}
if ( result == null )
{
result = createInstructionList(iNode);
generateAccess(binding, AccessType.Lenient, result);
result.addInstruction(OP_typeof);
}
this.typeofCount--;
return result;
}
public InstructionList reduce_useNamespaceDirective(IASNode iNode, Binding ns_name)
{
currentScope.getMethodBodySemanticChecker().checkUseNamespaceDirective(iNode, ns_name);
return createInstructionList(iNode);
}
public InstructionList reduce_variableExpression(IASNode iNode, Vector<InstructionList> decls)
{
InstructionList result = createInstructionList(iNode);
for ( InstructionList var_decl: decls )
result.addAll(var_decl);
return result;
}
public InstructionList reduce_vectorLiteral(IASNode iNode, Binding type_param, Vector<InstructionList> elements)
{
currentScope.getMethodBodySemanticChecker().checkVectorLiteral(iNode, type_param);
InstructionList result = createInstructionList(iNode);
Nsset ns_set = new Nsset(new Namespace(CONSTANT_PackageNs, IASLanguageConstants.Vector_impl_package));
Name vector_name = new Name(CONSTANT_Qname, ns_set, IASLanguageConstants.Vector);
result.addAll(currentScope.getPropertyValue(vector_name, currentScope.getProject().getBuiltinType(BuiltinType.VECTOR)));
generateTypeNameParameter(type_param, result);
result.addInstruction(OP_applytype, 1);
result.pushNumericConstant(elements.size());
result.addInstruction(OP_construct, 1);
// Share this instruction; there may be many elements.
Instruction setter = arrayAccess(iNode, OP_setproperty);
for ( int i = 0; i < elements.size(); i++ )
{
result.addInstruction(OP_dup);
result.pushNumericConstant(i);
result.addAll(elements.elementAt(i));
result.addInstruction(setter);
}
return result;
}
public InstructionList reduce_voidExpr_to_expression(IASNode iNode)
{
InstructionList il = createInstructionList(iNode);
il.addInstruction(OP_pushundefined);
return il;
}
public Binding reduce_voidExpr_to_return_type_name(IASNode node)
{
return new Binding(node, voidType, null);
}
public Binding reduce_voidExpr_to_type_name(IASNode node)
{
getProblems().add(new VoidTypeProblem(node));
return new Binding(node, voidType, null);
}
public Object reduce_void0Literal_to_constant_value(IASNode iNode)
{
return UNDEFINED_VALUE;
}
public InstructionList reduce_void0Literal_to_object_literal(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushundefined);
return result;
}
public InstructionList reduce_instructionListExpression(IASNode iNode)
{
return ((InstructionListNode)iNode).getInstructions();
}
public InstructionList reduce_void0Operator(IASNode iNode)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushundefined);
return result;
}
public Object reduce_voidOperator_to_constant_value(IASNode iNode, Object constant_value)
{
return UNDEFINED_VALUE;
}
public InstructionList reduce_voidOperator_to_expression(IASNode iNode, InstructionList expr)
{
InstructionList result = createInstructionList(iNode, 1);
result.addAll(expr);
result.addInstruction(OP_pop);
result.addInstruction(OP_pushundefined);
return result;
}
public InstructionList reduce_whileStmt(IASNode iNode, InstructionList cond, InstructionList body)
{
InstructionList result = createInstructionList(iNode, cond.size() + body.size() + 5);
currentScope.getFlowManager().resolveContinueLabel(cond);
// Jump to the test.
result.addInstruction(OP_jump, cond.getLabel());
// Create an emitter-time label, and attach
// it to an OP_label instruction for the
// backwards branch.
result.addInstruction(OP_label);
Label loop = result.getLastLabel();
result.addAll(body);
result.addAll(cond);
result.addInstruction(OP_iftrue, loop);
currentScope.getFlowManager().finishLoopControlFlowContext(result);
return result;
}
public InstructionList reduce_withStmt(IASNode iNode, InstructionList new_scope, InstructionList body)
{
InstructionList result = createInstructionList(iNode);
result.addAll(new_scope);
if ( currentScope.getFlowManager().hasWithStorage())
{
result.addInstruction(OP_dup);
result.addInstruction(currentScope.getFlowManager().getWithStorage().setlocal());
}
result.addInstruction(OP_pushwith);
result.addAll(body);
result.addInstruction(OP_popscope);
currentScope.getFlowManager().finishWithContext(result);
return result;
}
/**
* 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.
*/
private enum XMLContentState { TagStart, TagLiteral, TagName, Attr, ValueNeedsEquals, Value, TagEnd, ContentLiteral, ContentExpression };
public InstructionList reduce_XMLContent(IASNode iNode, Vector<InstructionList> exprs)
{
InstructionList result = createInstructionList(iNode);
result.addAll(currentScope.getPropertyValue(xmlType, currentScope.getProject().getBuiltinType(BuiltinType.XML)));
// Add all the arguments up into a single String.
XMLContentState[] content_state = computeXMLContentStateMatrix(exprs);
result.addAll(exprs.elementAt(0));
for ( int i = 1; i < exprs.size(); i++ )
{
result.addAll(exprs.elementAt(i));
switch ( content_state[i] )
{
case TagName:
{
// Parser elides whitespace after tag name expressions.
result.addInstruction(OP_pushstring, " ");
result.addInstruction(OP_add);
}
break;
case Attr:
{
// Parser elides whitespace before attribute name expressions.
if ( content_state[i-1] != XMLContentState.TagName )
{
result.addInstruction(OP_pushstring, " ");
result.addInstruction(OP_swap);
result.addInstruction(OP_add);
}
}
break;
case ValueNeedsEquals:
{
if ( content_state[i-1] == XMLContentState.Attr )
{
// Parser elided this token.
result.addInstruction(OP_pushstring, "=");
result.addInstruction(OP_swap);
result.addInstruction(OP_add);
}
}
// falls through
case Value:
{
result.addInstruction(OP_esc_xattr);
// The attribute will need quote marks for the AVM's XML parser.
result.addInstruction(OP_pushstring, "\"");
result.addInstruction(OP_swap);
result.addInstruction(OP_add);
result.addInstruction(OP_pushstring, "\"");
result.addInstruction(OP_add);
}
break;
case ContentExpression:
result.addInstruction(OP_esc_xelem);
}
result.addInstruction(OP_add);
}
result.addInstruction(OP_construct, 1);
return result;
}
public InstructionList reduce_XMLList(IASNode iNode, Vector<InstructionList> exprs)
{
InstructionList result = createInstructionList(iNode);
result.addAll(currentScope.getPropertyValue(xmlListType, currentScope.getProject().getBuiltinType(BuiltinType.XMLLIST)));
// The first and last elements are the <> and </> brackets.
// An empty XMLList <></> should be reduced by the constant
// case, below, so we know we have at least one element.
result.addAll(exprs.get(1));
for ( int i = 2; i < exprs.size() - 1; i++ )
{
result.addAll(exprs.get(i));
result.addInstruction(OP_add);
}
result.addInstruction(OP_construct, 1);
return result;
}
public InstructionList reduce_XMLListConst(IASNode iNode, Vector<String> elements)
{
InstructionList result = createInstructionList(iNode);
result.addAll(currentScope.getPropertyValue(xmlListType, currentScope.getProject().getBuiltinType(BuiltinType.XMLLIST)));
StringBuilder buffer = new StringBuilder();
// The first and last elements are the <> and </> brackets.
for ( int i = 1; i < elements.size() -1; i++ )
buffer.append(elements.elementAt(i));
result.addInstruction(OP_pushstring, buffer.toString());
result.addInstruction(OP_construct, 1);
return result;
}
/**
* Clone an InstructionList.
* @return the clone, appropriately cast.
* @note clone() always returns Object.
*/
InstructionList replicate(InstructionList prototype)
{
return (InstructionList)prototype.clone();
}
/**
* Set this reducer's list of a priori instructions;
* typically these are field initializers passed in to
* a constructor routine.
*/
public void setInstanceInitializers(InstructionList insns)
{
this.instanceInitializers = insns;
}
/**
* Set this reducer's initial LexicalScope.
*/
public void setCurrentscope(LexicalScope scope)
{
this.currentScope = scope;
}
/*
* ******************************
* ** Transformation routines **
* ******************************
*/
public InstructionList transform_boolean_constant(IASNode iNode, Boolean boolean_constant)
{
InstructionList result = createInstructionList(iNode, 1);
if ( Boolean.TRUE.equals(boolean_constant) )
result.addInstruction(OP_pushtrue);
else
result.addInstruction(OP_pushfalse);
return result;
}
public InstructionList transform_double_constant(IASNode iNode, Double double_constant)
{
InstructionList result = createInstructionList(iNode, 1);
pushNumericConstant(result, double_constant, SemanticUtils.resolveType(iNode, currentScope.getProject()));
return result;
}
public InstructionList transform_numeric_constant(IASNode iNode, Number numeric_constant)
{
if( numeric_constant instanceof Integer)
return transform_integer_constant(iNode, (Integer)numeric_constant);
if( numeric_constant instanceof Long )
return transform_long_constant(iNode, (Long)numeric_constant);
if( numeric_constant instanceof Double)
return transform_double_constant(iNode, (Double)numeric_constant);
return createInstructionList(iNode, 1);
}
/**
* Transform any PooledValue into an expression, so we can constant fold all sorts of expressions.
* @param iNode the node that generated the constant_value
* @param pooled_value the pooled value
* @return an InstructionList that contains instructions to push the pooled_value onto the stack.
*/
public InstructionList transform_pooled_value(IASNode iNode, PooledValue pooled_value )
{
return transform_constant_value(iNode, pooled_value.getValue());
}
/**
* 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 InstructionList that contains instructions to push the constant_value onto the stack.
*/
public InstructionList transform_constant_value(IASNode iNode, Object constant_value )
{
assert (!(constant_value instanceof PooledValue)) : "transform_constant_value should not be called with a PooledValue";
if( constant_value instanceof Boolean )
{
return transform_boolean_constant(iNode, (Boolean)constant_value);
}
if( constant_value instanceof Number )
{
return transform_numeric_constant(iNode, (Number)constant_value);
}
if( constant_value instanceof String )
{
return transform_string_constant(iNode, (String)constant_value);
}
InstructionList result = createInstructionList(iNode, 1);
if( constant_value instanceof Namespace)
{
result.addInstruction(OP_pushnamespace, constant_value);
}
else if( constant_value == ABCConstants.NULL_VALUE )
{
result.addInstruction(OP_pushnull);
}
else if( constant_value == ABCConstants.UNDEFINED_VALUE )
{
result.addInstruction(OP_pushundefined);
}
else
{
assert false : "unknown constant type";
}
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)
{
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)
{
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)
{
return numeric_constant;
}
public InstructionList transform_expression_to_conditionalJump(IASNode iNode, InstructionList expression)
{
InstructionList result = createInstructionList(iNode, expression.size() + 1);
result.addAll(expression);
result.addInstruction(InstructionFactory.getTargetableInstruction(OP_iftrue));
return result;
}
public Object transform_expression_to_constant_value(IASNode iNode, InstructionList expression)
{
// return null - something higher up will report any appropriate diagnostics.
return null;
}
public InstructionList transform_expression_to_void_expression(IASNode iNode, InstructionList expression)
{
InstructionList result = createInstructionList(iNode, expression.size() + 1);
result.addAll(expression);
result.addInstruction(OP_pop);
return result;
}
public InstructionList transform_integer_constant(IASNode iNode, Integer integer_constant)
{
InstructionList result = createInstructionList(iNode, 1);
pushNumericConstant(result, integer_constant, SemanticUtils.resolveType(iNode, currentScope.getProject()));
return result;
}
public InstructionList transform_long_constant(IASNode iNode, Long long_constant)
{
InstructionList result = createInstructionList(iNode, 1);
pushNumericConstant(result, long_constant, SemanticUtils.resolveType(iNode, currentScope.getProject()));
return result;
}
public Object transform_name_to_constant_value(IASNode iNode)
{
currentScope.getMethodBodySemanticChecker().checkConstantValue(iNode);
return SemanticUtils.transformNameToConstantValue(iNode, currentScope.getProject());
}
public InstructionList transform_name_to_expression(IASNode iNode, Binding name)
{
return generateAccess(name, determineAccessType(iNode));
}
public InstructionList transform_non_resolving_identifier(IASNode iNode, String non_resolving_identifier)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushstring, non_resolving_identifier);
return result;
}
public InstructionList transform_runtime_name_expression(IASNode iNode, RuntimeMultiname runtime_name_expression)
{
return runtime_name_expression.generateRvalue(iNode);
}
public InstructionList transform_string_constant(IASNode iNode, String string_constant)
{
InstructionList result = createInstructionList(iNode, 1);
result.addInstruction(OP_pushstring, string_constant);
return result;
}
public InstructionList transform_uint_constant(IASNode iNode, Long uint_constant)
{
InstructionList result = createInstructionList(iNode, 1);
pushNumericConstant(result, uint_constant, SemanticUtils.resolveType(iNode, currentScope.getProject()));
return result;
}
/**
* Generate a unary operator.
* @param operand - the operand expression.
* @param opcode - the operator's opcode.
* @return an InstructionList that applies the operator to the operand.
*/
InstructionList unaryOp(IASNode iNode, InstructionList operand, int opcode)
{
checkUnaryOp(iNode, opcode);
InstructionList result = createInstructionList(iNode, operand.size() + 1);
result.addAll(operand);
result.addInstruction(opcode);
return result;
}
public void checkUnaryOp (IASNode iNode, int opcode)
{
currentScope.getMethodBodySemanticChecker().checkUnaryOperator(iNode, opcode);
}
/**
* Walk a syntax tree and note any construct that
* will cause the ABC function to need an activation record.
*/
void scanFunctionBodyForActivations(IASNode n)
{
if ( n != null )
{
switch ( n.getNodeID() )
{
case WithID:
case AnonymousFunctionID:
case FunctionID:
{
currentScope.setNeedsActivation();
break;
}
default:
{
// Note: There is no need to create an activation
// for catch or finally. See ActivationSanityTest
// for examples which prove this.
for ( int i = 0; i < n.getChildCount(); i++ )
scanFunctionBodyForActivations(n.getChild(i));
}
}
}
}
/**
* Is this expression a string literal?
* @return true if the expression is a string literal, i.e.,
* it has one pushstring instruction.
*/
public static boolean isStringLiteral(InstructionList insns)
{
return insns.lastElement().getOpcode() == OP_pushstring;
}
/**
* Extract the string literal from an InstructionList.
* @param insns - the InstructionList of interest.
* @return the string literal from insns' final
* (and presumably only executable) instruction.
*/
public static String getStringLiteral(InstructionList insns)
{
assert isStringLiteral(insns);
return insns.lastElement().getOperand(0).toString();
}
/**
* Work around the linear presentation of XML initializer elements from the parser
* by doing ad-hoc pattern matching.
* @param exprs - a Vector of expressions.
* @return A state transition matrix to generate code for the elements.
* @see "ECMA-357 11.1.4 : XML Initialiser"
* Expressions may be used to compute parts of an XML initialiser.
* Expressions are delimited by curly braces and may appear inside tags or element content.
* Inside a tag, expressions may be used to compute a tag name, attribute name, or attribute value.
* Inside an element, expressions may be used to compute element content.
*/
private XMLContentState[] computeXMLContentStateMatrix( Vector<InstructionList> exprs)
{
XMLContentState[] result = new XMLContentState[exprs.size()];
// First element must be a string or the parser wouldn't have put us here.
// But it may be a simple < or </ literal or a <foo literal; the former
// imply that the next expression is going to be a TagName, the latter just
// is a TagLiteral that puts us into the middle of things.
assert isStringLiteral(exprs.elementAt(0)) : exprs.elementAt(0);
String first_element = getStringLiteral(exprs.elementAt(0));
if ( first_element.equals("<") || first_element.equals("</") )
result[0] = XMLContentState.TagStart;
else
result[0] = XMLContentState.TagLiteral;
for ( int i = 1; i < exprs.size(); i++ )
{
InstructionList insns = exprs.elementAt(i);
if ( isStringLiteral(insns) )
{
switch ( result[i-1] )
{
case TagStart:
case TagLiteral:
case TagName:
case Attr:
case Value:
case ValueNeedsEquals:
{
if ( getStringLiteral(insns).matches(".*>") )
result[i] = XMLContentState.TagEnd;
else
result[i] = XMLContentState.TagLiteral;
break;
}
case TagEnd:
case ContentLiteral:
case ContentExpression:
if ( getStringLiteral(insns).matches("<.*") )
result[i] = XMLContentState.TagStart;
else
result[i] = XMLContentState.ContentLiteral;
}
}
else
{
// Now the fun starts.
// The most important thing to do here is to get the
// Value, and ContentExpression states right;
// these are the entities that require special instructions.
switch ( result[i-1] )
{
case TagStart:
result[i] = XMLContentState.TagName;
break;
// An expression following a tag name or
// an attribute value should be an attribute name.
case TagName:
case Value:
result[i] = XMLContentState.Attr;
break;
// An expression following an attribute name
// should be an attribute value.
case Attr:
result[i] = XMLContentState.ValueNeedsEquals;
break;
case TagEnd:
case ContentLiteral:
case ContentExpression:
result[i] = XMLContentState.ContentExpression;
break;
case TagLiteral:
{
// The literal is free-form input and needs
// to be analyzed.
switch ( getXMLLiteralContentState(getStringLiteral(exprs.elementAt(i-1)) ) )
{
case TagStart:
result[i] = XMLContentState.TagName;
break;
case Attr:
// Since Attr here implies we saw
// a '=' character, the XML string
// won't need one appended.
result[i] = XMLContentState.Value;
break;
case Value:
result[i] = XMLContentState.Attr;
break;
default:
result[i] = XMLContentState.ContentExpression;
}
break;
}
default:
assert false: "Unhandled case " + result[i-1];
}
}
}
return result;
}
/**
* Analyze an XML literal and see what state its last character implies.
* @return the XMLContentState corresponding to the significance
* of the last literal; e.g., "foo=" returns Attr, "foo" returns Value.
*/
private XMLContentState getXMLLiteralContentState(String literal)
{
char lastChar = literal.charAt(literal.length()-1);
if ( lastChar == '<' )
{
return XMLContentState.TagStart;
}
else if ( lastChar == '=' )
{
return XMLContentState.Attr;
}
return XMLContentState.ContentExpression;
}
/**
* @return return the opcode to use to convert the top stack value to a numeric
* or not
*/
int op_unplus ()
{
return OP_convert_d;
}
/**
* Reduce a array index expression ( a[x] ) in an MXML data binding
* destination to: a[x] = firstParam
*/
public InstructionList reduce_arrayIndexExpr_to_mxmlDataBindingSetter(IASNode iNode, InstructionList stem, InstructionList index, boolean isSuper)
{
IDynamicAccessNode arrayIndexNode = (IDynamicAccessNode)iNode;
int stemInstructionCount = isSuper ? 1 : stem.size();
InstructionList result =
createInstructionList(arrayIndexNode, stemInstructionCount + index.size() + 3 + 1); // +1 for the returnvoid
if (isSuper)
result.addInstruction(OP_getlocal0);
else
result.addAll(stem);
result.addAll(index);
result.addInstruction(OP_getlocal1);
int opCode = isSuper ? OP_setsuper : OP_setproperty;
result.addInstruction(arrayAccess(arrayIndexNode, opCode));
return result;
}
/**
* Reduce a member access expression ( a.b ) in an MXML data binding
* destination to: a.b = firstParam
*/
public InstructionList reduce_memberAccessExpr_to_mxmlDataBindingSetter(IASNode memberAccessExpr, InstructionList stem, Binding member)
{
currentScope.getMethodBodySemanticChecker().checkLValue(memberAccessExpr, member);
InstructionList result =
createInstructionList(memberAccessExpr, stem.size() + 2 + 1); // +1 for the returnvoid
result.addAll(stem);
result.addInstruction(OP_getlocal1);
result.addInstruction(OP_setproperty, member.getName());
return result;
}
/**
* Reduce a qualified member access expression ( a.ns::b ) in an MXML data binding
* destination to: a.ns::b = firstParam
*/
public InstructionList reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberAccessExpr, InstructionList stem, Binding qualifier, Binding member)
{
InstructionList result =
createInstructionList(qualifiedMemberAccessExpr);
// We may need to work around CMP-751 by recreating
// the correct (trivial) qualifier for base.*::foo.
Name member_name = member.getName();
result.addAll(stem);
if ( !isNamespace(qualifier) )
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
}
// else the qualifier's namespace is already present in the name.
result.addInstruction(OP_getlocal1);
result.addInstruction(OP_setproperty, member_name);
return result;
}
/**
* Reduce a qualified member access expression ( a.ns::["b"] ) in an MXML data binding
* destination to: a.ns::["b"] = firstParam
*/
public InstructionList reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberRuntimeExpr, InstructionList stem, Binding qualifier, InstructionList runtime_member)
{
InstructionList result = createInstructionList(qualifiedMemberRuntimeExpr);
result.addAll(stem);
if ( isNamespace(qualifier) )
{
result.addAll(runtime_member);
// Extract the URI from the namespace and use it to construct a qualified name.
NamespaceDefinition ns_def = (NamespaceDefinition)qualifier.getDefinition();
Name qualified_name = new Name(CONSTANT_MultinameL, new Nsset(ns_def.resolveAETNamespace(currentScope.getProject())), null);
result.addInstruction(OP_getlocal1);
result.addInstruction(OP_setproperty, qualified_name);
}
else
{
generateAccess(qualifier, result);
// Verifier insists on this.
result.addInstruction(OP_coerce, namespaceType);
result.addAll(runtime_member);
result.addInstruction(OP_getlocal1);
result.addInstruction(OP_setproperty, new Name(CONSTANT_RTQnameL, null, null));
}
return result;
}
/**
* Reduce a runtime name ( nsVar::x ) in an MXML data binding
* destination to: nsVar::x = firstParam
* <p>
* This reduction is used when the qualifer is not a compiler time constant namespace.
*/
public InstructionList reduceRuntimeName_to_mxmlDataBindingSetter(IASNode runtimeNameNode, RuntimeMultiname runtime_name_expression)
{
InstructionList rhs = new InstructionList(1);
rhs.addInstruction(OP_getlocal1);
return runtime_name_expression.generateGetOrSet(runtimeNameNode, OP_setproperty, rhs);
}
/**
* Reduce a compile time constant name ( x ) in an MXML data binding
* destination to: x = firstParam.
*/
public InstructionList reduceName_to_mxmlDataBindingSetter(IASNode nameNode, Binding name)
{
currentScope.getMethodBodySemanticChecker().checkLValue(nameNode, name);
InstructionList result = new InstructionList(3 + 1); // +1 because of the returnvoid
result.addAll(currentScope.findProperty(name, true));
result.addInstruction(ABCConstants.OP_getlocal1);
result.addInstruction(OP_setproperty, name.getName());
return result;
}
/**
* Synthesize an array access instruction
* with the correct runtime multiname.
* <p>
* This handles <code>whatever[...]</code>,
* including <code>this[...]</code> and <code>super[...]</code>.
*
* @param iNode - an IDynamicAccessNode from the construct
* that needs an array access instruction.
* @param opcode - the opcode of the instruction desired.
* @return an instruction with the specified opcode
* and the set of open namespaces at the given node.
*/
private Instruction arrayAccess(IASNode iNode, int opcode)
{
ICompilerProject project = currentScope.getProject();
// Determine if iNode represents super[...] (either as an l-value or an r-value).
// If so, the namespace set will be slightly different; it will have
// ProtectedNs(thisClass) instead of ProtectedNs(superClass>.
IDefinition superDef = null;
if (iNode instanceof IDynamicAccessNode)
{
IExpressionNode arrayNode = ((IDynamicAccessNode)iNode).getLeftOperandNode();
if (arrayNode instanceof ILanguageIdentifierNode &&
((ILanguageIdentifierNode)arrayNode).getKind() == LanguageIdentifierKind.SUPER)
{
IIdentifierNode superNode = (IIdentifierNode)arrayNode;
superDef = superNode.resolveType(project);
}
}
Nsset nsSet = superDef != null ?
SemanticUtils.getOpenNamespacesForSuper(iNode, project, superDef) :
SemanticUtils.getOpenNamespaces(iNode, project);
Name name = new Name(ABCConstants.CONSTANT_MultinameL, nsSet, null);
return InstructionFactory.getInstruction(opcode, name);
}
/**
* Determine the proper access type for a name.
* @param iNode - the name's AST.
* @return AccessType.Lenient if the node is a unqualified
* name or the member reference leaf of a member access
* node, AccessType.Strict in all other cases.
*/
private AccessType determineAccessType(IASNode iNode)
{
if ( iNode.getParent() instanceof MemberAccessExpressionNode)
{
MemberAccessExpressionNode maen = (MemberAccessExpressionNode)iNode.getParent();
if ( !maen.isMemberReference(iNode) )
{
return AccessType.Strict;
}
}
return (this.typeofCount > 0)?
AccessType.Lenient:
AccessType.Strict;
}
}