http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/a185d7ee/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CmcRules.jbg ---------------------------------------------------------------------- diff --git a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CmcRules.jbg b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CmcRules.jbg index 18be2dc..de47d4b 100644 --- a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CmcRules.jbg +++ b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CmcRules.jbg @@ -32,49 +32,49 @@ // Prototype reduction logic for functions // is in FunctionRules.jbg; include them with // the patterns for each variation. -JBurg.include "FunctionRules.jbg" -JBurg.include "FunctionRules.jbg" typelessFunction="typelessGetter" typedFunction="typedGetter" -JBurg.include "FunctionRules.jbg" typelessFunction="typelessSetter" typedFunction="typedSetter" +@include "FunctionRules.jbg" +@include "FunctionRules.jbg" typelessFunction="typelessGetter" typedFunction="typedGetter" +@include "FunctionRules.jbg" typelessFunction="typelessSetter" typedFunction="typedSetter" // anonymous function closure expression = Pattern anonymousFunction: 1 -Prologue reducer.prologue_anonymousFunction(p) -JBurg.Reduction reducer.reduce_anonymousFunction(__p, function_body); +@Prologue reducer.prologue_anonymousFunction(p) +@Reduction reducer.reduce_anonymousFunction(__p, function_body); // typeless named function closure. expression = Pattern typelessFunctionObject: 1 -Prologue reducer.prologue_functionObject(p) -JBurg.Reduction reducer.reduce_functionObject(__p, function_name, plist, null, block); +@Prologue reducer.prologue_functionObject(p) +@Reduction reducer.reduce_functionObject(__p, function_name, plist, null, block); // named function closure with a return type. expression = Pattern typedFunctionObject: 1 -Prologue reducer.prologue_functionObject(p) -JBurg.Reduction reducer.reduce_functionObject(__p, function_name, plist, return_type, block); +@Prologue reducer.prologue_functionObject(p) +@Reduction reducer.reduce_functionObject(__p, function_name, plist, return_type, block); // A typeless nested function. -statement = Pattern typelessFunction : 0 -Prologue reducer.prologue_typelessFunction_to_statement(p) -JBurg.Reduction reducer.reduce_typelessFunction(__p, plist, block); +statement = Pattern typelessFunction: 0 +@Prologue reducer.prologue_typelessFunction_to_statement(p) +@Reduction reducer.reduce_typelessFunction(__p, plist, block); // A nested function with a return type. -statement = Pattern typedFunction : 0 -Prologue reducer.prologue_typedFunction_to_statement(p) -JBurg.Reduction reducer.reduce_typedFunction_to_statement(__p, plist, return_type, block); +statement = Pattern typedFunction: 0 +@Prologue reducer.prologue_typedFunction_to_statement(p) +@Reduction reducer.reduce_typedFunction_to_statement(__p, plist, return_type, block); /* * A parameterList with parameters. */ -parameterList = Pattern plist : 0 -JBurg.Reduction reducer.reduce_plist(__p, pdecl); +parameterList = Pattern plist: 0 +@Reduction reducer.reduce_plist(__p, pdecl); parameter = Pattern requiredParameter: 0 -JBurg.Reduction reducer.reduce_requiredParameter(__p, param_name, param_type); +@Reduction reducer.reduce_requiredParameter(__p, param_name, param_type); parameter = Pattern optionalParameter: 0 -JBurg.Reduction reducer.reduce_optionalParameter(__p, param_name, param_type, default_value); +@Reduction reducer.reduce_optionalParameter(__p, param_name, param_type, default_value); -parameter = Pattern restParameter : 0 -JBurg.Reduction reducer.reduce_restParameter (__p, param_name, param_type); +parameter = Pattern restParameter: 0 +@Reduction reducer.reduce_restParameter (__p, param_name, param_type); /* * ****************** @@ -86,101 +86,101 @@ JBurg.Reduction reducer.reduce_restParameter (__p, param_name, param_type); * Control-flow statements. */ statement = Pattern whileStmt: 0 -Prologue reducer.prologue_whileStmt(p) -JBurg.Reduction reducer.reduce_whileStmt(__p, cond, body); +@Prologue reducer.prologue_whileStmt(p) +@Reduction reducer.reduce_whileStmt(__p, cond, body); statement = Pattern doStmt: 0 -Prologue reducer.prologue_doStmt(p) -JBurg.Reduction reducer.reduce_doStmt(__p, body, cond); +@Prologue reducer.prologue_doStmt(p) +@Reduction reducer.reduce_doStmt(__p, body, cond); statement = Pattern countedForStmt: 2 -Prologue reducer.prologue_countedForStmt(p) -JBurg.Reduction reducer.reduce_countedForStmt(__p, init, test_insns, incr, body); +@Prologue reducer.prologue_countedForStmt(p) +@Reduction reducer.reduce_countedForStmt(__p, init, test_insns, incr, body); statement = Pattern forInStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueStmt(__p, it, base, body, OP_nextname); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueStmt(__p, it, base, body, OP_nextname); statement = Pattern forInArrayStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueArrayStmt(__p, stem, index, base, body, OP_nextname, false); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueArrayStmt(__p, stem, index, base, body, OP_nextname, false); statement = Pattern forInMemberStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, member, base, body, OP_nextname, false); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, member, base, body, OP_nextname, false); statement = Pattern forInDescendantStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, descendants, base, body, OP_nextname, false); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, descendants, base, body, OP_nextname, false); statement = Pattern forInSuperStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, null, member, base, body, OP_nextname, true); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, null, member, base, body, OP_nextname, true); statement = Pattern forInSuperBracketStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueArrayStmt(__p, null, index, base, body, OP_nextname, true); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueArrayStmt(__p, null, index, base, body, OP_nextname, true); statement = Pattern forVarDeclInStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forVarDeclInStmt(__p, single_decl, base, body, OP_nextname); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forVarDeclInStmt(__p, single_decl, base, body, OP_nextname); statement = Pattern forEachVarDeclInStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forVarDeclInStmt(__p, single_decl, base, body, OP_nextvalue); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forVarDeclInStmt(__p, single_decl, base, body, OP_nextvalue); statement = Pattern forEachStmt: 10 -Prologue reducer.prologue_forEachStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueStmt(__p, it, base, body, OP_nextvalue); +@Prologue reducer.prologue_forEachStmt(p) +@Reduction reducer.reduce_forKeyValueStmt(__p, it, base, body, OP_nextvalue); statement = Pattern forEachArrayStmt: 10 -Prologue reducer.prologue_forEachStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueArrayStmt(__p, stem, index, base, body, OP_nextvalue, false); +@Prologue reducer.prologue_forEachStmt(p) +@Reduction reducer.reduce_forKeyValueArrayStmt(__p, stem, index, base, body, OP_nextvalue, false); statement = Pattern forEachMemberStmt: 10 -Prologue reducer.prologue_forEachStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, member, base, body, OP_nextvalue, false); +@Prologue reducer.prologue_forEachStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, member, base, body, OP_nextvalue, false); statement = Pattern forEachInDescendantStmt: 10 -Prologue reducer.prologue_forInStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, descendants, base, body, OP_nextvalue, false); +@Prologue reducer.prologue_forInStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, stem, descendants, base, body, OP_nextvalue, false); statement = Pattern forEachSuperStmt: 10 -Prologue reducer.prologue_forEachStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueMemberStmt(__p, null, member, base, body, OP_nextvalue, true); +@Prologue reducer.prologue_forEachStmt(p) +@Reduction reducer.reduce_forKeyValueMemberStmt(__p, null, member, base, body, OP_nextvalue, true); statement = Pattern forEachSuperBracketStmt: 10 -Prologue reducer.prologue_forEachStmt(p) -JBurg.Reduction reducer.reduce_forKeyValueArrayStmt(__p, null, index, base, body, OP_nextvalue, true); +@Prologue reducer.prologue_forEachStmt(p) +@Reduction reducer.reduce_forKeyValueArrayStmt(__p, null, index, base, body, OP_nextvalue, true); -statement = Pattern ifElseIf : 0 -JBurg.Reduction reducer.reduce_ifElseIf (__p, test, then, if_elseif); +statement = Pattern ifElseIf: 0 +@Reduction reducer.reduce_ifElseIf (__p, test, then, if_elseif); conditionalElements = Pattern lastElse: 0 -JBurg.Reduction reducer.reduce_lastElse(__p, else_clause); +@Reduction reducer.reduce_lastElse(__p, else_clause); /* * General form of switch statement: expand into if/elseif. */ statement = Pattern switchStmt: 0 -Prologue reducer.prologue_switchStmt(p) -JBurg.Reduction reducer.reduce_switchStmt(__p, switch_expr, cases); +@Prologue reducer.prologue_switchStmt(p) +@Reduction reducer.reduce_switchStmt(__p, switch_expr, cases); conditionalElements = Pattern switchCase: 0 -JBurg.Reduction reducer.reduce_conditionalFragment(__p, case_expr, case_actions); +@Reduction reducer.reduce_conditionalFragment(__p, case_expr, case_actions); conditionalElements = Pattern constantSwitchCase: 0 -JBurg.Reduction reducer.reduce_constantConditionalFragment(__p, case_const_value, case_actions); +@Reduction reducer.reduce_constantConditionalFragment(__p, case_const_value, case_actions); conditionalElements = Pattern switchDefault: 0 -JBurg.Reduction reducer.reduce_conditionalFragment(__p, null, case_actions); +@Reduction reducer.reduce_conditionalFragment(__p, null, case_actions); statement = Pattern returnVoidSideEffect: 1 -JBurg.Reduction reducer.reduce_returnVoidSideEffect(__p, expr); +@Reduction reducer.reduce_returnVoidSideEffect(__p, expr); statement = Pattern returnValue: 2 -JBurg.Reduction reducer.reduce_returnValue(__p, value); +@Reduction reducer.reduce_returnValue(__p, value); // returnVoidValue's cost is inflated to cause // the code generator to prefer returnValue @@ -189,29 +189,29 @@ JBurg.Reduction reducer.reduce_returnValue(__p, value); // than the corresponding reduction to expr, // so the CG thinks returning a void value // is a good choice in isolation. -statement = Pattern returnVoidValue : 2000 -JBurg.Reduction reducer.reduce_returnVoidValue (__p, no_value); +statement = Pattern returnVoidValue: 2000 +@Reduction reducer.reduce_returnVoidValue (__p, no_value); statement = Pattern returnVoid: 1 -JBurg.Reduction reducer.reduce_returnVoid(__p); +@Reduction reducer.reduce_returnVoid(__p); statement = Pattern returnNil: 1 -JBurg.Reduction reducer.reduce_returnVoid(__p); +@Reduction reducer.reduce_returnVoid(__p); statement = Pattern breakStmt: 1 -JBurg.Reduction reducer.reduce_breakStmt(__p); +@Reduction reducer.reduce_breakStmt(__p); statement = Pattern labeledBreakStmt: 0 -JBurg.Reduction reducer.reduce_labeledBreakStmt(__p); +@Reduction reducer.reduce_labeledBreakStmt(__p); statement = Pattern continueStmt: 1 -JBurg.Reduction reducer.reduce_continueStmt(__p); +@Reduction reducer.reduce_continueStmt(__p); statement = Pattern labeledContinueStmt: 0 -JBurg.Reduction reducer.reduce_labeledContinueStmt(__p); +@Reduction reducer.reduce_labeledContinueStmt(__p); statement = Pattern gotoStmt: 1 -JBurg.Reduction reducer.reduce_gotoStmt(__p); +@Reduction reducer.reduce_gotoStmt(__p); // CodeModel doesn't have an ExpressionStatement node, // so accept a bare expression as a statement. @@ -221,43 +221,43 @@ statement = void_expression; * A block of statements. */ statement = Pattern blockStmt: 0 -Prologue reducer.prologue_blockStmt(p) -JBurg.Reduction reducer.reduce_blockStmt_to_statement(__p, stmts); +@Prologue reducer.prologue_blockStmt(p) +@Reduction reducer.reduce_blockStmt_to_statement(__p, stmts); statement = Pattern configBlockStmt: 0 -Prologue reducer.prologue_blockStmt(p) -JBurg.Reduction reducer.reduce_blockStmt_to_statement(__p, stmts); +@Prologue reducer.prologue_blockStmt(p) +@Reduction reducer.reduce_blockStmt_to_statement(__p, stmts); /* * ******************** * ** Declarations ** * ******************** */ -var_decl = Pattern typedVariableDecl : 0 -JBurg.Reduction reducer.reduce_typedVariableDecl(__p, var_name, var_type, chained_decls); +var_decl = Pattern typedVariableDecl: 0 +@Reduction reducer.reduce_typedVariableDecl(__p, var_name, var_type, chained_decls); -var_decl = Pattern typedVariableDeclWithInitializer : 0 -JBurg.Reduction reducer.reduce_typedVariableDeclWithInitializer(__p, var_name, var_type, var_initializer, chained_decls); +var_decl = Pattern typedVariableDeclWithInitializer: 0 +@Reduction reducer.reduce_typedVariableDeclWithInitializer(__p, var_name, var_type, var_initializer, chained_decls); -var_decl = Pattern typedVariableDeclWithConstantInitializer : 0 -JBurg.Reduction reducer.reduce_typedVariableDeclWithConstantInitializer(__p, var_name, var_type, constant_var_initializer, chained_decls); +var_decl = Pattern typedVariableDeclWithConstantInitializer: 0 +@Reduction reducer.reduce_typedVariableDeclWithConstantInitializer(__p, var_name, var_type, constant_var_initializer, chained_decls); -var_decl = Pattern typedBindableVariableDecl : 0 -JBurg.Reduction reducer.reduce_typedBindableVariableDecl(__p, var_name, var_type, chained_decls); +var_decl = Pattern typedBindableVariableDecl: 0 +@Reduction reducer.reduce_typedBindableVariableDecl(__p, var_name, var_type, chained_decls); -var_decl = Pattern typedBindableVariableDeclWithInitializer : 0 -JBurg.Reduction reducer.reduce_typedBindableVariableDeclWithInitializer(__p, var_name, var_type, var_initializer, chained_decls); +var_decl = Pattern typedBindableVariableDeclWithInitializer: 0 +@Reduction reducer.reduce_typedBindableVariableDeclWithInitializer(__p, var_name, var_type, var_initializer, chained_decls); statement = var_decl; -statement = Pattern namespaceDeclaration : 0 -JBurg.Reduction reducer.reduce_namespaceDeclaration (__p, ns_name); +statement = Pattern namespaceDeclaration: 0 +@Reduction reducer.reduce_namespaceDeclaration (__p, ns_name); -statement = Pattern namespaceDeclarationConstantInitializer : 0 -JBurg.Reduction reducer.reduce_namespaceDeclarationConstantInitializer (__p, ns_name, uri); +statement = Pattern namespaceDeclarationConstantInitializer: 0 +@Reduction reducer.reduce_namespaceDeclarationConstantInitializer (__p, ns_name, uri); -statement = Pattern namespaceDeclarationInitializer : 0 -JBurg.Reduction reducer.reduce_namespaceDeclarationInitializer (__p, ns_name, second_ns); +statement = Pattern namespaceDeclarationInitializer: 0 +@Reduction reducer.reduce_namespaceDeclarationInitializer (__p, ns_name, second_ns); /* * ****************** @@ -266,40 +266,40 @@ JBurg.Reduction reducer.reduce_namespaceDeclarationInitializer (__p, ns_name, se */ statement = Pattern throwStmt: 1 -JBurg.Reduction reducer.reduce_throwStmt(__p, tossable); +@Reduction reducer.reduce_throwStmt(__p, tossable); statement = Pattern tryCatchStmt: 0 -Prologue reducer.prologue_tryCatchStmt(p) -JBurg.Reduction reducer.reduce_tryCatchStmt(__p, try_stmt, catch_blocks); +@Prologue reducer.prologue_tryCatchStmt(p) +@Reduction reducer.reduce_tryCatchStmt(__p, try_stmt, catch_blocks); statement = Pattern tryFinallyStmt: 0 -Prologue reducer.prologue_tryFinallyStmt(p) -JBurg.Reduction reducer.reduce_tryFinallyStmt(__p, try_stmt, finally_stmt); +@Prologue reducer.prologue_tryFinallyStmt(p) +@Reduction reducer.reduce_tryFinallyStmt(__p, try_stmt, finally_stmt); statement = Pattern tryCatchFinallyStmt: 0 -Prologue reducer.prologue_tryCatchFinallyStmt(p) -JBurg.Reduction reducer.reduce_tryCatchFinallyStmt(__p, try_stmt, finally_stmt, catch_blocks); +@Prologue reducer.prologue_tryCatchFinallyStmt(p) +@Reduction reducer.reduce_tryCatchFinallyStmt(__p, try_stmt, finally_stmt, catch_blocks); -catch_block = Pattern catchBlockTyped : 0 -Prologue reducer.prologue_catchBlock(p) -JBurg.Reduction reducer.reduce_catchBlockTyped (__p, var_name, exception, action); +catch_block = Pattern catchBlockTyped: 0 +@Prologue reducer.prologue_catchBlock(p) +@Reduction reducer.reduce_catchBlockTyped (__p, var_name, exception, action); -catch_block = Pattern catchBlockUntyped : 0 -Prologue reducer.prologue_catchBlock(p) -JBurg.Reduction reducer.reduce_catchBlockUntyped (__p, var_name, action); +catch_block = Pattern catchBlockUntyped: 0 +@Prologue reducer.prologue_catchBlock(p) +@Reduction reducer.reduce_catchBlockUntyped (__p, var_name, action); finally_clause = Pattern blockStmt: 0 -Prologue reducer.prologue_blockStmt_to_finally_clause(p) -JBurg.Reduction reducer.reduce_blockStmt_to_finally_clause(__p, stmts); +@Prologue reducer.prologue_blockStmt_to_finally_clause(p) +@Reduction reducer.reduce_blockStmt_to_finally_clause(__p, stmts); statement = Pattern labeledStmt: 0 -Prologue reducer.prologue_labeledStmt(p) -JBurg.Reduction reducer.reduce_labeledStmt(__p, label, substatement); +@Prologue reducer.prologue_labeledStmt(p) +@Reduction reducer.reduce_labeledStmt(__p, label, substatement); // with statement. statement = Pattern withStmt: 0 -Prologue reducer.prologue_withStmt(p) -JBurg.Reduction reducer.reduce_withStmt(__p, new_scope, body); +@Prologue reducer.prologue_withStmt(p) +@Reduction reducer.reduce_withStmt(__p, new_scope, body); /* * ******************* @@ -307,103 +307,103 @@ JBurg.Reduction reducer.reduce_withStmt(__p, new_scope, body); * ******************* */ void_expression = expression: 1 -JBurg.Reduction reducer.transform_expression_to_void_expression(__p, expression); +@Reduction reducer.transform_expression_to_void_expression(__p, expression); /* * Assignment to a simple name. */ void_expression = Pattern assignToNameExpr: 1 -JBurg.Reduction reducer.reduce_assignToNameExpr_to_void_expression(__p, lval, r); +@Reduction reducer.reduce_assignToNameExpr_to_void_expression(__p, lval, r); expression = Pattern assignToNameExpr: 2 -JBurg.Reduction reducer.reduce_assignToNameExpr_to_expression(__p, lval,r); +@Reduction reducer.reduce_assignToNameExpr_to_expression(__p, lval,r); /* * Assignment to a more general lvalue. */ -void_expression = Pattern assignToMemberExpr : 10 -JBurg.Reduction reducer.reduce_assignToMemberExpr_to_void_expression(__p, stem, member, r); +void_expression = Pattern assignToMemberExpr: 10 +@Reduction reducer.reduce_assignToMemberExpr_to_void_expression(__p, stem, member, r); -expression = Pattern assignToMemberExpr : 10 -JBurg.Reduction reducer.reduce_assignToMemberExpr_to_expression(__p, stem, member, r); +expression = Pattern assignToMemberExpr: 10 +@Reduction reducer.reduce_assignToMemberExpr_to_expression(__p, stem, member, r); /* * Assignment to a[i] type lvalue. */ void_expression = Pattern assignToBracketExpr: 1 -JBurg.Reduction reducer.reduce_assignToBracketExpr_to_void_expression(__p, stem, index, r, false); +@Reduction reducer.reduce_assignToBracketExpr_to_void_expression(__p, stem, index, r, false); expression = Pattern assignToBracketExpr: 1 -JBurg.Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, stem, index, r, false); +@Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, stem, index, r, false); void_expression = Pattern assignToSuperBracketExpr: 1 -JBurg.Reduction reducer.reduce_assignToBracketExpr_to_void_expression(__p, null, index, r, true); +@Reduction reducer.reduce_assignToBracketExpr_to_void_expression(__p, null, index, r, true); expression = Pattern assignToSuperBracketExpr: 1 -JBurg.Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, null, index, r, true); +@Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, null, index, r, true); /* * Assignment to qualified names and attributes. */ -void_expression = Pattern assignToQualifiedMemberExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedMemberExpr(__p, stem, qualifier, member, r, DISCARD_VALUE); +void_expression = Pattern assignToQualifiedMemberExpr: 1 +@Reduction reducer.reduce_assignToQualifiedMemberExpr(__p, stem, qualifier, member, r, DISCARD_VALUE); -expression = Pattern assignToQualifiedMemberExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); +expression = Pattern assignToQualifiedMemberExpr: 1 +@Reduction reducer.reduce_assignToQualifiedMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); -void_expression = Pattern assignToQualifiedRuntimeMemberExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p, stem, qualifier, member, r, DISCARD_VALUE); +void_expression = Pattern assignToQualifiedRuntimeMemberExpr: 1 +@Reduction reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p, stem, qualifier, member, r, DISCARD_VALUE); -expression = Pattern assignToQualifiedRuntimeMemberExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); +expression = Pattern assignToQualifiedRuntimeMemberExpr: 1 +@Reduction reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); -void_expression = Pattern assignToQualifiedAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedAttributeExpr(__p, stem, qualifier, attribute, r,DISCARD_VALUE); +void_expression = Pattern assignToQualifiedAttributeExpr: 1 +@Reduction reducer.reduce_assignToQualifiedAttributeExpr(__p, stem, qualifier, attribute, r,DISCARD_VALUE); -expression = Pattern assignToQualifiedAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedAttributeExpr(__p, stem, qualifier, attribute, r, NEED_VALUE); +expression = Pattern assignToQualifiedAttributeExpr: 1 +@Reduction reducer.reduce_assignToQualifiedAttributeExpr(__p, stem, qualifier, attribute, r, NEED_VALUE); -void_expression = Pattern assignToQualifiedRuntimeAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedRuntimeAttributeExpr(__p, stem, qualifier, attribute, r, DISCARD_VALUE); +void_expression = Pattern assignToQualifiedRuntimeAttributeExpr: 1 +@Reduction reducer.reduce_assignToQualifiedRuntimeAttributeExpr(__p, stem, qualifier, attribute, r, DISCARD_VALUE); -void_expression = Pattern assignToQualifiedRuntimeAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToQualifiedRuntimeAttributeExpr(__p, stem, qualifier, attribute, r, NEED_VALUE); +void_expression = Pattern assignToQualifiedRuntimeAttributeExpr: 1 +@Reduction reducer.reduce_assignToQualifiedRuntimeAttributeExpr(__p, stem, qualifier, attribute, r, NEED_VALUE); -void_expression = Pattern assignToUnqualifiedRuntimeAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, DISCARD_VALUE); +void_expression = Pattern assignToUnqualifiedRuntimeAttributeExpr: 1 +@Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, DISCARD_VALUE); -expression = Pattern assignToUnqualifiedRuntimeAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); +expression = Pattern assignToUnqualifiedRuntimeAttributeExpr: 1 +@Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); // TODO: This is more than a smidge whacky but it's what ASC does. // Research and pursue with PM. -void_expression = Pattern assignToUnqualifiedRuntimeDescendantsAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, DISCARD_VALUE); +void_expression = Pattern assignToUnqualifiedRuntimeDescendantsAttributeExpr: 1 +@Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, DISCARD_VALUE); -expression = Pattern assignToUnqualifiedRuntimeDescendantsAttributeExpr : 1 -JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); +expression = Pattern assignToUnqualifiedRuntimeDescendantsAttributeExpr: 1 +@Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); /* * Assignment to descendants. */ -void_expression = Pattern assignToDescendantsExpr : 1 -JBurg.Reduction reducer.reduce_assignToDescendantsExpr(__p, stem, member, r, DISCARD_VALUE); +void_expression = Pattern assignToDescendantsExpr: 1 +@Reduction reducer.reduce_assignToDescendantsExpr(__p, stem, member, r, DISCARD_VALUE); -expression = Pattern assignToDescendantsExpr : 1 -JBurg.Reduction reducer.reduce_assignToDescendantsExpr(__p, stem, member, r, NEED_VALUE); +expression = Pattern assignToDescendantsExpr: 1 +@Reduction reducer.reduce_assignToDescendantsExpr(__p, stem, member, r, NEED_VALUE); /* * Error trap for diagnosing parser/CG mismatches. * The cost is unfeasibly high for a normal reduction, * so this will only be chosen if no other reduction works. */ -expression = Op_AssignId(expression non_lvalue, expression rvalue ) : ERROR_TRAP -JBurg.Reduction reducer.error_reduce_Op_AssignId(__p, non_lvalue, rvalue); +expression = Op_AssignId(expression non_lvalue, expression rvalue ): ERROR_TRAP +@Reduction reducer.error_reduce_Op_AssignId(__p, non_lvalue, rvalue); /* * Compound assignment. */ -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_add" \ compoundAssignToName="assignPlusToNameExpr" \ compoundAssignToMember="assignPlusToMemberExpr" \ @@ -411,7 +411,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignPlusToDescendantsExpr" \ compoundAssignToRuntimeName="assignPlusToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_subtract" \ compoundAssignToName="assignMinusToNameExpr" \ compoundAssignToMember="assignMinusToMemberExpr" \ @@ -419,7 +419,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignMinusToDescendantsExpr" \ compoundAssignToRuntimeName="assignMinusToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_divide" \ compoundAssignToName="assignDivideToNameExpr" \ compoundAssignToMember="assignDivideToMemberExpr" \ @@ -427,7 +427,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignDivideToDescendantsExpr" \ compoundAssignToRuntimeName="assignDivideToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_multiply" \ compoundAssignToName="assignMultiplyToNameExpr" \ compoundAssignToMember="assignMultiplyToMemberExpr" \ @@ -435,7 +435,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignMultiplyToDescendantsExpr" \ compoundAssignToRuntimeName="assignMultiplyToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_modulo" \ compoundAssignToName="assignModuloToNameExpr" \ compoundAssignToMember="assignModuloToMemberExpr" \ @@ -443,7 +443,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignModuloToDescendantsExpr" \ compoundAssignToRuntimeName="assignModuloToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_bitor" \ compoundAssignToName="assignBitwiseOrToNameExpr" \ compoundAssignToMember="assignBitwiseOrToMemberExpr" \ @@ -451,7 +451,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignBitwiseOrToDescendantsExpr" \ compoundAssignToRuntimeName="assignBitwiseOrToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_bitand" \ compoundAssignToName="assignBitwiseAndToNameExpr" \ compoundAssignToMember="assignBitwiseAndToMemberExpr" \ @@ -459,7 +459,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignBitwiseAndToDescendantsExpr" \ compoundAssignToRuntimeName="assignBitwiseAndToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_bitxor" \ compoundAssignToName="assignBitwiseXorToNameExpr" \ compoundAssignToMember="assignBitwiseXorToMemberExpr" \ @@ -467,7 +467,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignBitwiseXorToDescendantsExpr" \ compoundAssignToRuntimeName="assignBitwiseXorToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_lshift" \ compoundAssignToName="assignLeftShiftToNameExpr" \ compoundAssignToMember="assignLeftShiftToMemberExpr" \ @@ -475,7 +475,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignLeftShiftToDescendantsExpr" \ compoundAssignToRuntimeName="assignLeftShiftToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_rshift" \ compoundAssignToName="assignRightShiftToNameExpr" \ compoundAssignToMember="assignRightShiftToMemberExpr" \ @@ -483,7 +483,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignRightShiftToDescendantsExpr" \ compoundAssignToRuntimeName="assignRightShiftToRuntimeNameExpr" -JBurg.include "CompoundAssignmentRules.jbg" \ +@include "CompoundAssignmentRules.jbg" \ opcode="OP_urshift" \ compoundAssignToName="assignUnsignedRightShiftToNameExpr" \ compoundAssignToMember="assignUnsignedRightShiftToMemberExpr" \ @@ -491,7 +491,7 @@ JBurg.include "CompoundAssignmentRules.jbg" \ compoundAssignToDescendants="assignUnsignedRightShiftToDescendantsExpr" \ compoundAssignToRuntimeName="assignUnsignedRightShiftToRuntimeNameExpr" -JBurg.include "CompoundLogicalAssignmentRules.jbg" \ +@include "CompoundLogicalAssignmentRules.jbg" \ IsAnd="true" \ compoundAssignToName="assignLogicalAndToNameExpr" \ compoundAssignToMember="assignLogicalAndToMemberExpr" \ @@ -499,7 +499,7 @@ JBurg.include "CompoundLogicalAssignmentRules.jbg" \ compoundAssignToDescendants="assignLogicalAndToDescendantsExpr" \ compoundAssignToRuntimeName="assignLogicalAndToRuntimeNameExpr" -JBurg.include "CompoundLogicalAssignmentRules.jbg" \ +@include "CompoundLogicalAssignmentRules.jbg" \ IsAnd="false" \ compoundAssignToName="assignLogicalOrToNameExpr" \ compoundAssignToMember="assignLogicalOrToMemberExpr" \ @@ -511,68 +511,68 @@ JBurg.include "CompoundLogicalAssignmentRules.jbg" \ /* * Miscellaneous void expressions. */ -void_expression = Pattern variableExpression : 0 -JBurg.Reduction reducer.reduce_variableExpression (__p, decls); +void_expression = Pattern variableExpression: 0 +@Reduction reducer.reduce_variableExpression (__p, decls); void_expression = Pattern nilExpr: 0 -JBurg.Reduction reducer.createInstructionList(__p); +@Reduction reducer.createInstructionList(__p); -expression = Pattern nilExpr : 1 -JBurg.Reduction reducer.reduce_nilExpr_to_expression(__p); +expression = Pattern nilExpr: 1 +@Reduction reducer.reduce_nilExpr_to_expression(__p); void_expression = Pattern groupedVoidExpression: 0 -JBurg.Reduction reducer.reduce_groupedVoidExpression(__p, contents); +@Reduction reducer.reduce_groupedVoidExpression(__p, contents); /* * Special Instruction List node - allows arbitrary instructions to be inserted * where an expression is expected. Used by some MXML processing that wants to * generate code without having to create a synthetic AST to pass to the burm. */ -expression = Pattern instructionListExpression : 1 -JBurg.Reduction reducer.reduce_instructionListExpression(__p); +expression = Pattern instructionListExpression: 1 +@Reduction reducer.reduce_instructionListExpression(__p); /* * Binary logical operators. */ -comparison_expression = Pattern equalExpr : 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_equals); +comparison_expression = Pattern equalExpr: 1 +@Reduction reducer.binaryOp (__p, l, r, OP_equals); -comparison_expression = Pattern neqExpr : 1 -JBurg.Reduction reducer.reduce_neqExpr (__p, l, r); +comparison_expression = Pattern neqExpr: 1 +@Reduction reducer.reduce_neqExpr (__p, l, r); -comparison_expression = Pattern stricteqExpr : 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_strictequals); +comparison_expression = Pattern stricteqExpr: 1 +@Reduction reducer.binaryOp (__p, l, r, OP_strictequals); -comparison_expression = Pattern strictneqExpr : 1 -JBurg.Reduction reducer.reduce_strictneqExpr (__p, l, r); +comparison_expression = Pattern strictneqExpr: 1 +@Reduction reducer.reduce_strictneqExpr (__p, l, r); comparison_expression = Pattern greaterThanExpr: 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_greaterthan); +@Reduction reducer.binaryOp (__p, l, r, OP_greaterthan); comparison_expression = Pattern greaterThanEqExpr: 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_greaterequals); +@Reduction reducer.binaryOp (__p, l, r, OP_greaterequals); -comparison_expression = Pattern lessExpr : 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_lessthan); +comparison_expression = Pattern lessExpr: 1 +@Reduction reducer.binaryOp (__p, l, r, OP_lessthan); -comparison_expression = Pattern lessEqExpr : 1 -JBurg.Reduction reducer.binaryOp (__p, l, r, OP_lessequals); +comparison_expression = Pattern lessEqExpr: 1 +@Reduction reducer.binaryOp (__p, l, r, OP_lessequals); // Closure rule: any comparison_expression // is also an expression without further conversion. expression = comparison_expression; -expression = Pattern logicalAndExpr : 5 -JBurg.Reduction reducer.reduce_logicalAndExpr (__p, l, r); +expression = Pattern logicalAndExpr: 5 +@Reduction reducer.reduce_logicalAndExpr (__p, l, r); -expression = Pattern logicalOrExpr : 5 -JBurg.Reduction reducer.reduce_logicalOrExpr (__p, l, r); +expression = Pattern logicalOrExpr: 5 +@Reduction reducer.reduce_logicalOrExpr (__p, l, r); -expression = Pattern logicalNotExpr : 1 -JBurg.Reduction reducer.reduce_logicalNotExpr (__p, expr); +expression = Pattern logicalNotExpr: 1 +@Reduction reducer.reduce_logicalNotExpr (__p, expr); -expression = Pattern ternaryExpr : 1 -JBurg.Reduction reducer.reduce_ternaryExpr (__p, test, when_true, when_false); +expression = Pattern ternaryExpr: 1 +@Reduction reducer.reduce_ternaryExpr (__p, test, when_true, when_false); /* * Binary branching constructs; @@ -580,151 +580,151 @@ JBurg.Reduction reducer.reduce_ternaryExpr (__p, test, when_true, when_false); * near their equivalent operators * for maintenance's sake. */ -conditionalJump = Pattern equalExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifeq); +conditionalJump = Pattern equalExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_ifeq); -conditionalJump = Pattern neqExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifne); +conditionalJump = Pattern neqExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_ifne); -conditionalJump = Pattern stricteqExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifstricteq); +conditionalJump = Pattern stricteqExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_ifstricteq); -conditionalJump = Pattern strictneqExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifstrictne); +conditionalJump = Pattern strictneqExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_ifstrictne); conditionalJump = Pattern greaterThanExpr: 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifgt); +@Reduction reducer.conditionalJump(__p, l, r, OP_ifgt); conditionalJump = Pattern greaterThanEqExpr: 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifge); +@Reduction reducer.conditionalJump(__p, l, r, OP_ifge); -conditionalJump = Pattern lessExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_iflt); +conditionalJump = Pattern lessExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_iflt); -conditionalJump = Pattern lessEqExpr : 1 -JBurg.Reduction reducer.conditionalJump(__p, l, r, OP_ifle); +conditionalJump = Pattern lessEqExpr: 1 +@Reduction reducer.conditionalJump(__p, l, r, OP_ifle); -conditionalJump = Pattern nilExpr : 1 -JBurg.Reduction reducer.reduce_nilExpr_to_conditionalJump (__p); +conditionalJump = Pattern nilExpr: 1 +@Reduction reducer.reduce_nilExpr_to_conditionalJump (__p); /* * General form of conditional jump. */ -conditionalJump = expression : 1 -JBurg.Reduction reducer.transform_expression_to_conditionalJump(__p, expression); +conditionalJump = expression: 1 +@Reduction reducer.transform_expression_to_conditionalJump(__p, expression); /* * Binary arithmetic operators. */ -expression = Pattern divideExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_divide); +expression = Pattern divideExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_divide); -expression = Pattern multExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_multiply); +expression = Pattern multExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_multiply); -expression = Pattern moduloExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_modulo); +expression = Pattern moduloExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_modulo); -expression = Pattern addExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_add); +expression = Pattern addExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_add); -expression = Pattern subtractExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_subtract); +expression = Pattern subtractExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_subtract); -expression = Pattern bitwiseLeftShiftExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_lshift); +expression = Pattern bitwiseLeftShiftExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_lshift); -expression = Pattern bitwiseRightShiftExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_rshift); +expression = Pattern bitwiseRightShiftExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_rshift); -expression = Pattern bitwiseUnsignedRightShiftExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_urshift); +expression = Pattern bitwiseUnsignedRightShiftExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_urshift); -expression = Pattern bitwiseAndExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_bitand); +expression = Pattern bitwiseAndExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_bitand); -expression = Pattern bitwiseOrExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_bitor); +expression = Pattern bitwiseOrExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_bitor); -expression = Pattern bitwiseXorExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, l, r, OP_bitxor); +expression = Pattern bitwiseXorExpr: 1 +@Reduction reducer.binaryOp(__p, l, r, OP_bitxor); /* * pre/postfix unary operators. */ -expression = Pattern postIncNameExpr : 7 -JBurg.Reduction reducer.reduce_postIncNameExpr(__p, unary, true); +expression = Pattern postIncNameExpr: 7 +@Reduction reducer.reduce_postIncNameExpr(__p, unary, true); -void_expression = Pattern postIncNameExpr : 7 -JBurg.Reduction reducer.reduce_postIncNameExpr(__p, unary, false); +void_expression = Pattern postIncNameExpr: 7 +@Reduction reducer.reduce_postIncNameExpr(__p, unary, false); -expression = Pattern preIncNameExpr : 7 -JBurg.Reduction reducer.reduce_preIncNameExpr(__p, unary, true); +expression = Pattern preIncNameExpr: 7 +@Reduction reducer.reduce_preIncNameExpr(__p, unary, true); -void_expression = Pattern preIncNameExpr : 7 -JBurg.Reduction reducer.reduce_preIncNameExpr(__p, unary, false); +void_expression = Pattern preIncNameExpr: 7 +@Reduction reducer.reduce_preIncNameExpr(__p, unary, false); -expression = Pattern preIncMemberExpr : 8 -JBurg.Reduction reducer.reduce_preIncMemberExpr(__p, stem, field, true); +expression = Pattern preIncMemberExpr: 8 +@Reduction reducer.reduce_preIncMemberExpr(__p, stem, field, true); -void_expression = Pattern preIncMemberExpr : 8 -JBurg.Reduction reducer.reduce_preIncMemberExpr(__p, stem, field, false); +void_expression = Pattern preIncMemberExpr: 8 +@Reduction reducer.reduce_preIncMemberExpr(__p, stem, field, false); expression = Pattern postIncMemberExpr: 8 -JBurg.Reduction reducer.reduce_postIncMemberExpr(__p, stem, field, true); +@Reduction reducer.reduce_postIncMemberExpr(__p, stem, field, true); void_expression = Pattern postIncMemberExpr: 8 -JBurg.Reduction reducer.reduce_postIncMemberExpr(__p, stem, field, false); +@Reduction reducer.reduce_postIncMemberExpr(__p, stem, field, false); expression = Pattern preIncBracketExpr: 8 -JBurg.Reduction reducer.reduce_preIncBracketExpr(__p, stem, index, true); +@Reduction reducer.reduce_preIncBracketExpr(__p, stem, index, true); void_expression = Pattern preIncBracketExpr: 8 -JBurg.Reduction reducer.reduce_preIncBracketExpr(__p, stem, index, false); +@Reduction reducer.reduce_preIncBracketExpr(__p, stem, index, false); expression = Pattern postIncBracketExpr: 8 -JBurg.Reduction reducer.reduce_postIncBracketExpr(__p, stem, index, true); +@Reduction reducer.reduce_postIncBracketExpr(__p, stem, index, true); void_expression = Pattern postIncBracketExpr: 8 -JBurg.Reduction reducer.reduce_postIncBracketExpr(__p, stem, index, false); +@Reduction reducer.reduce_postIncBracketExpr(__p, stem, index, false); -expression = Pattern postDecNameExpr : 7 -JBurg.Reduction reducer.reduce_postDecNameExpr(__p, unary, true); +expression = Pattern postDecNameExpr: 7 +@Reduction reducer.reduce_postDecNameExpr(__p, unary, true); -void_expression = Pattern postDecNameExpr : 7 -JBurg.Reduction reducer.reduce_postDecNameExpr(__p, unary, false); +void_expression = Pattern postDecNameExpr: 7 +@Reduction reducer.reduce_postDecNameExpr(__p, unary, false); -expression = Pattern preDecNameExpr : 7 -JBurg.Reduction reducer.reduce_preDecNameExpr(__p, unary, true); +expression = Pattern preDecNameExpr: 7 +@Reduction reducer.reduce_preDecNameExpr(__p, unary, true); -void_expression = Pattern preDecNameExpr : 7 -JBurg.Reduction reducer.reduce_preDecNameExpr(__p, unary, false); +void_expression = Pattern preDecNameExpr: 7 +@Reduction reducer.reduce_preDecNameExpr(__p, unary, false); -expression = Pattern preDecMemberExpr : 8 -JBurg.Reduction reducer.reduce_preDecMemberExpr(__p, stem, field, true); +expression = Pattern preDecMemberExpr: 8 +@Reduction reducer.reduce_preDecMemberExpr(__p, stem, field, true); -void_expression = Pattern preDecMemberExpr : 8 -JBurg.Reduction reducer.reduce_preDecMemberExpr(__p, stem, field, false); +void_expression = Pattern preDecMemberExpr: 8 +@Reduction reducer.reduce_preDecMemberExpr(__p, stem, field, false); expression = Pattern postDecMemberExpr: 8 -JBurg.Reduction reducer.reduce_postDecMemberExpr(__p, stem, field, true); +@Reduction reducer.reduce_postDecMemberExpr(__p, stem, field, true); void_expression = Pattern postDecMemberExpr: 8 -JBurg.Reduction reducer.reduce_postDecMemberExpr(__p, stem, field, false); +@Reduction reducer.reduce_postDecMemberExpr(__p, stem, field, false); expression = Pattern preDecBracketExpr: 8 -JBurg.Reduction reducer.reduce_preDecBracketExpr(__p, stem, index, true); +@Reduction reducer.reduce_preDecBracketExpr(__p, stem, index, true); void_expression = Pattern preDecBracketExpr: 8 -JBurg.Reduction reducer.reduce_preDecBracketExpr(__p, stem, index, false); +@Reduction reducer.reduce_preDecBracketExpr(__p, stem, index, false); expression = Pattern postDecBracketExpr: 8 -JBurg.Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, true); +@Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, true); void_expression = Pattern postDecBracketExpr: 8 -JBurg.Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, false); +@Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, false); @@ -732,7 +732,7 @@ JBurg.Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, false); * Unary expressions. */ expression = Pattern unaryMinusExpr: 1 -JBurg.Reduction reducer.unaryOp(__p, e, OP_negate); +@Reduction reducer.unaryOp(__p, e, OP_negate); expression = Pattern unaryPlusExpr: 0 { @@ -740,218 +740,218 @@ expression = Pattern unaryPlusExpr: 0 } expression = Pattern typeofExpr: 10 -Prologue reducer.prologue_typeof(p) -JBurg.Reduction reducer.reduce_typeof_expr(__p, expr); +@Prologue reducer.prologue_typeof(p) +@Reduction reducer.reduce_typeof_expr(__p, expr); expression = Pattern typeofName: 1 -Prologue reducer.prologue_typeof(p) -JBurg.Reduction reducer.reduce_typeof_name(__p, n); +@Prologue reducer.prologue_typeof(p) +@Reduction reducer.reduce_typeof_name(__p, n); expression = Pattern bitNotExpr: 1 -JBurg.Reduction reducer.unaryOp(__p, unary, OP_bitnot); +@Reduction reducer.unaryOp(__p, unary, OP_bitnot); /* * Miscellaneous binary expressions. */ -expression = Pattern istypeExprLate : 1 -JBurg.Reduction reducer.binaryOp(__p, expr, typename, OP_istypelate); +expression = Pattern istypeExprLate: 1 +@Reduction reducer.binaryOp(__p, expr, typename, OP_istypelate); -expression = Pattern astypeExprLate : 1 -JBurg.Reduction reducer.binaryOp(__p, expr, typename, OP_astypelate); +expression = Pattern astypeExprLate: 1 +@Reduction reducer.binaryOp(__p, expr, typename, OP_astypelate); -expression = Pattern inExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, needle, haystack, OP_in); +expression = Pattern inExpr: 1 +@Reduction reducer.binaryOp(__p, needle, haystack, OP_in); -expression = Pattern instanceofExpr : 1 -JBurg.Reduction reducer.binaryOp(__p, expr, typename, OP_instanceof); +expression = Pattern instanceofExpr: 1 +@Reduction reducer.binaryOp(__p, expr, typename, OP_instanceof); /* * Primary expressions. */ -expression = Pattern memberAccessExpr : 10 -JBurg.Reduction reducer.reduce_memberAccessExpr (__p, stem, member, OP_getproperty); +expression = Pattern memberAccessExpr: 10 +@Reduction reducer.reduce_memberAccessExpr (__p, stem, member, OP_getproperty); -expression = Pattern qualifiedMemberAccessExpr : 10 -JBurg.Reduction reducer.reduce_qualifiedMemberAccessExpr(__p, stem, qualifier, member, OP_getproperty); +expression = Pattern qualifiedMemberAccessExpr: 10 +@Reduction reducer.reduce_qualifiedMemberAccessExpr(__p, stem, qualifier, member, OP_getproperty); -expression = Pattern qualifiedDescendantsExpr : 10 -JBurg.Reduction reducer.reduce_qualifiedMemberAccessExpr(__p, stem, qualifier, member, OP_getdescendants); +expression = Pattern qualifiedDescendantsExpr: 10 +@Reduction reducer.reduce_qualifiedMemberAccessExpr(__p, stem, qualifier, member, OP_getdescendants); -expression = Pattern qualifiedDescendantsRuntimeExpr : 1 -JBurg.Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getdescendants); +expression = Pattern qualifiedDescendantsRuntimeExpr: 1 +@Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getdescendants); -expression = Pattern qualifiedAttributeExpr : 1 -JBurg.Reduction reducer.reduce_qualifiedAttributeExpr(__p, stem, qualifier, member, OP_getproperty); +expression = Pattern qualifiedAttributeExpr: 1 +@Reduction reducer.reduce_qualifiedAttributeExpr(__p, stem, qualifier, member, OP_getproperty); -expression = Pattern qualifiedDescendantsAttributeExpr : 1 -JBurg.Reduction reducer.reduce_qualifiedAttributeExpr(__p, stem, qualifier, member, OP_getdescendants); +expression = Pattern qualifiedDescendantsAttributeExpr: 1 +@Reduction reducer.reduce_qualifiedAttributeExpr(__p, stem, qualifier, member, OP_getdescendants); -expression = Pattern qualifiedAttributeRuntimeMemberExpr : 1 -JBurg.Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getproperty); +expression = Pattern qualifiedAttributeRuntimeMemberExpr: 1 +@Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getproperty); -expression = Pattern qualifiedDescendantsRuntimeMemberExpr : 1 -JBurg.Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getdescendants); +expression = Pattern qualifiedDescendantsRuntimeMemberExpr: 1 +@Reduction reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p, stem, qualifier, runtime_member, OP_getdescendants); // Prefer the basic memberAccessExpr pattern where feasible. -expression = Pattern qualifiedMemberRuntimeNameExpr : 100 -JBurg.Reduction reducer.reduce_qualifiedMemberRuntimeNameExpr(__p, stem, qualifier, runtime_member); +expression = Pattern qualifiedMemberRuntimeNameExpr: 100 +@Reduction reducer.reduce_qualifiedMemberRuntimeNameExpr(__p, stem, qualifier, runtime_member); -expression = Pattern unqualifiedAttributeExpr : 1 -JBurg.Reduction reducer.reduce_unqualifiedAttributeExpr(__p, stem, expr, OP_getproperty); +expression = Pattern unqualifiedAttributeExpr: 1 +@Reduction reducer.reduce_unqualifiedAttributeExpr(__p, stem, expr, OP_getproperty); -expression = Pattern unqualifiedDescendantsAttributeExpr : 1 -JBurg.Reduction reducer.reduce_unqualifiedAttributeExpr(__p, stem, expr, OP_getdescendants); +expression = Pattern unqualifiedDescendantsAttributeExpr: 1 +@Reduction reducer.reduce_unqualifiedAttributeExpr(__p, stem, expr, OP_getdescendants); -expression = Pattern runtimeAttributeExp : 1 -JBurg.Reduction reducer.reduce_runtimeAttributeExp(__p, expr); +expression = Pattern runtimeAttributeExp: 1 +@Reduction reducer.reduce_runtimeAttributeExp(__p, expr); -expression = Pattern arrayIndexExpr : 1 -JBurg.Reduction reducer.reduce_arrayIndexExpr (__p, stem, false, index); +expression = Pattern arrayIndexExpr: 1 +@Reduction reducer.reduce_arrayIndexExpr (__p, stem, false, index); -expression = Pattern superIndexExpr : 1 -JBurg.Reduction reducer.reduce_arrayIndexExpr (__p, null, true, index); +expression = Pattern superIndexExpr: 1 +@Reduction reducer.reduce_arrayIndexExpr (__p, null, true, index); -expression = Pattern functionCallExpr : 3 // Cost artificially inflated -JBurg.Reduction reducer.reduce_functionCallExpr_to_expression (__p, method_name, args); +expression = Pattern functionCallExpr: 3 // Cost artificially inflated +@Reduction reducer.reduce_functionCallExpr_to_expression (__p, method_name, args); // Use callpropvoid to dodge a pop insn where it fits. -void_expression = Pattern functionCallExpr : 2 -JBurg.Reduction reducer.reduce_functionCallExpr_to_void_expression (__p, method_name, args); +void_expression = Pattern functionCallExpr: 2 +@Reduction reducer.reduce_functionCallExpr_to_void_expression (__p, method_name, args); -void_expression = Pattern superCallExpr : 2 -JBurg.Reduction reducer.reduce_superCallExpr (__p, args); +void_expression = Pattern superCallExpr: 2 +@Reduction reducer.reduce_superCallExpr (__p, args); -void_expression = Pattern functionCallOfSuperclassMethod : 1 -JBurg.Reduction reducer.reduce_functionCallOfSuperclassMethod_to_void_expression (__p, null, method_name, args); +void_expression = Pattern functionCallOfSuperclassMethod: 1 +@Reduction reducer.reduce_functionCallOfSuperclassMethod_to_void_expression (__p, null, method_name, args); -void_expression = Pattern functionCallOfExplicitObjectSuperclassMethod : 2 -JBurg.Reduction reducer.reduce_functionCallOfSuperclassMethod_to_void_expression (__p, stem, method_name, args); +void_expression = Pattern functionCallOfExplicitObjectSuperclassMethod: 2 +@Reduction reducer.reduce_functionCallOfSuperclassMethod_to_void_expression (__p, stem, method_name, args); expression = Pattern newVectorLiteral: 0 -JBurg.Reduction reducer.reduce_newVectorLiteral(__p, literal); +@Reduction reducer.reduce_newVectorLiteral(__p, literal); // 'new Array()' has cost 1. -expression = Pattern emptyConstructor : isEmptyArrayConstructor() -JBurg.Reduction reducer.reduce_newEmptyArray(__p); +expression = Pattern emptyConstructor: isEmptyArrayConstructor() +@Reduction reducer.reduce_newEmptyArray(__p); // 'new Object()' has cost 1. -expression = Pattern emptyConstructor : isEmptyObjectConstructor() -JBurg.Reduction reducer.reduce_newEmptyObject(__p); +expression = Pattern emptyConstructor: isEmptyObjectConstructor() +@Reduction reducer.reduce_newEmptyObject(__p); // 'new Whatever(...)' has cost 2, so it gets beaten by the two previous rules. // Use this reduction if the type is known; // it allows much better error checking of the constructor call. -expression = Pattern newExpr : 2 -JBurg.Reduction reducer.reduce_newExpr (__p, class_binding, args); +expression = Pattern newExpr: 2 +@Reduction reducer.reduce_newExpr (__p, class_binding, args); expression = Pattern newMemberProperty: 10 -JBurg.Reduction reducer.reduce_newMemberProperty(__p, stem, member, args); +@Reduction reducer.reduce_newMemberProperty(__p, stem, member, args); -expression = Pattern newAsRandomExpr : 30 -JBurg.Reduction reducer.reduce_newAsRandomExpr (__p, random_expr, args); +expression = Pattern newAsRandomExpr: 30 +@Reduction reducer.reduce_newAsRandomExpr (__p, random_expr, args); -expression = Pattern functionCallOfSuperclassMethod : 2 -JBurg.Reduction reducer.reduce_functionCallOfSuperclassMethod_to_expression (__p, null, method_name, args); +expression = Pattern functionCallOfSuperclassMethod: 2 +@Reduction reducer.reduce_functionCallOfSuperclassMethod_to_expression (__p, null, method_name, args); -expression = Pattern functionCallOfExplicitObjectSuperclassMethod : 2 -JBurg.Reduction reducer.reduce_functionCallOfSuperclassMethod_to_expression (__p, stem, method_name, args); +expression = Pattern functionCallOfExplicitObjectSuperclassMethod: 2 +@Reduction reducer.reduce_functionCallOfSuperclassMethod_to_expression (__p, stem, method_name, args); -expression = Pattern functionAsMemberExpr : 4 // Cost inflated to prefer functionCallOfSuperclassMethod -JBurg.Reduction reducer.reduce_functionAsMemberExpr (__p, stem, method_name, args); +expression = Pattern functionAsMemberExpr: 4 // Cost inflated to prefer functionCallOfSuperclassMethod +@Reduction reducer.reduce_functionAsMemberExpr (__p, stem, method_name, args); -expression = Pattern functionAsBracketExpr : 4 -JBurg.Reduction reducer.reduce_functionAsBracketExpr (__p, stem, index, args); +expression = Pattern functionAsBracketExpr: 4 +@Reduction reducer.reduce_functionAsBracketExpr (__p, stem, index, args); -expression = Pattern functionAsRandomExpr : 30 -JBurg.Reduction reducer.reduce_functionAsRandomExpr (__p, random_expr, args); +expression = Pattern functionAsRandomExpr: 30 +@Reduction reducer.reduce_functionAsRandomExpr (__p, random_expr, args); /* * Delete expressions. */ expression = Pattern deleteNameExpr: 2 -JBurg.Reduction reducer.reduce_deleteNameExpr(__p, n); +@Reduction reducer.reduce_deleteNameExpr(__p, n); expression = Pattern deleteBracketExpr: 1 -JBurg.Reduction reducer.reduce_deleteBracketExpr(__p, stem, index); +@Reduction reducer.reduce_deleteBracketExpr(__p, stem, index); expression = Pattern deleteAtBracketExpr: 1 -JBurg.Reduction reducer.reduce_deleteAtBracketExpr(__p, stem, index); +@Reduction reducer.reduce_deleteAtBracketExpr(__p, stem, index); expression = Pattern deleteMemberExpr: 1 -JBurg.Reduction reducer.reduce_deleteMemberExpr(__p, stem, field); +@Reduction reducer.reduce_deleteMemberExpr(__p, stem, field); expression = Pattern deleteRuntimeNameExpr: 1 -JBurg.Reduction reducer.reduce_deleteRuntimeNameExpr(__p, stem, rt_name); +@Reduction reducer.reduce_deleteRuntimeNameExpr(__p, stem, rt_name); expression = Pattern deleteDescendantsExpr: 1 -JBurg.Reduction reducer.reduce_deleteDescendantsExpr(__p, stem, field); +@Reduction reducer.reduce_deleteDescendantsExpr(__p, stem, field); expression = Pattern deleteAnyExprExprExpr: 2000 -JBurg.Reduction reducer.reduce_deleteExprExprExpr(__p, expr); +@Reduction reducer.reduce_deleteExprExprExpr(__p, expr); /* * Comma expression. */ expression = Pattern commaExpr: 0 -JBurg.Reduction reducer.reduce_commaExpr(__p, payload_expr, exprs); +@Reduction reducer.reduce_commaExpr(__p, payload_expr, exprs); /* * Names and reference expressions built from names. */ -name = Pattern simpleName : 0 -JBurg.Reduction reducer.reduce_simpleName (__p); +name = Pattern simpleName: 0 +@Reduction reducer.reduce_simpleName (__p); -decl_name = Pattern simpleName : 0 -JBurg.Reduction reducer.reduce_declName(__p); +decl_name = Pattern simpleName: 0 +@Reduction reducer.reduce_declName(__p); qualifiedNamePart = Pattern simpleName: 0 -JBurg.Reduction reducer.getIdentifierContent(__p); +@Reduction reducer.getIdentifierContent(__p); -name = Pattern typedVariableExpression : 0 -JBurg.Reduction reducer.reduce_typedVariableExpression (__p, var_name, var_type); +name = Pattern typedVariableExpression: 0 +@Reduction reducer.reduce_typedVariableExpression (__p, var_name, var_type); -dottedNamePart = Pattern dottedName : 0 -JBurg.Reduction reducer.reduce_by_concatenation (__p, first, second); +dottedNamePart = Pattern dottedName: 0 +@Reduction reducer.reduce_by_concatenation (__p, first, second); dottedNamePart = qualifiedNamePart; -name = Pattern dottedName : isDottedName() -JBurg.Reduction reducer.dottedName (__p, first, second); +name = Pattern dottedName: isDottedName() +@Reduction reducer.dottedName (__p, first, second); -name = Pattern dottedName : isPackageName() -JBurg.Reduction reducer.errorPackageName(__p, first, second); +name = Pattern dottedName: isPackageName() +@Reduction reducer.errorPackageName(__p, first, second); // This reduction handles an entire dotted name subtree. -name = Pattern fullName : 0 -JBurg.Reduction reducer.dottedName(__p, first, second); +name = Pattern fullName: 0 +@Reduction reducer.dottedName(__p, first, second); // qualified namespace is the same as a full name, // it's just what gets produced when we're in a use namespace directive // use namespace a.b.Foo; -name = Pattern qualifiedNamespaceName : 0 -JBurg.Reduction reducer.dottedName(__p, first, second); +name = Pattern qualifiedNamespaceName: 0 +@Reduction reducer.dottedName(__p, first, second); // This reduction handles the bar.T part of foo.bar.T -dottedNamePart = Pattern fullName : 0 -JBurg.Reduction reducer.reduce_by_concatenation (__p, first, second); +dottedNamePart = Pattern fullName: 0 +@Reduction reducer.reduce_by_concatenation (__p, first, second); -name = Pattern superAccess : 0 -JBurg.Reduction reducer.reduce_superAccess (__p, qualified_name); +name = Pattern superAccess: 0 +@Reduction reducer.reduce_superAccess (__p, qualified_name); -name = Pattern superThisAccess : isSuperThisForFieldAccess() -JBurg.Reduction reducer.reduce_superAccess (__p, qualified_name); +name = Pattern superThisAccess: isSuperThisForFieldAccess() +@Reduction reducer.reduce_superAccess (__p, qualified_name); // A bare parameterized type name can only be // used as a type annotation. In code it's necessary // to expand it into an expression that calls applytype. type_name = Pattern parameterizedName :0 -JBurg.Reduction reducer.reduce_parameterizedName (__p, base, param); +@Reduction reducer.reduce_parameterizedName (__p, base, param); // A name can be a type_name, which in combination with // the reduction above yields the set of possible type_names: // identifiers and * -type_name = name : 1 -JBurg.Reduction reducer.reduce_nameToTypeName(name, true); +type_name = name: 1 +@Reduction reducer.reduce_nameToTypeName(name, true); // The 'new' expression takes a pseduo-type name: // when it can be resolved, the semantic analysis @@ -961,39 +961,39 @@ new_type_name = name; // Inflate this cost so it's only selected // if the type_name isn't a name. -new_type_name = type_name : 20 -JBurg.Reduction reducer.reduce_nameToTypeName(type_name, false); +new_type_name = type_name: 20 +@Reduction reducer.reduce_nameToTypeName(type_name, false); // Special rule to convert from name to type param expression // we need this because '*' converts special in this context -type_param_expression = name : 1 -JBurg.Reduction reducer.reduce_typeNameParameter(__p, name); +type_param_expression = name: 1 +@Reduction reducer.reduce_typeNameParameter(__p, name); // any other expression can be used as a type param name in an expression context type_param_expression = expression; -expression = Pattern parameterizedTypeExpression : 1 -JBurg.Reduction reducer.reduce_parameterizedTypeExpression (__p, base, param); +expression = Pattern parameterizedTypeExpression: 1 +@Reduction reducer.reduce_parameterizedTypeExpression (__p, base, param); expression = name: 2000 -JBurg.Reduction reducer.transform_name_to_expression(__p, name); +@Reduction reducer.transform_name_to_expression(__p, name); -type_name = Pattern voidExpr : 0 -JBurg.Reduction reducer.reduce_voidExpr_to_type_name(__p); +type_name = Pattern voidExpr: 0 +@Reduction reducer.reduce_voidExpr_to_type_name(__p); -name = Pattern attributeName : 0 -JBurg.Reduction reducer.reduce_attributeName (__p, attr_name); +name = Pattern attributeName: 0 +@Reduction reducer.reduce_attributeName (__p, attr_name); // ns1::foo and rt_ns::foo look alike to // the parser, so they must be disambiguated // by checking their semantic annotations. -name = Pattern namespaceAccess : qualifierIsCompileTimeConstant() -JBurg.Reduction reducer.reduce_namespaceAccess (__p, qualifier, qualified_name); +name = Pattern namespaceAccess: qualifierIsCompileTimeConstant() +@Reduction reducer.reduce_namespaceAccess (__p, qualifier, qualified_name); // Error trap for an unresolved namespace in a context // where it must be declared. name = Pattern namespaceAccess: ERROR_TRAP -JBurg.Reduction reducer.error_namespaceAccess(__p, qualifier, qualified_name); +@Reduction reducer.error_namespaceAccess(__p, qualifier, qualified_name); // A namespace-qualified name reference whose name // is a runtime expression, e.g., ns1::[foo]. @@ -1001,90 +1001,90 @@ JBurg.Reduction reducer.error_namespaceAccess(__p, qualifier, qualified_name); // ns1::[foo] and rt_ns::[foo], so we need a cost // function to disambiguate the tree. runtime_name_expression = Pattern namespaceMultinameL: qualifierIsCompileTimeConstant() -JBurg.Reduction reducer.reduce_namespaceMultinameL(__p, qualifier, expr); +@Reduction reducer.reduce_namespaceMultinameL(__p, qualifier, expr); -runtime_name_expression = Pattern namespaceRTQName : 2000 -JBurg.Reduction reducer.reduce_namespaceRTQName (__p, qualifier, qualfied_name); +runtime_name_expression = Pattern namespaceRTQName: 2000 +@Reduction reducer.reduce_namespaceRTQName (__p, qualifier, qualfied_name); -expression = Pattern embedExpression : 2 -JBurg.Reduction reducer.reduce_embed(__p); +expression = Pattern embedExpression: 2 +@Reduction reducer.reduce_embed(__p); /* * E4X expressions (except literals) */ -expression = Pattern e4xFilter : 3 -JBurg.Reduction reducer.reduce_e4xFilter (__p, stem, filter); +expression = Pattern e4xFilter: 3 +@Reduction reducer.reduce_e4xFilter (__p, stem, filter); -runtime_name_expression = Pattern namespaceRTQNameL : 2000 -JBurg.Reduction reducer.reduce_namespaceRTQNameL (__p, qualifier, expr); +runtime_name_expression = Pattern namespaceRTQNameL: 2000 +@Reduction reducer.reduce_namespaceRTQNameL (__p, qualifier, expr); -expression = runtime_name_expression : 1 -JBurg.Reduction reducer.transform_runtime_name_expression(__p, runtime_name_expression); +expression = runtime_name_expression: 1 +@Reduction reducer.transform_runtime_name_expression(__p, runtime_name_expression); expression = Pattern runtimeNameExpression: 1 -JBurg.Reduction reducer.reduce_runtimeNameExpression(__p, expr); +@Reduction reducer.reduce_runtimeNameExpression(__p, expr); name = Pattern namespaceAsName: 1 -JBurg.Reduction reducer.reduce_namespaceAsName_to_name(__p); +@Reduction reducer.reduce_namespaceAsName_to_name(__p); expression = Pattern namespaceAsName: 1 -JBurg.Reduction reducer.reduce_namespaceAsName_to_expression(__p); +@Reduction reducer.reduce_namespaceAsName_to_expression(__p); void_expression = Pattern assignToRuntimeNameExpr: 1 -JBurg.Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, DISCARD_VALUE); +@Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, DISCARD_VALUE); expression = Pattern assignToRuntimeNameExpr: 1 -JBurg.Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, NEED_VALUE); +@Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, NEED_VALUE); -expression = Pattern descendantsExpression : 1 -JBurg.Reduction reducer.reduce_memberAccessExpr(__p, stem, descendants, OP_getdescendants); +expression = Pattern descendantsExpression: 1 +@Reduction reducer.reduce_memberAccessExpr(__p, stem, descendants, OP_getdescendants); /* * E4X directives and statements */ -statement = Pattern defaultXMLNamespace : 1 -JBurg.Reduction reducer.reduce_defaultXMLNamespace(__p, ns_expr); +statement = Pattern defaultXMLNamespace: 1 +@Reduction reducer.reduce_defaultXMLNamespace(__p, ns_expr); /* * Literals. */ -e4x_literal = Pattern XMLLiteral : 0 -JBurg.Reduction reducer.getStringLiteralContent (__p); +e4x_literal = Pattern XMLLiteral: 0 +@Reduction reducer.getStringLiteralContent (__p); string_constant = e4x_literal; expression = Pattern XMLContent: 1 -JBurg.Reduction reducer.reduce_XMLContent(__p, exprs); +@Reduction reducer.reduce_XMLContent(__p, exprs); expression = Pattern XMLList: 2 -JBurg.Reduction reducer.reduce_XMLList(__p, exprs); +@Reduction reducer.reduce_XMLList(__p, exprs); expression = Pattern XMLListConst: 1 -JBurg.Reduction reducer.reduce_XMLListConst(__p, elements); +@Reduction reducer.reduce_XMLListConst(__p, elements); expression = literal; literal = object_literal; literal = boolean_literal; literal = array_literal; -expression = string_constant : 1 -JBurg.Reduction reducer.transform_string_constant(__p, string_constant); +expression = string_constant: 1 +@Reduction reducer.transform_string_constant(__p, string_constant); integer_constant = Pattern integerLiteral: 0 -JBurg.Reduction reducer.getIntegerContent(__p); +@Reduction reducer.getIntegerContent(__p); -expression = integer_constant : 1 -JBurg.Reduction reducer.transform_integer_constant(__p, integer_constant); +expression = integer_constant: 1 +@Reduction reducer.transform_integer_constant(__p, integer_constant); uint_constant = Pattern uintLiteral: 0 -JBurg.Reduction reducer.getUintContent(__p); +@Reduction reducer.getUintContent(__p); -expression = uint_constant : 1 -JBurg.Reduction reducer.transform_uint_constant(__p, uint_constant); +expression = uint_constant: 1 +@Reduction reducer.transform_uint_constant(__p, uint_constant); -expression = boolean_constant : 1 -JBurg.Reduction reducer.transform_boolean_constant(__p, boolean_constant); +expression = boolean_constant: 1 +@Reduction reducer.transform_boolean_constant(__p, boolean_constant); /** @@ -1092,63 +1092,63 @@ JBurg.Reduction reducer.transform_boolean_constant(__p, boolean_constant); */ // Constant-folded arithmetic for all types. -JBurg.include "ConstantArithmetic.jbg" +@include "ConstantArithmetic.jbg" // Constant-folded logic for all types -JBurg.include "ConstantLogic.jbg" +@include "ConstantLogic.jbg" // Error trap for non-constant expressions // used in a context where only a constant is valid, // e.g., foo() in function needsConstantInit(x = foo()). -required_constant_value = expression : ERROR_TRAP -JBurg.Reduction reducer.transform_expression_to_constant_value(__p, expression); +required_constant_value = expression: ERROR_TRAP +@Reduction reducer.transform_expression_to_constant_value(__p, expression); // A name can be used as a constant in some contexts, // e.g., if it's a Namespace or otherwise known to be // a compile-time constant. -constant_value = name : isCompileTimeConstant() -JBurg.Reduction reducer.transform_name_to_constant_value(__p); +constant_value = name: isCompileTimeConstant() +@Reduction reducer.transform_name_to_constant_value(__p); constant_value = Pattern constantDottedName: isCompileTimeConstant() -JBurg.Reduction reducer.transform_name_to_constant_value(__p); +@Reduction reducer.transform_name_to_constant_value(__p); -double_constant = Pattern doubleLiteral : 3 -JBurg.Reduction reducer.getDoubleContent(__p); +double_constant = Pattern doubleLiteral: 3 +@Reduction reducer.getDoubleContent(__p); -integer_constant = LiteralIntegerZeroID(void) : 1 -JBurg.Reduction reducer.getIntegerZeroContent(__p); +integer_constant = LiteralIntegerZeroID(void): 1 +@Reduction reducer.getIntegerZeroContent(__p); -uint_constant = LiteralIntegerZeroID(void) : 1 -JBurg.Reduction reducer.getIntegerZeroContentAsLong(__p); +uint_constant = LiteralIntegerZeroID(void): 1 +@Reduction reducer.getIntegerZeroContentAsLong(__p); -constant_value = Pattern nullLiteral : 0 -JBurg.Reduction reducer.reduce_nullLiteral_to_constant_value (__p); +constant_value = Pattern nullLiteral: 0 +@Reduction reducer.reduce_nullLiteral_to_constant_value (__p); constant_value = Pattern void0Literal: 0 -JBurg.Reduction reducer.reduce_void0Literal_to_constant_value(__p); +@Reduction reducer.reduce_void0Literal_to_constant_value(__p); constant_value = Pattern voidConstant: 0 -JBurg.Reduction reducer.reduce_voidOperator_to_constant_value(__p, value); +@Reduction reducer.reduce_voidOperator_to_constant_value(__p, value); boolean_constant = Pattern booleanLiteral: 0 -JBurg.Reduction reducer.reduce_booleanLiteral(__p); +@Reduction reducer.reduce_booleanLiteral(__p); -string_constant = Pattern stringLiteral : 0 -JBurg.Reduction reducer.getStringLiteralContent (__p); +string_constant = Pattern stringLiteral: 0 +@Reduction reducer.getStringLiteralContent (__p); numeric_constant = integer_constant; numeric_constant = uint_constant; numeric_constant = double_constant; -constant_value = string_constant : 1 -JBurg.Reduction reducer.transform_string_constant_to_constant(__p, string_constant); +constant_value = string_constant: 1 +@Reduction reducer.transform_string_constant_to_constant(__p, string_constant); -constant_value = boolean_constant : 1 -JBurg.Reduction reducer.transform_boolean_constant_to_constant(__p, boolean_constant); +constant_value = boolean_constant: 1 +@Reduction reducer.transform_boolean_constant_to_constant(__p, boolean_constant); -constant_value = numeric_constant : 1 -JBurg.Reduction reducer.transform_numeric_constant_to_constant(__p, numeric_constant); +constant_value = numeric_constant: 1 +@Reduction reducer.transform_numeric_constant_to_constant(__p, numeric_constant); required_constant_value = constant_value; @@ -1156,79 +1156,79 @@ required_constant_value = constant_value; // double failed in LiteralNumberNode.getNodeID(). // It's not likely to work better here, // but the BURM will emit some diagnostics. -double_constant = Pattern numericLiteral : 3 -JBurg.Reduction reducer.getDoubleContent(__p); +double_constant = Pattern numericLiteral: 3 +@Reduction reducer.getDoubleContent(__p); -expression = double_constant : 5 -JBurg.Reduction reducer.transform_double_constant(__p, double_constant); +expression = double_constant: 5 +@Reduction reducer.transform_double_constant(__p, double_constant); -expression = numeric_constant : 5 -JBurg.Reduction reducer.transform_numeric_constant(__p, numeric_constant); +expression = numeric_constant: 5 +@Reduction reducer.transform_numeric_constant(__p, numeric_constant); -expression = constant_value : 0 -JBurg.Reduction reducer.transform_constant_value(__p, constant_value); +expression = constant_value: 0 +@Reduction reducer.transform_constant_value(__p, constant_value); -object_literal = Pattern nullLiteral : 1 -JBurg.Reduction reducer.reduce_nullLiteral_to_object_literal (__p); +object_literal = Pattern nullLiteral: 1 +@Reduction reducer.reduce_nullLiteral_to_object_literal (__p); -object_literal = Pattern objectLiteral : 3 -JBurg.Reduction reducer.reduce_objectLiteral (__p, elements); +object_literal = Pattern objectLiteral: 3 +@Reduction reducer.reduce_objectLiteral (__p, elements); -object_literal_element = Pattern objectLiteralElement : 0 -JBurg.Reduction reducer.reduce_objectLiteralElement (__p, id, value); +object_literal_element = Pattern objectLiteralElement: 0 +@Reduction reducer.reduce_objectLiteralElement (__p, id, value); -non_resolving_identifier = Pattern nonResolvingIdentifier : 0 -JBurg.Reduction reducer.getIdentifierContent(__p); +non_resolving_identifier = Pattern nonResolvingIdentifier: 0 +@Reduction reducer.getIdentifierContent(__p); -expression = non_resolving_identifier : 1 -JBurg.Reduction reducer.transform_non_resolving_identifier(__p, non_resolving_identifier); +expression = non_resolving_identifier: 1 +@Reduction reducer.transform_non_resolving_identifier(__p, non_resolving_identifier); object_literal = Pattern regexLiteral: 5 -JBurg.Reduction reducer.reduce_regexLiteral(__p); +@Reduction reducer.reduce_regexLiteral(__p); object_literal = Pattern void0Literal: 1 -JBurg.Reduction reducer.reduce_void0Literal_to_object_literal(__p); +@Reduction reducer.reduce_void0Literal_to_object_literal(__p); object_literal = Pattern void0Operator: 1 -JBurg.Reduction reducer.reduce_void0Operator(__p); +@Reduction reducer.reduce_void0Operator(__p); -expression = Pattern voidOperator : 1 -JBurg.Reduction reducer.reduce_voidOperator_to_expression (__p, expr); +expression = Pattern voidOperator: 1 +@Reduction reducer.reduce_voidOperator_to_expression (__p, expr); -expression = Pattern voidExpr : 1 -JBurg.Reduction reducer.reduce_voidExpr_to_expression(__p); +expression = Pattern voidExpr: 1 +@Reduction reducer.reduce_voidExpr_to_expression(__p); boolean_literal = boolean_constant: 1 -JBurg.Reduction reducer.transform_boolean_constant(__p, boolean_constant); +@Reduction reducer.transform_boolean_constant(__p, boolean_constant); -array_literal = Pattern arrayLiteral : 1 -JBurg.Reduction reducer.reduce_arrayLiteral (__p, elements); +array_literal = Pattern arrayLiteral: 1 +@Reduction reducer.reduce_arrayLiteral (__p, elements); vector_literal = Pattern vectorLiteral: 1 -JBurg.Reduction reducer.reduce_vectorLiteral(__p, type_param, elements); +@Reduction reducer.reduce_vectorLiteral(__p, type_param, elements); /* * Directives. */ statement = Pattern useNamespaceDirective: 0 -JBurg.Reduction reducer.reduce_useNamespaceDirective(__p, ns_name); +@Reduction reducer.reduce_useNamespaceDirective(__p, ns_name); -import_name = Pattern simpleName : 0 -JBurg.Reduction reducer.createInstructionList(__p); +import_name = Pattern simpleName: 0 +@Reduction reducer.createInstructionList(__p); -import_name = Pattern fullName : 0 -JBurg.Reduction reducer.createInstructionList(__p); +import_name = Pattern fullName: 0 +@Reduction reducer.createInstructionList(__p); statement = Pattern importDirective: 0 -JBurg.Reduction reducer.reduce_importDirective(__p); +@Reduction reducer.reduce_importDirective(__p); /* * MXML constructs */ -function = Pattern mxmlEventSpecifier : 0 -Prologue reducer.prologue_mxmlEventSpecifier(p) -JBurg.Reduction reducer.reduce_mxmlEventSpecifier (__p, stmts); +function = Pattern mxmlEventSpecifier: 0 +@Prologue reducer.prologue_mxmlEventSpecifier(p) +@Reduction reducer.reduce_mxmlEventSpecifier (__p, stmts); // MXML data binding setter expression's @@ -1239,20 +1239,20 @@ JBurg.Reduction reducer.reduce_mxmlEventSpecifier (__p, stmts); // The mxml_data_binding_setter_expression is used // as the goal state when this BURM is invoked from // AbcGenerator.generateMXMLDataBindingSetterFunction. -mxml_data_binding_setter_expression = Pattern memberAccessExpr : 1 -JBurg.Reduction reducer.reduce_memberAccessExpr_to_mxmlDataBindingSetter(__p, stem, member); +mxml_data_binding_setter_expression = Pattern memberAccessExpr: 1 +@Reduction reducer.reduce_memberAccessExpr_to_mxmlDataBindingSetter(__p, stem, member); -mxml_data_binding_setter_expression = Pattern qualifiedMemberAccessExpr : 10 -JBurg.Reduction reducer.reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter(__p, stem, qualifier, member); +mxml_data_binding_setter_expression = Pattern qualifiedMemberAccessExpr: 10 +@Reduction reducer.reduce_qualifiedMemberAccessExpr_to_mxmlDataBindingSetter(__p, stem, qualifier, member); -mxml_data_binding_setter_expression = Pattern qualifiedMemberRuntimeNameExpr : 100 -JBurg.Reduction reducer.reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter(__p, stem, qualifier, runtime_member); +mxml_data_binding_setter_expression = Pattern qualifiedMemberRuntimeNameExpr: 100 +@Reduction reducer.reduce_qualifiedMemberRuntimeNameExpr_to_mxmlDataBindingSetter(__p, stem, qualifier, runtime_member); -mxml_data_binding_setter_expression = Pattern arrayIndexExpr : 1 -JBurg.Reduction reducer.reduce_arrayIndexExpr_to_mxmlDataBindingSetter(__p, stem, index, false); +mxml_data_binding_setter_expression = Pattern arrayIndexExpr: 1 +@Reduction reducer.reduce_arrayIndexExpr_to_mxmlDataBindingSetter(__p, stem, index, false); -mxml_data_binding_setter_expression = name : 1 -JBurg.Reduction reducer.reduceName_to_mxmlDataBindingSetter(__p, name); +mxml_data_binding_setter_expression = name: 1 +@Reduction reducer.reduceName_to_mxmlDataBindingSetter(__p, name); -mxml_data_binding_setter_expression = runtime_name_expression : 1 -JBurg.Reduction reducer.reduceRuntimeName_to_mxmlDataBindingSetter(__p, runtime_name_expression); +mxml_data_binding_setter_expression = runtime_name_expression: 1 +@Reduction reducer.reduceRuntimeName_to_mxmlDataBindingSetter(__p, runtime_name_expression);
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/a185d7ee/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentPatterns.jbg ---------------------------------------------------------------------- diff --git a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentPatterns.jbg b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentPatterns.jbg index 521205c..1f19732 100644 --- a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentPatterns.jbg +++ b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentPatterns.jbg @@ -18,22 +18,22 @@ //////////////////////////////////////////////////////////////////////////////// // x op= foo -Pattern compoundAssignToName +@Pattern compoundAssignToName Op_COMPOUND_ASSIGN(name operand, expression expr); // x.y op= foo -Pattern compoundAssignToMember +@Pattern compoundAssignToMember Op_COMPOUND_ASSIGN(MemberAccessExpressionID(expression stem, name member), expression expr); // a[i] op= foo -Pattern compoundAssignToBracket +@Pattern compoundAssignToBracket Op_COMPOUND_ASSIGN(ArrayIndexExpressionID(expression stem, expression index), expression expr); // a..y op= foo -Pattern compoundAssignToDescendants +@Pattern compoundAssignToDescendants Op_COMPOUND_ASSIGN(Op_DescendantsID(expression stem, name member), expression expr); // n::x op= foo -Pattern compoundAssignToRuntimeName +@Pattern compoundAssignToRuntimeName Op_COMPOUND_ASSIGN(runtime_name_expression name, expression expr); http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/a185d7ee/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentRules.jbg ---------------------------------------------------------------------- diff --git a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentRules.jbg b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentRules.jbg index 0cd819a..a9b1b5c 100644 --- a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentRules.jbg +++ b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundAssignmentRules.jbg @@ -18,32 +18,32 @@ //////////////////////////////////////////////////////////////////////////////// void_expression = Pattern compoundAssignToName : 4 -JBurg.Reduction reducer.generateCompoundAssignment(__p, operand, expr, opcode, DISCARD_VALUE); +@Reduction reducer.generateCompoundAssignment(__p, operand, expr, opcode, DISCARD_VALUE); expression = Pattern compoundAssignToName : 4 -JBurg.Reduction reducer.generateCompoundAssignment(__p, operand, expr, opcode, NEED_VALUE); +@Reduction reducer.generateCompoundAssignment(__p, operand, expr, opcode, NEED_VALUE); void_expression = Pattern compoundAssignToMember : 4 -JBurg.Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getproperty, opcode, DISCARD_VALUE); +@Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getproperty, opcode, DISCARD_VALUE); expression = Pattern compoundAssignToMember : 4 -JBurg.Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getproperty, opcode, NEED_VALUE); +@Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getproperty, opcode, NEED_VALUE); expression = Pattern compoundAssignToBracket : 4 -JBurg.Reduction reducer.generateCompoundBracketAssignment(__p, stem, index, expr, opcode, NEED_VALUE); +@Reduction reducer.generateCompoundBracketAssignment(__p, stem, index, expr, opcode, NEED_VALUE); void_expression = Pattern compoundAssignToBracket : 4 -JBurg.Reduction reducer.generateCompoundBracketAssignment(__p, stem, index, expr, opcode, DISCARD_VALUE); +@Reduction reducer.generateCompoundBracketAssignment(__p, stem, index, expr, opcode, DISCARD_VALUE); void_expression = Pattern compoundAssignToDescendants : 4 -JBurg.Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getdescendants, opcode, DISCARD_VALUE); +@Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getdescendants, opcode, DISCARD_VALUE); expression = Pattern compoundAssignToDescendants : 4 -JBurg.Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getdescendants, opcode, NEED_VALUE); +@Reduction reducer.generateCompoundMemberAssignment(__p, stem, member, expr, OP_getdescendants, opcode, NEED_VALUE); void_expression = Pattern compoundAssignToRuntimeName : 4 -JBurg.Reduction reducer.generateCompoundAssignmentToRuntimeName(__p, name, expr, opcode, DISCARD_VALUE); +@Reduction reducer.generateCompoundAssignmentToRuntimeName(__p, name, expr, opcode, DISCARD_VALUE); expression = Pattern compoundAssignToRuntimeName : 4 -JBurg.Reduction reducer.generateCompoundAssignmentToRuntimeName(__p, name, expr, opcode, NEED_VALUE); +@Reduction reducer.generateCompoundAssignmentToRuntimeName(__p, name, expr, opcode, NEED_VALUE); http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/a185d7ee/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundLogicalAssignmentRules.jbg ---------------------------------------------------------------------- diff --git a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundLogicalAssignmentRules.jbg b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundLogicalAssignmentRules.jbg index 510f11c..e9017ec 100644 --- a/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundLogicalAssignmentRules.jbg +++ b/compiler/src/main/jburg/org/apache/flex/compiler/internal/as/codegen/CompoundLogicalAssignmentRules.jbg @@ -18,35 +18,35 @@ //////////////////////////////////////////////////////////////////////////////// void_expression = Pattern compoundAssignToName : 4 -JBurg.Reduction reducer.generateCompoundLogicalAssignment(__p, operand, expr, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalAssignment(__p, operand, expr, IsAnd, DISCARD_VALUE); expression = Pattern compoundAssignToName : 4 -JBurg.Reduction reducer.generateCompoundLogicalAssignment(__p, operand, expr, IsAnd, NEED_VALUE); +@Reduction reducer.generateCompoundLogicalAssignment(__p, operand, expr, IsAnd, NEED_VALUE); void_expression = Pattern compoundAssignToMember : 4 -JBurg.Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getproperty, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getproperty, IsAnd, DISCARD_VALUE); expression = Pattern compoundAssignToMember : 4 -JBurg.Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getproperty, IsAnd, NEED_VALUE); +@Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getproperty, IsAnd, NEED_VALUE); expression = Pattern compoundAssignToBracket : 4 -JBurg.Reduction reducer.generateCompoundLogicalBracketAssignment(__p, stem, index, expr, IsAnd, NEED_VALUE); +@Reduction reducer.generateCompoundLogicalBracketAssignment(__p, stem, index, expr, IsAnd, NEED_VALUE); void_expression = Pattern compoundAssignToBracket : 4 -JBurg.Reduction reducer.generateCompoundLogicalBracketAssignment(__p, stem, index, expr, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalBracketAssignment(__p, stem, index, expr, IsAnd, DISCARD_VALUE); void_expression = Pattern compoundAssignToDescendants : 4 -JBurg.Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, DISCARD_VALUE); void_expression = Pattern compoundAssignToDescendants : 4 -JBurg.Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, DISCARD_VALUE); expression = Pattern compoundAssignToDescendants : 4 -JBurg.Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, NEED_VALUE); +@Reduction reducer.generateCompoundLogicalMemberAssignment(__p, stem, member, expr, OP_getdescendants, IsAnd, NEED_VALUE); void_expression = Pattern compoundAssignToRuntimeName : 4 -JBurg.Reduction reducer.generateCompoundLogicalRuntimeNameAssignment(__p, name, expr, IsAnd, DISCARD_VALUE); +@Reduction reducer.generateCompoundLogicalRuntimeNameAssignment(__p, name, expr, IsAnd, DISCARD_VALUE); expression = Pattern compoundAssignToRuntimeName : 4 -JBurg.Reduction reducer.generateCompoundLogicalRuntimeNameAssignment(__p, name, expr, IsAnd, NEED_VALUE); +@Reduction reducer.generateCompoundLogicalRuntimeNameAssignment(__p, name, expr, IsAnd, NEED_VALUE);
