ABCGeneratingReducer (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer

public class ABCGeneratingReducer
extends Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ABCGeneratingReducer.CatchPrototype` A struct for the decoded pieces of a catch block.
`class`	`ABCGeneratingReducer.ConditionalFragment` ConditionalFragment holds the disparate elements of a conditional statement fragment.

Field Summary

Fields
Modifier and Type	Field and Description
`static Name`	`namespaceType` A shared name for the Namespace type.
`static Name`	`regexType` A shared name for the RegExp type.
`static Instruction`	`synthesizedReturnVoid` 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.
`static Name`	`voidType` A shared name for the void type.
`static Name`	`xmlListType` A shared name for the XMLList type.
`static Name`	`xmlType` A shared name for the XML type.

Constructor Summary

Constructors
Constructor and Description

ABCGeneratingReducer()

Constructors
Constructor and Description
`ABCGeneratingReducer()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`checkBinaryOp(IASNode iNode, int opcode)` Perform semantic checks on a binary operator.
`void`	`checkUnaryOp(IASNode iNode, int opcode)`
`void`	`coerce(InstructionList il, IDefinition toType)` Add instructions to the instructionlist passed in to coerce the top value of the stack to the given type.
`InstructionList`	`createInstructionList(IASNode iNode)` Common routine used by reductions that need an empty list.
`InstructionList`	`createInstructionList(IASNode iNode, int capacity)` Common routine used by reductions that need an empty list.
`Binding`	`error_namespaceAccess(IASNode iNode, IASNode raw_qualifier, Binding qualified_name)` Error trap.
`InstructionList`	`error_reduce_Op_AssignId(IASNode iNode, InstructionList non_lvalue, InstructionList rvalue)` Error trap.
`Collection<ICompilerProblem>`	`getProblems()`
`static String`	`getStringLiteral(InstructionList insns)` Extract the string literal from an InstructionList.
`static boolean`	`isStringLiteral(InstructionList insns)` Is this expression a string literal?
`void`	`prologue_anonymousFunction(IASNode iNode)`
`void`	`prologue_blockStmt_to_finally_clause(IASNode iNode)`
`void`	`prologue_blockStmt(IASNode iNode)`
`void`	`prologue_catchBlock(IASNode iNode)`
`void`	`prologue_countedForStmt(IASNode iNode)`
`void`	`prologue_doStmt(IASNode iNode)`
`void`	`prologue_forEachStmt(IASNode iNode)`
`void`	`prologue_forInStmt(IASNode iNode)`
`void`	`prologue_functionObject(IASNode iNode)`
`void`	`prologue_labeledStmt(IASNode iNode)`
`void`	`prologue_mxmlEventSpecifier(IASNode iNode)`
`void`	`prologue_switchStmt(IASNode iNode)`
`void`	`prologue_tryCatchFinallyStmt(IASNode iNode)`
`void`	`prologue_tryCatchStmt(IASNode iNode)`
`void`	`prologue_tryFinallyStmt(IASNode iNode)`
`void`	`prologue_typedFunction_to_statement(IASNode iNode)`
`void`	`prologue_typelessFunction_to_statement(IASNode iNode)`
`void`	`prologue_typeof(IASNode iNode)` Before reducing the operands of a typeof, we need to increment the typeof counter.
`void`	`prologue_whileStmt(IASNode iNode)`
`void`	`prologue_withStmt(IASNode iNode)`
`void`	`pushNumericConstant(InstructionList result_list, Number value, IDefinition type)` Generate code to push a numeric value onto the stack.
`static void`	`pushNumericConstant(long value, InstructionList result_list)` Generate code to push a numeric constant.
`InstructionList`	`reduce_anonymousFunction(IASNode iNode, InstructionList function_body)`
`InstructionList`	`reduce_arrayIndexExpr_to_mxmlDataBindingSetter(IASNode iNode, InstructionList stem, InstructionList index, boolean isSuper)` Reduce a array index expression ( a[x] ) in an MXML data binding destination to: a[x] = firstParam
`InstructionList`	`reduce_arrayIndexExpr(IASNode iNode, InstructionList stem, boolean is_super, InstructionList index)`
`InstructionList`	`reduce_arrayLiteral(IASNode iNode, Vector<InstructionList> elements)`
`InstructionList`	`reduce_assignToBracketExpr_to_expression(IASNode iNode, InstructionList stem, InstructionList index, InstructionList r, boolean is_super)`
`InstructionList`	`reduce_assignToBracketExpr_to_void_expression(IASNode iNode, InstructionList stem, InstructionList index, InstructionList r, boolean is_super)`
`InstructionList`	`reduce_assignToDescendantsExpr(IASNode iNode, InstructionList stem, Binding member, InstructionList r, boolean need_value)`
`InstructionList`	`reduce_assignToMemberExpr_to_expression(IASNode iNode, InstructionList stem, Binding member, InstructionList r)`
`InstructionList`	`reduce_assignToMemberExpr_to_void_expression(IASNode iNode, InstructionList stem, Binding member, InstructionList r)`
`InstructionList`	`reduce_assignToNameExpr_to_expression(IASNode iNode, Binding lvalue, InstructionList r)`
`InstructionList`	`reduce_assignToNameExpr_to_void_expression(IASNode iNode, Binding lvalue, InstructionList r)`
`InstructionList`	`reduce_assignToQualifiedAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, InstructionList rhs, boolean need_value)`
`InstructionList`	`reduce_assignToQualifiedMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, InstructionList rhs, boolean need_value)`
`InstructionList`	`reduce_assignToQualifiedRuntimeAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, InstructionList rhs, boolean need_value)`
`InstructionList`	`reduce_assignToQualifiedRuntimeMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, InstructionList rhs, boolean need_value)`
`InstructionList`	`reduce_assignToRuntimeNameExpr(IASNode iNode, org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname lval, InstructionList r, boolean need_value)`
`InstructionList`	`reduce_assignToUnqualifiedRuntimeAttributeExpr(IASNode iNode, InstructionList stem, InstructionList rt_attr, InstructionList rhs, boolean need_value)`
`Binding`	`reduce_attributeName(IASNode iNode, Binding attr_name)`
`InstructionList`	`reduce_blockStmt_to_finally_clause(IASNode iNode, Vector<InstructionList> stmts)`
`InstructionList`	`reduce_blockStmt_to_statement(IASNode iNode, Vector<InstructionList> stmts)`
`Boolean`	`reduce_booleanLiteral(IASNode iNode)`
`InstructionList`	`reduce_breakStmt(IASNode iNode)`
`String`	`reduce_by_concatenation(IASNode iNode, String first, String second)`
`ABCGeneratingReducer.CatchPrototype`	`reduce_catchBlockTyped(IASNode iNode, Binding var_name, Binding exception, InstructionList action)`
`ABCGeneratingReducer.CatchPrototype`	`reduce_catchBlockUntyped(IASNode iNode, Binding var_name, InstructionList action)`
`InstructionList`	`reduce_commaExpr(IASNode iNode, InstructionList payload_expr, Vector<InstructionList> exprs)`
`ABCGeneratingReducer.ConditionalFragment`	`reduce_conditionalFragment(IASNode iNode, InstructionList condition, Vector<InstructionList> consequents)`
`Object`	`reduce_constantAddition(IASNode iNode, Object l, Object r)` reduce addition of two constant values.
`ABCGeneratingReducer.ConditionalFragment`	`reduce_constantConditionalFragment(IASNode iNode, Object constantCondition, Vector<InstructionList> consequents)`
`String`	`reduce_constantStringConcatenation(IASNode iNode, Object l, String r)` reduce a concatenation of a constant value and a string to a string constant.
`String`	`reduce_constantStringConcatenation(IASNode iNode, String l, Object r)` reduce a concatenation of a string and a constant value to a string constant.
`String`	`reduce_constantStringConcatenation(IASNode iNode, String l, String r)` reduce a concatenation of two strings to a string constant
`InstructionList`	`reduce_continueStmt(IASNode iNode)`
`InstructionList`	`reduce_countedForStmt(IASNode iNode, InstructionList init, InstructionList test_insns, InstructionList incr, InstructionList body)`
`Name`	`reduce_declName(IASNode iNode)`
`InstructionList`	`reduce_defaultXMLNamespace(IASNode iNode, InstructionList ns_expr)`
`InstructionList`	`reduce_deleteAtBracketExpr(IASNode iNode, InstructionList stem, InstructionList index)` Reduce E4X expression like: {@code delete x.
`InstructionList`	`reduce_deleteBracketExpr(IASNode iNode, InstructionList stem, InstructionList index)` Reduce expression like: `delete o[p]`
`InstructionList`	`reduce_deleteDescendantsExpr(IASNode iNode, InstructionList stem, Binding field)`
`InstructionList`	`reduce_deleteExprExprExpr(IASNode iNode, InstructionList expr)`
`InstructionList`	`reduce_deleteMemberExpr(IASNode iNode, InstructionList stem, Binding field)`
`InstructionList`	`reduce_deleteNameExpr(IASNode iNode, Binding n)`
`InstructionList`	`reduce_deleteRuntimeNameExpr(IASNode iNode, InstructionList stem, org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname rt_name)`
`InstructionList`	`reduce_doStmt(IASNode iNode, InstructionList body, InstructionList cond)`
`InstructionList`	`reduce_e4xFilter(IASNode iNode, InstructionList stem, InstructionList filter)`
`InstructionList`	`reduce_embed(IASNode iNode)`
`InstructionList`	`reduce_forKeyValueArrayStmt(IASNode iNode, InstructionList stem, InstructionList index, InstructionList base, InstructionList body, int opcode, boolean is_super)` Reduce statement like: `for (a[it] in base) body;`
`InstructionList`	`reduce_forKeyValueMemberStmt(IASNode iNode, InstructionList stem, Binding member, InstructionList base, InstructionList body, int opcode, boolean is_super)`
`InstructionList`	`reduce_forKeyValueStmt(IASNode iNode, Binding it, InstructionList base, InstructionList body, int opcode)`
`InstructionList`	`reduce_forVarDeclInStmt(IASNode iNode, InstructionList single_decl, InstructionList base, InstructionList body, int opcode)` Reduce `for(it in base)` or `for each(it in base)` loop with variable initializer.
`InstructionList`	`reduce_functionAsBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, Vector<InstructionList> args)` Reduce expression like: `a[i]()`
`InstructionList`	`reduce_functionAsMemberExpr(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionAsRandomExpr(IASNode iNode, InstructionList random_expr, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionCallExpr_to_expression(IASNode iNode, Binding method_name, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionCallExpr_to_void_expression(IASNode iNode, Binding method_name, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionCallOfSuperclassMethod_to_expression(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionCallOfSuperclassMethod_to_void_expression(IASNode iNode, InstructionList stem, Binding method_name, Vector<InstructionList> args)`
`InstructionList`	`reduce_functionObject(IASNode iNode, IASNode function_name, InstructionList plist, Binding return_binding, InstructionList function_body)`
`InstructionList`	`reduce_gotoStmt(IASNode iNode)`
`InstructionList`	`reduce_groupedVoidExpression(IASNode iNode, Vector<InstructionList> contents)`
`InstructionList`	`reduce_ifElseIf(IASNode iNode, InstructionList test, InstructionList then, Vector<ABCGeneratingReducer.ConditionalFragment> if_elseif)`
`InstructionList`	`reduce_importDirective(IASNode iNode)`
`InstructionList`	`reduce_instructionListExpression(IASNode iNode)`
`InstructionList`	`reduce_labeledBreakStmt(IASNode iNode)`
`InstructionList`	`reduce_labeledContinueStmt(IASNode iNode)`
`InstructionList`	`reduce_labeledStmt(IASNode iNode, String label, InstructionList substatement)`
`ABCGeneratingReducer.ConditionalFragment`	`reduce_lastElse(IASNode iNode, InstructionList else_clause)`
`InstructionList`	`reduce_logicalAndExpr(IASNode iNode, InstructionList l, InstructionList r)`
`InstructionList`	`reduce_logicalNotExpr(IASNode iNode, InstructionList expr)`
`InstructionList`	`reduce_logicalOrExpr(IASNode iNode, InstructionList l, InstructionList r)`
`InstructionList`	`reduce_memberAccessExpr_to_mxmlDataBindingSetter(IASNode memberAccessExpr, InstructionList stem, Binding member)` Reduce a member access expression ( a.b ) in an MXML data binding destination to: a.b = firstParam
`InstructionList`	`reduce_memberAccessExpr(IASNode iNode, InstructionList stem, Binding member, int opcode)`
`InstructionList`	`reduce_mxmlEventSpecifier(IASNode iNode, Vector<InstructionList> stmts)`
`org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname`	`reduce_namespaceAccess_to_runtime_name(IASNode iNode, Binding qualified_name)`
`Binding`	`reduce_namespaceAccess(IASNode iNode, IASNode qualifier, Binding qualified_name)`
`InstructionList`	`reduce_namespaceAsName_to_expression(IASNode iNode)`
`Name`	`reduce_namespaceAsName_to_multinameL(IASNode iNode)`
`Name`	`reduce_namespaceAsName_to_multinameL(IASNode iNode, boolean is_attribute)`
`Binding`	`reduce_namespaceAsName_to_name(IASNode iNode)`
`InstructionList`	`reduce_namespaceDeclaration(IASNode iNode, Binding ns_name)`
`InstructionList`	`reduce_namespaceDeclarationConstantInitializer(IASNode iNode, Binding ns_name, Namespace initializer)` Does the work for the various reduce_namespaceDecl methods.
`InstructionList`	`reduce_namespaceDeclarationConstantInitializer(IASNode iNode, Binding ns_name, String uri)`
`InstructionList`	`reduce_namespaceDeclarationInitializer(IASNode iNode, Binding ns_name, Binding second_ns)`
`org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname`	`reduce_namespaceMultinameL(IASNode iNode, IASNode qualifier_node, InstructionList expr)`
`org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname`	`reduce_namespaceRTQName(IASNode iNode, InstructionList qualifier, Binding qualified_name)`
`org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname`	`reduce_namespaceRTQNameL(IASNode iNode, InstructionList qualifier, InstructionList expr)`
`Binding`	`reduce_nameToTypeName(Binding name, boolean check_name)`
`InstructionList`	`reduce_neqExpr(IASNode iNode, InstructionList l, InstructionList r)`
`InstructionList`	`reduce_newAsRandomExpr(IASNode iNode, InstructionList random_expr, Vector<InstructionList> args)`
`InstructionList`	`reduce_newEmptyArray(IASNode iNode)`
`InstructionList`	`reduce_newEmptyObject(IASNode iNode)`
`InstructionList`	`reduce_newExpr(IASNode iNode, Binding class_binding, Vector<InstructionList> args)`
`InstructionList`	`reduce_newMemberProperty(IASNode iNode, InstructionList stem, Binding member, Vector<InstructionList> args)`
`InstructionList`	`reduce_newVectorLiteral(IASNode iNode, InstructionList literal)`
`InstructionList`	`reduce_nilExpr_to_conditionalJump(IASNode iNode)`
`InstructionList`	`reduce_nilExpr_to_expression(IASNode iNode)`
`Object`	`reduce_nullLiteral_to_constant_value(IASNode iNode)`
`InstructionList`	`reduce_nullLiteral_to_object_literal(IASNode iNode)`
`InstructionList`	`reduce_objectLiteral(IASNode iNode, Vector<InstructionList> elements)`
`InstructionList`	`reduce_objectLiteralElement(IASNode iNode, InstructionList id, InstructionList value)`
`InstructionList`	`reduce_optionalParameter(IASNode iNode, Name param_name, Binding param_type, Object raw_default_value)`
`Binding`	`reduce_parameterizedName(IASNode iNode, Binding base, Binding param)`
`InstructionList`	`reduce_parameterizedTypeExpression(IASNode iNode, InstructionList base, InstructionList param)`
`InstructionList`	`reduce_plist(IASNode iNode, Vector<InstructionList> pdecl)`
`InstructionList`	`reduce_postDecBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)`
`InstructionList`	`reduce_postDecMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)`
`InstructionList`	`reduce_postDecNameExpr(IASNode iNode, Binding unary, boolean need_result)`
`InstructionList`	`reduce_postIncBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)`
`InstructionList`	`reduce_postIncMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)`
`InstructionList`	`reduce_postIncNameExpr(IASNode iNode, Binding unary, boolean need_result)`
`InstructionList`	`reduce_preDecBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)`
`InstructionList`	`reduce_preDecMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)`
`InstructionList`	`reduce_preDecNameExpr(IASNode iNode, Binding unary, boolean need_result)`
`InstructionList`	`reduce_preIncBracketExpr(IASNode iNode, InstructionList stem, InstructionList index, boolean need_result)`
`InstructionList`	`reduce_preIncMemberExpr(IASNode iNode, InstructionList stem, Binding field, boolean need_result)`
`InstructionList`	`reduce_preIncNameExpr(IASNode iNode, Binding unary, boolean need_result)`
`InstructionList`	`reduce_qualifiedAttributeExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, int opcode)`
`InstructionList`	`reduce_qualifiedAttributeRuntimeMemberExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector, int opcode)`
`InstructionList`	`reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberAccessExpr, InstructionList stem, Binding qualifier, Binding member)` Reduce a qualified member access expression ( a.ns::b ) in an MXML data binding destination to: a.ns::b = firstParam
`InstructionList`	`reduce_qualifiedMemberAccessExpr(IASNode iNode, InstructionList stem, Binding qualifier, Binding member, int opcode)`
`InstructionList`	`reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberRuntimeExpr, InstructionList stem, Binding qualifier, InstructionList runtime_member)` Reduce a qualified member access expression ( a.ns::["b"] ) in an MXML data binding destination to: a.ns::["b"] = firstParam
`InstructionList`	`reduce_qualifiedMemberRuntimeNameExpr(IASNode iNode, InstructionList stem, Binding qualifier, InstructionList runtime_member_selector)`
`InstructionList`	`reduce_regexLiteral(IASNode iNode)`
`InstructionList`	`reduce_requiredParameter(IASNode iNode, Name param_name, Binding param_type)`
`InstructionList`	`reduce_restParameter(IASNode iNode, Name param_name, Binding param_type)`
`InstructionList`	`reduce_returnValue(IASNode iNode, InstructionList value)`
`InstructionList`	`reduce_returnVoid(IASNode iNode)`
`InstructionList`	`reduce_returnVoidSideEffect(IASNode iNode, InstructionList value)`
`InstructionList`	`reduce_returnVoidValue(IASNode iNode, InstructionList no_value)`
`InstructionList`	`reduce_runtimeAttributeExp(IASNode iNode, InstructionList rt_attr)` Reduce runtime attribute expression, such as `@[exp]`.
`InstructionList`	`reduce_runtimeNameExpression(IASNode iNode, InstructionList expr)`
`Binding`	`reduce_simpleName(IASNode iNode)`
`InstructionList`	`reduce_strictneqExpr(IASNode iNode, InstructionList l, InstructionList r)`
`Binding`	`reduce_superAccess(IASNode iNode, Binding qualified_name)`
`InstructionList`	`reduce_superCallExpr(IASNode iNode, Vector<InstructionList> args)`
`InstructionList`	`reduce_switchStmt(IASNode iNode, InstructionList switch_expr, Vector<ABCGeneratingReducer.ConditionalFragment> cases)`
`InstructionList`	`reduce_ternaryExpr(IASNode iNode, InstructionList test, InstructionList when_true, InstructionList when_false)`
`InstructionList`	`reduce_throwStmt(IASNode iNode, InstructionList tossable)`
`InstructionList`	`reduce_tryCatchFinallyStmt(IASNode iNode, InstructionList try_stmt, InstructionList finally_stmt, Vector<ABCGeneratingReducer.CatchPrototype> catch_blocks)`
`InstructionList`	`reduce_tryCatchStmt(IASNode iNode, InstructionList try_stmt, Vector<ABCGeneratingReducer.CatchPrototype> catch_blocks)`
`InstructionList`	`reduce_tryFinallyStmt(IASNode iNode, InstructionList try_stmt, InstructionList finally_stmt)`
`InstructionList`	`reduce_typedBindableVariableDecl(IASNode iNode, Name name, Binding var_type, Vector<InstructionList> chained_decls)`
`InstructionList`	`reduce_typedBindableVariableDeclWithInitializer(IASNode iNode, Name var_name, Binding var_type, InstructionList var_initializer, Vector<InstructionList> chained_decls)`
`InstructionList`	`reduce_typedFunction_to_statement(IASNode iNode, InstructionList plist, Binding return_type, InstructionList block)`
`InstructionList`	`reduce_typedVariableDecl(IASNode iNode, Name var_name, Binding var_type, Vector<InstructionList> chained_decls)`
`InstructionList`	`reduce_typedVariableDeclWithConstantInitializer(IASNode iNode, Name var_name, Binding var_type, Object constant_var_initializer, Vector<InstructionList> chained_decls)`
`InstructionList`	`reduce_typedVariableDeclWithInitializer(IASNode iNode, Name var_name, Binding var_type, InstructionList var_initializer, Vector<InstructionList> chained_decls)`
`Binding`	`reduce_typedVariableExpression(IASNode iNode, Name var_name, Binding var_type)`
`InstructionList`	`reduce_typelessFunction(IASNode iNode, InstructionList plist, InstructionList block)`
`InstructionList`	`reduce_typeNameParameter(IASNode iNode, Binding param_name)` Reduce a name to an instruction list that can be used in a parameterized type expression.
`InstructionList`	`reduce_typeof_expr(IASNode iNode, InstructionList operand)`
`InstructionList`	`reduce_typeof_name(IASNode iNode, Binding binding)`
`InstructionList`	`reduce_unqualifiedAttributeExpr(IASNode iNode, InstructionList stem, InstructionList rt_attr, int opcode)`
`InstructionList`	`reduce_useNamespaceDirective(IASNode iNode, Binding ns_name)`
`InstructionList`	`reduce_variableExpression(IASNode iNode, Vector<InstructionList> decls)`
`InstructionList`	`reduce_vectorLiteral(IASNode iNode, Binding type_param, Vector<InstructionList> elements)`
`Object`	`reduce_void0Literal_to_constant_value(IASNode iNode)`
`InstructionList`	`reduce_void0Literal_to_object_literal(IASNode iNode)`
`InstructionList`	`reduce_void0Operator(IASNode iNode)`
`InstructionList`	`reduce_voidExpr_to_expression(IASNode iNode)`
`Binding`	`reduce_voidExpr_to_return_type_name(IASNode node)`
`Binding`	`reduce_voidExpr_to_type_name(IASNode node)`
`Object`	`reduce_voidOperator_to_constant_value(IASNode iNode, Object constant_value)`
`InstructionList`	`reduce_voidOperator_to_expression(IASNode iNode, InstructionList expr)`
`InstructionList`	`reduce_whileStmt(IASNode iNode, InstructionList cond, InstructionList body)`
`InstructionList`	`reduce_withStmt(IASNode iNode, InstructionList new_scope, InstructionList body)`
`InstructionList`	`reduce_XMLContent(IASNode iNode, Vector<InstructionList> exprs)`
`InstructionList`	`reduce_XMLList(IASNode iNode, Vector<InstructionList> exprs)`
`InstructionList`	`reduce_XMLListConst(IASNode iNode, Vector<String> elements)`
`InstructionList`	`reduceName_to_mxmlDataBindingSetter(IASNode nameNode, Binding name)` Reduce a compile time constant name ( x ) in an MXML data binding destination to: x = firstParam.
`InstructionList`	`reduceRuntimeName_to_mxmlDataBindingSetter(IASNode runtimeNameNode, org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname runtime_name_expression)` Reduce a runtime name ( nsVar::x ) in an MXML data binding destination to: nsVar::x = firstParam This reduction is used when the qualifer is not a compiler time constant namespace.
`void`	`setCurrentscope(LexicalScope scope)` Set this reducer's initial LexicalScope.
`void`	`setInstanceInitializers(InstructionList insns)` Set this reducer's list of a priori instructions; typically these are field initializers passed in to a constructor routine.
`Object`	`transform_boolean_constant_to_constant(IASNode iNode, Boolean boolean_constant)` transform a boolean_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost
`InstructionList`	`transform_boolean_constant(IASNode iNode, Boolean boolean_constant)`
`InstructionList`	`transform_constant_value(IASNode iNode, Object constant_value)` Transform any constant_value into an expression, so we can constant fold all sorts of expressions.
`InstructionList`	`transform_double_constant(IASNode iNode, Double double_constant)`
`InstructionList`	`transform_expression_to_conditionalJump(IASNode iNode, InstructionList expression)`
`Object`	`transform_expression_to_constant_value(IASNode iNode, InstructionList expression)`
`InstructionList`	`transform_expression_to_void_expression(IASNode iNode, InstructionList expression)`
`InstructionList`	`transform_integer_constant(IASNode iNode, Integer integer_constant)`
`InstructionList`	`transform_long_constant(IASNode iNode, Long long_constant)`
`Object`	`transform_name_to_constant_value(IASNode iNode)`
`InstructionList`	`transform_name_to_expression(IASNode iNode, Binding name)`
`InstructionList`	`transform_non_resolving_identifier(IASNode iNode, String non_resolving_identifier)`
`Object`	`transform_numeric_constant_to_constant(IASNode iNode, Number numeric_constant)` transform a numeric_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost
`InstructionList`	`transform_numeric_constant(IASNode iNode, Number numeric_constant)`
`InstructionList`	`transform_pooled_value(IASNode iNode, PooledValue pooled_value)` Transform any PooledValue into an expression, so we can constant fold all sorts of expressions.
`InstructionList`	`transform_runtime_name_expression(IASNode iNode, org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname runtime_name_expression)`
`Object`	`transform_string_constant_to_constant(IASNode iNode, String string_constant)` transform a string_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost
`InstructionList`	`transform_string_constant(IASNode iNode, String string_constant)`
`InstructionList`	`transform_uint_constant(IASNode iNode, Long uint_constant)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- namespaceType
```
public static final Name namespaceType
```
  A shared name for the Namespace type.
- xmlType
```
public static final Name xmlType
```
  A shared name for the XML type.
- xmlListType
```
public static final Name xmlListType
```
  A shared name for the XMLList type.
- regexType
```
public static final Name regexType
```
  A shared name for the RegExp type.
- voidType
```
public static final Name voidType
```
  A shared name for the void type.
- synthesizedReturnVoid
```
public static final Instruction synthesizedReturnVoid
```
  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.

Constructor Detail
- ABCGeneratingReducer
```
public ABCGeneratingReducer()
```

Method Detail

pushNumericConstant

public static void pushNumericConstant(long value,
                       InstructionList result_list)

Generate code to push a numeric constant.

pushNumericConstant
```
public void pushNumericConstant(InstructionList result_list,
                       Number value,
                       IDefinition type)
```
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.

Parameters:
result_list - IL to add the instruction.
value - the numeric value to push
type - the type of the expression that produced the value.

getProblems
```
public Collection<ICompilerProblem> getProblems()
```
Returns:
the currently active collection of problems.

checkBinaryOp

public void checkBinaryOp(IASNode iNode,
                 int opcode)

Perform semantic checks on a binary operator.

createInstructionList
```
public InstructionList createInstructionList(IASNode iNode)
```
Common routine used by reductions that need an empty list.

Parameters:
iNode - - the current AST node.

createInstructionList
```
public InstructionList createInstructionList(IASNode iNode,
                                    int capacity)
```
Common routine used by reductions that need an empty list.

Parameters:
iNode - - the current AST node.
capacity - - requested capacity of the new list. May be adjusted to accomodate debug instructions.

error_namespaceAccess

public Binding error_namespaceAccess(IASNode iNode,
                            IASNode raw_qualifier,
                            Binding qualified_name)

Error trap.

error_reduce_Op_AssignId

public InstructionList error_reduce_Op_AssignId(IASNode iNode,
                                       InstructionList non_lvalue,
                                       InstructionList rvalue)

Error trap.

reduce_typeNameParameter
```
public InstructionList reduce_typeNameParameter(IASNode iNode,
                                       Binding param_name)
```
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.

Parameters:
iNode - the node
param_name - the name to reduce

Returns:
IL with instructions to push the appropriate value on the stack

prologue_anonymousFunction

public void prologue_anonymousFunction(IASNode iNode)

prologue_functionObject

public void prologue_functionObject(IASNode iNode)

prologue_blockStmt

public void prologue_blockStmt(IASNode iNode)

prologue_blockStmt_to_finally_clause

public void prologue_blockStmt_to_finally_clause(IASNode iNode)

prologue_catchBlock

public void prologue_catchBlock(IASNode iNode)

prologue_countedForStmt

public void prologue_countedForStmt(IASNode iNode)

prologue_doStmt

public void prologue_doStmt(IASNode iNode)

prologue_forEachStmt

public void prologue_forEachStmt(IASNode iNode)

prologue_forInStmt

public void prologue_forInStmt(IASNode iNode)

prologue_labeledStmt

public void prologue_labeledStmt(IASNode iNode)

prologue_mxmlEventSpecifier

public void prologue_mxmlEventSpecifier(IASNode iNode)

prologue_switchStmt

public void prologue_switchStmt(IASNode iNode)

prologue_tryCatchFinallyStmt

public void prologue_tryCatchFinallyStmt(IASNode iNode)

prologue_tryCatchStmt

public void prologue_tryCatchStmt(IASNode iNode)

prologue_tryFinallyStmt

public void prologue_tryFinallyStmt(IASNode iNode)

prologue_typedFunction_to_statement

public void prologue_typedFunction_to_statement(IASNode iNode)

prologue_typelessFunction_to_statement

public void prologue_typelessFunction_to_statement(IASNode iNode)

prologue_typeof
```
public void prologue_typeof(IASNode iNode)
```
Before reducing the operands of a typeof, we need to increment the typeof counter. It will be decremented by the reduction's epilogue.

prologue_whileStmt

public void prologue_whileStmt(IASNode iNode)

prologue_withStmt

public void prologue_withStmt(IASNode iNode)

reduce_anonymousFunction

public InstructionList reduce_anonymousFunction(IASNode iNode,
                                       InstructionList function_body)

reduce_functionObject

public InstructionList reduce_functionObject(IASNode iNode,
                                    IASNode function_name,
                                    InstructionList plist,
                                    Binding return_binding,
                                    InstructionList function_body)

reduce_arrayIndexExpr

public InstructionList reduce_arrayIndexExpr(IASNode iNode,
                                    InstructionList stem,
                                    boolean is_super,
                                    InstructionList index)

reduce_arrayLiteral

public InstructionList reduce_arrayLiteral(IASNode iNode,
                                  Vector<InstructionList> elements)

reduce_assignToBracketExpr_to_expression

public InstructionList reduce_assignToBracketExpr_to_expression(IASNode iNode,
                                                       InstructionList stem,
                                                       InstructionList index,
                                                       InstructionList r,
                                                       boolean is_super)

reduce_assignToBracketExpr_to_void_expression

public InstructionList reduce_assignToBracketExpr_to_void_expression(IASNode iNode,
                                                            InstructionList stem,
                                                            InstructionList index,
                                                            InstructionList r,
                                                            boolean is_super)

reduce_assignToMemberExpr_to_expression

public InstructionList reduce_assignToMemberExpr_to_expression(IASNode iNode,
                                                      InstructionList stem,
                                                      Binding member,
                                                      InstructionList r)

reduce_assignToMemberExpr_to_void_expression

public InstructionList reduce_assignToMemberExpr_to_void_expression(IASNode iNode,
                                                           InstructionList stem,
                                                           Binding member,
                                                           InstructionList r)

reduce_assignToDescendantsExpr

public InstructionList reduce_assignToDescendantsExpr(IASNode iNode,
                                             InstructionList stem,
                                             Binding member,
                                             InstructionList r,
                                             boolean need_value)

reduce_assignToNameExpr_to_void_expression

public InstructionList reduce_assignToNameExpr_to_void_expression(IASNode iNode,
                                                         Binding lvalue,
                                                         InstructionList r)

reduce_assignToNameExpr_to_expression

public InstructionList reduce_assignToNameExpr_to_expression(IASNode iNode,
                                                    Binding lvalue,
                                                    InstructionList r)

reduce_assignToQualifiedMemberExpr

public InstructionList reduce_assignToQualifiedMemberExpr(IASNode iNode,
                                                 InstructionList stem,
                                                 Binding qualifier,
                                                 Binding member,
                                                 InstructionList rhs,
                                                 boolean need_value)

reduce_assignToQualifiedRuntimeMemberExpr

public InstructionList reduce_assignToQualifiedRuntimeMemberExpr(IASNode iNode,
                                                        InstructionList stem,
                                                        Binding qualifier,
                                                        InstructionList runtime_member_selector,
                                                        InstructionList rhs,
                                                        boolean need_value)

reduce_assignToQualifiedAttributeExpr

public InstructionList reduce_assignToQualifiedAttributeExpr(IASNode iNode,
                                                    InstructionList stem,
                                                    Binding qualifier,
                                                    Binding member,
                                                    InstructionList rhs,
                                                    boolean need_value)

reduce_assignToQualifiedRuntimeAttributeExpr

public InstructionList reduce_assignToQualifiedRuntimeAttributeExpr(IASNode iNode,
                                                           InstructionList stem,
                                                           Binding qualifier,
                                                           InstructionList runtime_member_selector,
                                                           InstructionList rhs,
                                                           boolean need_value)

reduce_assignToRuntimeNameExpr

public InstructionList reduce_assignToRuntimeNameExpr(IASNode iNode,
                                             org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname lval,
                                             InstructionList r,
                                             boolean need_value)

reduce_assignToUnqualifiedRuntimeAttributeExpr

public InstructionList reduce_assignToUnqualifiedRuntimeAttributeExpr(IASNode iNode,
                                                             InstructionList stem,
                                                             InstructionList rt_attr,
                                                             InstructionList rhs,
                                                             boolean need_value)

reduce_attributeName

public Binding reduce_attributeName(IASNode iNode,
                           Binding attr_name)

reduce_blockStmt_to_finally_clause

public InstructionList reduce_blockStmt_to_finally_clause(IASNode iNode,
                                                 Vector<InstructionList> stmts)

reduce_blockStmt_to_statement

public InstructionList reduce_blockStmt_to_statement(IASNode iNode,
                                            Vector<InstructionList> stmts)

reduce_booleanLiteral

public Boolean reduce_booleanLiteral(IASNode iNode)

reduce_breakStmt

public InstructionList reduce_breakStmt(IASNode iNode)

reduce_by_concatenation

public String reduce_by_concatenation(IASNode iNode,
                             String first,
                             String second)

reduce_catchBlockTyped

public ABCGeneratingReducer.CatchPrototype reduce_catchBlockTyped(IASNode iNode,
                                                         Binding var_name,
                                                         Binding exception,
                                                         InstructionList action)

reduce_catchBlockUntyped

public ABCGeneratingReducer.CatchPrototype reduce_catchBlockUntyped(IASNode iNode,
                                                           Binding var_name,
                                                           InstructionList action)

reduce_commaExpr

public InstructionList reduce_commaExpr(IASNode iNode,
                               InstructionList payload_expr,
                               Vector<InstructionList> exprs)

reduce_conditionalFragment

public ABCGeneratingReducer.ConditionalFragment reduce_conditionalFragment(IASNode iNode,
                                                                  InstructionList condition,
                                                                  Vector<InstructionList> consequents)

reduce_constantConditionalFragment

public ABCGeneratingReducer.ConditionalFragment reduce_constantConditionalFragment(IASNode iNode,
                                                                          Object constantCondition,
                                                                          Vector<InstructionList> consequents)

reduce_constantStringConcatenation

public String reduce_constantStringConcatenation(IASNode iNode,
                                        String l,
                                        String r)

reduce a concatenation of two strings to a string constant

Parameters:: iNode - the node; l - the left string; r - the right string
Returns:: the concatenated string

reduce_constantStringConcatenation
```
public String reduce_constantStringConcatenation(IASNode iNode,
                                        String l,
                                        Object 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.

Parameters:
iNode - the node
l - the left string
r - the right value

Returns:
the concatenated string

reduce_constantStringConcatenation
```
public String reduce_constantStringConcatenation(IASNode iNode,
                                        Object l,
                                        String 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.

Parameters:
iNode - the node
l - the left value
r - the right string

Returns:
the concatenated string

reduce_constantAddition
```
public Object reduce_constantAddition(IASNode iNode,
                             Object l,
                             Object 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

Parameters:
iNode - the node
l - the left value
r - the right value

Returns:
the result of adding the two values

reduce_continueStmt

public InstructionList reduce_continueStmt(IASNode iNode)

reduce_countedForStmt

public InstructionList reduce_countedForStmt(IASNode iNode,
                                    InstructionList init,
                                    InstructionList test_insns,
                                    InstructionList incr,
                                    InstructionList body)

reduce_defaultXMLNamespace

public InstructionList reduce_defaultXMLNamespace(IASNode iNode,
                                         InstructionList ns_expr)

reduce_deleteBracketExpr

public InstructionList reduce_deleteBracketExpr(IASNode iNode,
                                       InstructionList stem,
                                       InstructionList index)

Reduce expression like:
delete o[p]

Parameters:: iNode - Tree node for the delete statement.; stem - Instructions for creating a DynamicAccessNode.; index - Instructions for initializing the index expression.
Returns:: Instructions for executing a delete statement.

reduce_deleteAtBracketExpr
```
public InstructionList reduce_deleteAtBracketExpr(IASNode iNode,
                                         InstructionList stem,
                                         InstructionList index)
```
Reduce E4X expression like:
delete x.@[foo]

Parameters:
iNode - Tree node for the delete statement.
stem - Instructions for creating a MemberAccessExpressionNode.
index - Instructions for initializing the array index expression.

Returns:
Instructions for executing a delete statement.

reduce_deleteDescendantsExpr

public InstructionList reduce_deleteDescendantsExpr(IASNode iNode,
                                           InstructionList stem,
                                           Binding field)

reduce_deleteExprExprExpr

public InstructionList reduce_deleteExprExprExpr(IASNode iNode,
                                        InstructionList expr)

reduce_deleteMemberExpr

public InstructionList reduce_deleteMemberExpr(IASNode iNode,
                                      InstructionList stem,
                                      Binding field)

reduce_deleteRuntimeNameExpr

public InstructionList reduce_deleteRuntimeNameExpr(IASNode iNode,
                                           InstructionList stem,
                                           org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname rt_name)

reduce_deleteNameExpr

public InstructionList reduce_deleteNameExpr(IASNode iNode,
                                    Binding n)

reduce_doStmt

public InstructionList reduce_doStmt(IASNode iNode,
                            InstructionList body,
                            InstructionList cond)

reduce_e4xFilter

public InstructionList reduce_e4xFilter(IASNode iNode,
                               InstructionList stem,
                               InstructionList filter)

reduce_embed

public InstructionList reduce_embed(IASNode iNode)

reduce_forKeyValueStmt

public InstructionList reduce_forKeyValueStmt(IASNode iNode,
                                     Binding it,
                                     InstructionList base,
                                     InstructionList body,
                                     int opcode)

reduce_forVarDeclInStmt

public InstructionList reduce_forVarDeclInStmt(IASNode iNode,
                                      InstructionList single_decl,
                                      InstructionList base,
                                      InstructionList body,
                                      int opcode)

Reduce for(it in base) or for each(it in base) loop with variable initializer.

Parameters:: iNode - ForLoopNode; single_decl - Instructions to initialize a loop variable.; base - Instructions to create a loop base.; body - For loop body instructions.; opcode - Use OP_nextname for "for" loops; use OP_nextvalue for "for each" loops.
Returns:: Instructions generated for the "for" loop node.

reduce_forKeyValueArrayStmt

public InstructionList reduce_forKeyValueArrayStmt(IASNode iNode,
                                          InstructionList stem,
                                          InstructionList index,
                                          InstructionList base,
                                          InstructionList body,
                                          int opcode,
                                          boolean is_super)

Reduce statement like:
for (a[it] in base) body;

Parameters:: iNode - Tree node for the for-in loop.; stem - Instructions for creating a DynamicAccessNode.; index - Instructions for initializing the index expression.; base - Instructions for initializing the base object of the in expression.; body - Instructions for initializing the body of the for-loop.; opcode - Opcode for nextname or ,code>nextvalue instruction.; is_super - Flag indicating whether the stem of the array index expression is super.
Returns:: Instructions for executing the for-in statement.

reduce_forKeyValueMemberStmt

public InstructionList reduce_forKeyValueMemberStmt(IASNode iNode,
                                           InstructionList stem,
                                           Binding member,
                                           InstructionList base,
                                           InstructionList body,
                                           int opcode,
                                           boolean is_super)

reduce_functionAsBracketExpr

public InstructionList reduce_functionAsBracketExpr(IASNode iNode,
                                           InstructionList stem,
                                           InstructionList index,
                                           Vector<InstructionList> args)

Reduce expression like:
a[i]()

Parameters:: iNode - Tree node for the function call.; stem - Instructions for creating a DynamicAccessNode.; index - Instructions for initializing the index expression.
Returns:: Instructions for executing a function call statement.

reduce_functionAsMemberExpr

public InstructionList reduce_functionAsMemberExpr(IASNode iNode,
                                          InstructionList stem,
                                          Binding method_name,
                                          Vector<InstructionList> args)

reduce_functionAsRandomExpr

public InstructionList reduce_functionAsRandomExpr(IASNode iNode,
                                          InstructionList random_expr,
                                          Vector<InstructionList> args)

reduce_functionCallExpr_to_expression

public InstructionList reduce_functionCallExpr_to_expression(IASNode iNode,
                                                    Binding method_name,
                                                    Vector<InstructionList> args)

reduce_functionCallExpr_to_void_expression

public InstructionList reduce_functionCallExpr_to_void_expression(IASNode iNode,
                                                         Binding method_name,
                                                         Vector<InstructionList> args)

reduce_functionCallOfSuperclassMethod_to_expression

public InstructionList reduce_functionCallOfSuperclassMethod_to_expression(IASNode iNode,
                                                                  InstructionList stem,
                                                                  Binding method_name,
                                                                  Vector<InstructionList> args)

reduce_functionCallOfSuperclassMethod_to_void_expression

public InstructionList reduce_functionCallOfSuperclassMethod_to_void_expression(IASNode iNode,
                                                                       InstructionList stem,
                                                                       Binding method_name,
                                                                       Vector<InstructionList> args)

reduce_groupedVoidExpression

public InstructionList reduce_groupedVoidExpression(IASNode iNode,
                                           Vector<InstructionList> contents)

reduce_ifElseIf

public InstructionList reduce_ifElseIf(IASNode iNode,
                              InstructionList test,
                              InstructionList then,
                              Vector<ABCGeneratingReducer.ConditionalFragment> if_elseif)

reduce_importDirective

public InstructionList reduce_importDirective(IASNode iNode)

reduce_labeledBreakStmt

public InstructionList reduce_labeledBreakStmt(IASNode iNode)

reduce_labeledContinueStmt

public InstructionList reduce_labeledContinueStmt(IASNode iNode)

reduce_gotoStmt

public InstructionList reduce_gotoStmt(IASNode iNode)

reduce_labeledStmt

public InstructionList reduce_labeledStmt(IASNode iNode,
                                 String label,
                                 InstructionList substatement)

reduce_lastElse

public ABCGeneratingReducer.ConditionalFragment reduce_lastElse(IASNode iNode,
                                                       InstructionList else_clause)

reduce_logicalAndExpr

public InstructionList reduce_logicalAndExpr(IASNode iNode,
                                    InstructionList l,
                                    InstructionList r)

reduce_logicalNotExpr

public InstructionList reduce_logicalNotExpr(IASNode iNode,
                                    InstructionList expr)

reduce_logicalOrExpr

public InstructionList reduce_logicalOrExpr(IASNode iNode,
                                   InstructionList l,
                                   InstructionList r)

reduce_memberAccessExpr

public InstructionList reduce_memberAccessExpr(IASNode iNode,
                                      InstructionList stem,
                                      Binding member,
                                      int opcode)

reduce_qualifiedMemberAccessExpr

public InstructionList reduce_qualifiedMemberAccessExpr(IASNode iNode,
                                               InstructionList stem,
                                               Binding qualifier,
                                               Binding member,
                                               int opcode)

reduce_qualifiedAttributeRuntimeMemberExpr

public InstructionList reduce_qualifiedAttributeRuntimeMemberExpr(IASNode iNode,
                                                         InstructionList stem,
                                                         Binding qualifier,
                                                         InstructionList runtime_member_selector,
                                                         int opcode)

reduce_qualifiedMemberRuntimeNameExpr

public InstructionList reduce_qualifiedMemberRuntimeNameExpr(IASNode iNode,
                                                    InstructionList stem,
                                                    Binding qualifier,
                                                    InstructionList runtime_member_selector)

reduce_qualifiedAttributeExpr

public InstructionList reduce_qualifiedAttributeExpr(IASNode iNode,
                                            InstructionList stem,
                                            Binding qualifier,
                                            Binding member,
                                            int opcode)

reduce_unqualifiedAttributeExpr

public InstructionList reduce_unqualifiedAttributeExpr(IASNode iNode,
                                              InstructionList stem,
                                              InstructionList rt_attr,
                                              int opcode)

reduce_runtimeAttributeExp
```
public InstructionList reduce_runtimeAttributeExp(IASNode iNode,
                                         InstructionList rt_attr)
```
Reduce runtime attribute expression, such as @[exp].

Parameters:
iNode - Node for @[...]. It is a ArrayIndexExpressionID(Op_AtID, ...).
rt_attr - Instructions generated for the runtime name expression.

Returns:
Instructions to get the value of an attribute described with a runtime name.

reduce_mxmlEventSpecifier

public InstructionList reduce_mxmlEventSpecifier(IASNode iNode,
                                        Vector<InstructionList> stmts)

reduce_namespaceAccess

public Binding reduce_namespaceAccess(IASNode iNode,
                             IASNode qualifier,
                             Binding qualified_name)

reduce_namespaceAccess_to_runtime_name

public org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname reduce_namespaceAccess_to_runtime_name(IASNode iNode,
                                                                                                                        Binding qualified_name)

reduce_namespaceAsName_to_expression

public InstructionList reduce_namespaceAsName_to_expression(IASNode iNode)

reduce_namespaceAsName_to_multinameL

public Name reduce_namespaceAsName_to_multinameL(IASNode iNode)

reduce_namespaceAsName_to_multinameL

public Name reduce_namespaceAsName_to_multinameL(IASNode iNode,
                                        boolean is_attribute)

reduce_namespaceAsName_to_name

public Binding reduce_namespaceAsName_to_name(IASNode iNode)

reduce_namespaceDeclaration

public InstructionList reduce_namespaceDeclaration(IASNode iNode,
                                          Binding ns_name)

reduce_namespaceDeclarationConstantInitializer

public InstructionList reduce_namespaceDeclarationConstantInitializer(IASNode iNode,
                                                             Binding ns_name,
                                                             String uri)

reduce_namespaceDeclarationConstantInitializer

public InstructionList reduce_namespaceDeclarationConstantInitializer(IASNode iNode,
                                                             Binding ns_name,
                                                             Namespace initializer)

Does the work for the various reduce_namespaceDecl methods. Creates a new property, with an initial value of the Namespace passed in.

reduce_namespaceDeclarationInitializer

public InstructionList reduce_namespaceDeclarationInitializer(IASNode iNode,
                                                     Binding ns_name,
                                                     Binding second_ns)

reduce_namespaceMultinameL

public org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname reduce_namespaceMultinameL(IASNode iNode,
                                                                                                            IASNode qualifier_node,
                                                                                                            InstructionList expr)

reduce_namespaceRTQName

public org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname reduce_namespaceRTQName(IASNode iNode,
                                                                                                         InstructionList qualifier,
                                                                                                         Binding qualified_name)

reduce_namespaceRTQNameL

public org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname reduce_namespaceRTQNameL(IASNode iNode,
                                                                                                          InstructionList qualifier,
                                                                                                          InstructionList expr)

reduce_neqExpr

public InstructionList reduce_neqExpr(IASNode iNode,
                             InstructionList l,
                             InstructionList r)

reduce_nameToTypeName

public Binding reduce_nameToTypeName(Binding name,
                            boolean check_name)

reduce_newMemberProperty

public InstructionList reduce_newMemberProperty(IASNode iNode,
                                       InstructionList stem,
                                       Binding member,
                                       Vector<InstructionList> args)

reduce_newAsRandomExpr

public InstructionList reduce_newAsRandomExpr(IASNode iNode,
                                     InstructionList random_expr,
                                     Vector<InstructionList> args)

reduce_newEmptyArray

public InstructionList reduce_newEmptyArray(IASNode iNode)

reduce_newEmptyObject

public InstructionList reduce_newEmptyObject(IASNode iNode)

reduce_newExpr

public InstructionList reduce_newExpr(IASNode iNode,
                             Binding class_binding,
                             Vector<InstructionList> args)

reduce_newVectorLiteral

public InstructionList reduce_newVectorLiteral(IASNode iNode,
                                      InstructionList literal)

reduce_nilExpr_to_conditionalJump

public InstructionList reduce_nilExpr_to_conditionalJump(IASNode iNode)

reduce_nilExpr_to_expression

public InstructionList reduce_nilExpr_to_expression(IASNode iNode)

reduce_nullLiteral_to_constant_value

public Object reduce_nullLiteral_to_constant_value(IASNode iNode)

reduce_nullLiteral_to_object_literal

public InstructionList reduce_nullLiteral_to_object_literal(IASNode iNode)

reduce_objectLiteral

public InstructionList reduce_objectLiteral(IASNode iNode,
                                   Vector<InstructionList> elements)

reduce_objectLiteralElement

public InstructionList reduce_objectLiteralElement(IASNode iNode,
                                          InstructionList id,
                                          InstructionList value)

reduce_optionalParameter

public InstructionList reduce_optionalParameter(IASNode iNode,
                                       Name param_name,
                                       Binding param_type,
                                       Object raw_default_value)

reduce_parameterizedName

public Binding reduce_parameterizedName(IASNode iNode,
                               Binding base,
                               Binding param)

reduce_parameterizedTypeExpression

public InstructionList reduce_parameterizedTypeExpression(IASNode iNode,
                                                 InstructionList base,
                                                 InstructionList param)

reduce_plist

public InstructionList reduce_plist(IASNode iNode,
                           Vector<InstructionList> pdecl)

reduce_postDecBracketExpr

public InstructionList reduce_postDecBracketExpr(IASNode iNode,
                                        InstructionList stem,
                                        InstructionList index,
                                        boolean need_result)

reduce_postDecMemberExpr

public InstructionList reduce_postDecMemberExpr(IASNode iNode,
                                       InstructionList stem,
                                       Binding field,
                                       boolean need_result)

reduce_postDecNameExpr

public InstructionList reduce_postDecNameExpr(IASNode iNode,
                                     Binding unary,
                                     boolean need_result)

reduce_postIncBracketExpr

public InstructionList reduce_postIncBracketExpr(IASNode iNode,
                                        InstructionList stem,
                                        InstructionList index,
                                        boolean need_result)

reduce_postIncMemberExpr

public InstructionList reduce_postIncMemberExpr(IASNode iNode,
                                       InstructionList stem,
                                       Binding field,
                                       boolean need_result)

reduce_postIncNameExpr

public InstructionList reduce_postIncNameExpr(IASNode iNode,
                                     Binding unary,
                                     boolean need_result)

reduce_preDecBracketExpr

public InstructionList reduce_preDecBracketExpr(IASNode iNode,
                                       InstructionList stem,
                                       InstructionList index,
                                       boolean need_result)

reduce_preDecMemberExpr

public InstructionList reduce_preDecMemberExpr(IASNode iNode,
                                      InstructionList stem,
                                      Binding field,
                                      boolean need_result)

reduce_preDecNameExpr

public InstructionList reduce_preDecNameExpr(IASNode iNode,
                                    Binding unary,
                                    boolean need_result)

reduce_preIncBracketExpr

public InstructionList reduce_preIncBracketExpr(IASNode iNode,
                                       InstructionList stem,
                                       InstructionList index,
                                       boolean need_result)

reduce_preIncMemberExpr

public InstructionList reduce_preIncMemberExpr(IASNode iNode,
                                      InstructionList stem,
                                      Binding field,
                                      boolean need_result)

reduce_preIncNameExpr

public InstructionList reduce_preIncNameExpr(IASNode iNode,
                                    Binding unary,
                                    boolean need_result)

coerce
```
public void coerce(InstructionList il,
          IDefinition toType)
```
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.

Parameters:
il - the InstructionList to add the instruction to
toType - the type you want to coerce the top stack value to

reduce_regexLiteral

public InstructionList reduce_regexLiteral(IASNode iNode)

reduce_requiredParameter

public InstructionList reduce_requiredParameter(IASNode iNode,
                                       Name param_name,
                                       Binding param_type)

reduce_restParameter

public InstructionList reduce_restParameter(IASNode iNode,
                                   Name param_name,
                                   Binding param_type)

reduce_returnVoidSideEffect

public InstructionList reduce_returnVoidSideEffect(IASNode iNode,
                                          InstructionList value)

reduce_returnValue

public InstructionList reduce_returnValue(IASNode iNode,
                                 InstructionList value)

reduce_returnVoidValue

public InstructionList reduce_returnVoidValue(IASNode iNode,
                                     InstructionList no_value)

reduce_returnVoid

public InstructionList reduce_returnVoid(IASNode iNode)

reduce_runtimeNameExpression

public InstructionList reduce_runtimeNameExpression(IASNode iNode,
                                           InstructionList expr)

reduce_simpleName

public Binding reduce_simpleName(IASNode iNode)

reduce_declName

public Name reduce_declName(IASNode iNode)

reduce_strictneqExpr

public InstructionList reduce_strictneqExpr(IASNode iNode,
                                   InstructionList l,
                                   InstructionList r)

reduce_superAccess

public Binding reduce_superAccess(IASNode iNode,
                         Binding qualified_name)

reduce_superCallExpr

public InstructionList reduce_superCallExpr(IASNode iNode,
                                   Vector<InstructionList> args)

reduce_switchStmt

public InstructionList reduce_switchStmt(IASNode iNode,
                                InstructionList switch_expr,
                                Vector<ABCGeneratingReducer.ConditionalFragment> cases)

reduce_ternaryExpr

public InstructionList reduce_ternaryExpr(IASNode iNode,
                                 InstructionList test,
                                 InstructionList when_true,
                                 InstructionList when_false)

reduce_throwStmt

public InstructionList reduce_throwStmt(IASNode iNode,
                               InstructionList tossable)

reduce_tryCatchFinallyStmt

public InstructionList reduce_tryCatchFinallyStmt(IASNode iNode,
                                         InstructionList try_stmt,
                                         InstructionList finally_stmt,
                                         Vector<ABCGeneratingReducer.CatchPrototype> catch_blocks)

reduce_tryCatchStmt

public InstructionList reduce_tryCatchStmt(IASNode iNode,
                                  InstructionList try_stmt,
                                  Vector<ABCGeneratingReducer.CatchPrototype> catch_blocks)

reduce_tryFinallyStmt

public InstructionList reduce_tryFinallyStmt(IASNode iNode,
                                    InstructionList try_stmt,
                                    InstructionList finally_stmt)

reduce_typedFunction_to_statement

public InstructionList reduce_typedFunction_to_statement(IASNode iNode,
                                                InstructionList plist,
                                                Binding return_type,
                                                InstructionList block)

reduce_typedVariableDecl

public InstructionList reduce_typedVariableDecl(IASNode iNode,
                                       Name var_name,
                                       Binding var_type,
                                       Vector<InstructionList> chained_decls)

reduce_typedVariableDeclWithInitializer

public InstructionList reduce_typedVariableDeclWithInitializer(IASNode iNode,
                                                      Name var_name,
                                                      Binding var_type,
                                                      InstructionList var_initializer,
                                                      Vector<InstructionList> chained_decls)

reduce_typedVariableDeclWithConstantInitializer

public InstructionList reduce_typedVariableDeclWithConstantInitializer(IASNode iNode,
                                                              Name var_name,
                                                              Binding var_type,
                                                              Object constant_var_initializer,
                                                              Vector<InstructionList> chained_decls)

reduce_typedBindableVariableDecl

public InstructionList reduce_typedBindableVariableDecl(IASNode iNode,
                                               Name name,
                                               Binding var_type,
                                               Vector<InstructionList> chained_decls)

reduce_typedBindableVariableDeclWithInitializer

public InstructionList reduce_typedBindableVariableDeclWithInitializer(IASNode iNode,
                                                              Name var_name,
                                                              Binding var_type,
                                                              InstructionList var_initializer,
                                                              Vector<InstructionList> chained_decls)

reduce_typedVariableExpression

public Binding reduce_typedVariableExpression(IASNode iNode,
                                     Name var_name,
                                     Binding var_type)

reduce_typelessFunction

public InstructionList reduce_typelessFunction(IASNode iNode,
                                      InstructionList plist,
                                      InstructionList block)

reduce_typeof_expr

public InstructionList reduce_typeof_expr(IASNode iNode,
                                 InstructionList operand)

reduce_typeof_name

public InstructionList reduce_typeof_name(IASNode iNode,
                                 Binding binding)

reduce_useNamespaceDirective

public InstructionList reduce_useNamespaceDirective(IASNode iNode,
                                           Binding ns_name)

reduce_variableExpression

public InstructionList reduce_variableExpression(IASNode iNode,
                                        Vector<InstructionList> decls)

reduce_vectorLiteral

public InstructionList reduce_vectorLiteral(IASNode iNode,
                                   Binding type_param,
                                   Vector<InstructionList> elements)

reduce_voidExpr_to_expression

public InstructionList reduce_voidExpr_to_expression(IASNode iNode)

reduce_voidExpr_to_return_type_name

public Binding reduce_voidExpr_to_return_type_name(IASNode node)

reduce_voidExpr_to_type_name

public Binding reduce_voidExpr_to_type_name(IASNode node)

reduce_void0Literal_to_constant_value

public Object reduce_void0Literal_to_constant_value(IASNode iNode)

reduce_void0Literal_to_object_literal

public InstructionList reduce_void0Literal_to_object_literal(IASNode iNode)

reduce_instructionListExpression

public InstructionList reduce_instructionListExpression(IASNode iNode)

reduce_void0Operator

public InstructionList reduce_void0Operator(IASNode iNode)

reduce_voidOperator_to_constant_value

public Object reduce_voidOperator_to_constant_value(IASNode iNode,
                                           Object constant_value)

reduce_voidOperator_to_expression

public InstructionList reduce_voidOperator_to_expression(IASNode iNode,
                                                InstructionList expr)

reduce_whileStmt

public InstructionList reduce_whileStmt(IASNode iNode,
                               InstructionList cond,
                               InstructionList body)

reduce_withStmt

public InstructionList reduce_withStmt(IASNode iNode,
                              InstructionList new_scope,
                              InstructionList body)

reduce_XMLContent

public InstructionList reduce_XMLContent(IASNode iNode,
                                Vector<InstructionList> exprs)

reduce_XMLList

public InstructionList reduce_XMLList(IASNode iNode,
                             Vector<InstructionList> exprs)

reduce_XMLListConst

public InstructionList reduce_XMLListConst(IASNode iNode,
                                  Vector<String> elements)

setInstanceInitializers
```
public void setInstanceInitializers(InstructionList insns)
```
Set this reducer's list of a priori instructions; typically these are field initializers passed in to a constructor routine.

setCurrentscope
```
public void setCurrentscope(LexicalScope scope)
```
Set this reducer's initial LexicalScope.

transform_boolean_constant

public InstructionList transform_boolean_constant(IASNode iNode,
                                         Boolean boolean_constant)

transform_double_constant

public InstructionList transform_double_constant(IASNode iNode,
                                        Double double_constant)

transform_numeric_constant

public InstructionList transform_numeric_constant(IASNode iNode,
                                         Number numeric_constant)

transform_pooled_value
```
public InstructionList transform_pooled_value(IASNode iNode,
                                     PooledValue pooled_value)
```
Transform any PooledValue into an expression, so we can constant fold all sorts of expressions.

Parameters:
iNode - the node that generated the constant_value
pooled_value - the pooled value

Returns:
an InstructionList that contains instructions to push the pooled_value onto the stack.

transform_constant_value
```
public InstructionList transform_constant_value(IASNode iNode,
                                       Object constant_value)
```
Transform any constant_value into an expression, so we can constant fold all sorts of expressions.

Parameters:
iNode - the node that generated the constant_value
constant_value - the constant value

Returns:
an InstructionList that contains instructions to push the constant_value onto the stack.

transform_string_constant_to_constant

public Object transform_string_constant_to_constant(IASNode iNode,
                                           String string_constant)

transform a string_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost

transform_boolean_constant_to_constant

public Object transform_boolean_constant_to_constant(IASNode iNode,
                                            Boolean boolean_constant)

transform a boolean_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost

transform_numeric_constant_to_constant

public Object transform_numeric_constant_to_constant(IASNode iNode,
                                            Number numeric_constant)

transform a numeric_constant to a constant_value - essentially a no-op, but need a reduction so we can assign it a cost

transform_expression_to_conditionalJump

public InstructionList transform_expression_to_conditionalJump(IASNode iNode,
                                                      InstructionList expression)

transform_expression_to_constant_value

public Object transform_expression_to_constant_value(IASNode iNode,
                                            InstructionList expression)

transform_expression_to_void_expression

public InstructionList transform_expression_to_void_expression(IASNode iNode,
                                                      InstructionList expression)

transform_integer_constant

public InstructionList transform_integer_constant(IASNode iNode,
                                         Integer integer_constant)

transform_long_constant

public InstructionList transform_long_constant(IASNode iNode,
                                      Long long_constant)

transform_name_to_constant_value

public Object transform_name_to_constant_value(IASNode iNode)

transform_name_to_expression

public InstructionList transform_name_to_expression(IASNode iNode,
                                           Binding name)

transform_non_resolving_identifier

public InstructionList transform_non_resolving_identifier(IASNode iNode,
                                                 String non_resolving_identifier)

transform_runtime_name_expression

public InstructionList transform_runtime_name_expression(IASNode iNode,
                                                org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname runtime_name_expression)

transform_string_constant

public InstructionList transform_string_constant(IASNode iNode,
                                        String string_constant)

transform_uint_constant

public InstructionList transform_uint_constant(IASNode iNode,
                                      Long uint_constant)

checkUnaryOp

public void checkUnaryOp(IASNode iNode,
                int opcode)

isStringLiteral
```
public static boolean isStringLiteral(InstructionList insns)
```
Is this expression a string literal?

Returns:
true if the expression is a string literal, i.e., it has one pushstring instruction.

getStringLiteral
```
public static String getStringLiteral(InstructionList insns)
```
Extract the string literal from an InstructionList.

Parameters:
insns - - the InstructionList of interest.

Returns:
the string literal from insns' final (and presumably only executable) instruction.

reduce_arrayIndexExpr_to_mxmlDataBindingSetter

public InstructionList reduce_arrayIndexExpr_to_mxmlDataBindingSetter(IASNode iNode,
                                                             InstructionList stem,
                                                             InstructionList index,
                                                             boolean isSuper)

Reduce a array index expression ( a[x] ) in an MXML data binding destination to: a[x] = firstParam

reduce_memberAccessExpr_to_mxmlDataBindingSetter

public InstructionList reduce_memberAccessExpr_to_mxmlDataBindingSetter(IASNode memberAccessExpr,
                                                               InstructionList stem,
                                                               Binding member)

Reduce a member access expression ( a.b ) in an MXML data binding destination to: a.b = firstParam

reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter

public InstructionList reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberAccessExpr,
                                                                        InstructionList stem,
                                                                        Binding qualifier,
                                                                        Binding member)

Reduce a qualified member access expression ( a.ns::b ) in an MXML data binding destination to: a.ns::b = firstParam

reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter

public InstructionList reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter(IASNode qualifiedMemberRuntimeExpr,
                                                                             InstructionList stem,
                                                                             Binding qualifier,
                                                                             InstructionList runtime_member)

Reduce a qualified member access expression ( a.ns::["b"] ) in an MXML data binding destination to: a.ns::["b"] = firstParam

reduceRuntimeName_to_mxmlDataBindingSetter

public InstructionList reduceRuntimeName_to_mxmlDataBindingSetter(IASNode runtimeNameNode,
                                                         org.apache.flex.compiler.internal.as.codegen.ABCGeneratingReducer.RuntimeMultiname runtime_name_expression)

Reduce a runtime name ( nsVar::x ) in an MXML data binding destination to: nsVar::x = firstParam

This reduction is used when the qualifer is not a compiler time constant namespace.

reduceName_to_mxmlDataBindingSetter

public InstructionList reduceName_to_mxmlDataBindingSetter(IASNode nameNode,
                                                  Binding name)

Reduce a compile time constant name ( x ) in an MXML data binding destination to: x = firstParam.

Class ABCGeneratingReducer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

namespaceType

xmlType

xmlListType

regexType

voidType

synthesizedReturnVoid

Constructor Detail

ABCGeneratingReducer

Method Detail

pushNumericConstant

pushNumericConstant

getProblems

checkBinaryOp

createInstructionList

createInstructionList

error_namespaceAccess

error_reduce_Op_AssignId

reduce_typeNameParameter

prologue_anonymousFunction

prologue_functionObject

prologue_blockStmt

prologue_blockStmt_to_finally_clause

prologue_catchBlock

prologue_countedForStmt

prologue_doStmt

prologue_forEachStmt

prologue_forInStmt

prologue_labeledStmt

prologue_mxmlEventSpecifier

prologue_switchStmt

prologue_tryCatchFinallyStmt

prologue_tryCatchStmt

prologue_tryFinallyStmt

prologue_typedFunction_to_statement

prologue_typelessFunction_to_statement

prologue_typeof

prologue_whileStmt

prologue_withStmt

reduce_anonymousFunction

reduce_functionObject

reduce_arrayIndexExpr

reduce_arrayLiteral

reduce_assignToBracketExpr_to_expression

reduce_assignToBracketExpr_to_void_expression

reduce_assignToMemberExpr_to_expression

reduce_assignToMemberExpr_to_void_expression

reduce_assignToDescendantsExpr

reduce_assignToNameExpr_to_void_expression

reduce_assignToNameExpr_to_expression

reduce_assignToQualifiedMemberExpr

reduce_assignToQualifiedRuntimeMemberExpr

reduce_assignToQualifiedAttributeExpr

reduce_assignToQualifiedRuntimeAttributeExpr

reduce_assignToRuntimeNameExpr

reduce_assignToUnqualifiedRuntimeAttributeExpr

reduce_attributeName

reduce_blockStmt_to_finally_clause

reduce_blockStmt_to_statement

reduce_booleanLiteral

reduce_breakStmt

reduce_by_concatenation

reduce_catchBlockTyped

reduce_catchBlockUntyped

reduce_commaExpr

reduce_conditionalFragment

reduce_constantConditionalFragment

reduce_constantStringConcatenation

reduce_constantStringConcatenation

reduce_constantStringConcatenation

reduce_constantAddition

reduce_continueStmt

reduce_countedForStmt

reduce_defaultXMLNamespace