| /* |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| Pattern foldedExpressionPattern |
| FoldedExpressionID(void); |
| |
| foldedExpression = Pattern foldedExpressionPattern: 1 |
| JBurg.Reduction reducer.reduceLazyExpression(__p); |
| |
| Pattern logicalAndExprLazy |
| Op_LogicalAndID(expression l, foldedExpression r); |
| |
| Pattern logicalOrExprLazy |
| Op_LogicalOrID(expression l, foldedExpression r); |
| |
| /* |
| * AS3DebuggerRules.jbg holds the rewrite rules for debugger support. |
| * @see AS3Patterns.jbg, which holds the corresponding patterns. |
| */ |
| |
| /* |
| * Assignment to a simple name. |
| */ |
| expression = Pattern assignToNameExpr: 2 |
| JBurg.Reduction reducer.reduce_assignToNameExpr_to_expression(__p, lval,r); |
| |
| /* |
| * Assignment to a more general lvalue. |
| */ |
| expression = Pattern assignToMemberExpr : 10 |
| JBurg.Reduction reducer.reduce_assignToMemberExpr_to_expression(__p, stem, member, r); |
| |
| /* |
| * Assignment to a[i] type lvalue. |
| */ |
| expression = Pattern assignToBracketExpr: 1 |
| JBurg.Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, stem, index, r, false); |
| |
| expression = Pattern assignToSuperBracketExpr: 1 |
| JBurg.Reduction reducer.reduce_assignToBracketExpr_to_expression(__p, null, index, r, true); |
| |
| /* |
| * Assignment to qualified names and attributes. |
| */ |
| expression = Pattern assignToQualifiedMemberExpr : 1 |
| JBurg.Reduction reducer.reduce_assignToQualifiedMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); |
| |
| expression = Pattern assignToQualifiedRuntimeMemberExpr : 1 |
| JBurg.Reduction reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p, stem, qualifier, member, r, NEED_VALUE); |
| |
| expression = Pattern assignToQualifiedAttributeExpr : 1 |
| JBurg.Reduction reducer.reduce_assignToQualifiedAttributeExpr(__p, stem, qualifier, attribute, r, NEED_VALUE); |
| |
| expression = Pattern assignToUnqualifiedRuntimeAttributeExpr : 1 |
| JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); |
| |
| expression = Pattern assignToUnqualifiedRuntimeDescendantsAttributeExpr : 1 |
| JBurg.Reduction reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p, stem, rt_attr_name, r, NEED_VALUE); |
| |
| /* |
| * Assignment to descendants. |
| */ |
| expression = Pattern assignToDescendantsExpr : 1 |
| JBurg.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); |
| |
| /* |
| * Miscellaneous void expressions. |
| */ |
| expression = Pattern nilExpr : 1 |
| JBurg.Reduction reducer.reduce_nilExpr_to_expression(__p); |
| |
| /* |
| * Binary logical operators. |
| */ |
| comparison_expression = Pattern equalExpr : 1 |
| JBurg.Reduction reducer.binaryOp (__p, l, r, OP_equals); |
| |
| comparison_expression = Pattern neqExpr : 1 |
| JBurg.Reduction reducer.reduce_neqExpr (__p, l, r); |
| |
| comparison_expression = Pattern stricteqExpr : 1 |
| JBurg.Reduction reducer.binaryOp (__p, l, r, OP_strictequals); |
| |
| comparison_expression = Pattern strictneqExpr : 1 |
| JBurg.Reduction reducer.reduce_strictneqExpr (__p, l, r); |
| |
| comparison_expression = Pattern greaterThanExpr: 1 |
| JBurg.Reduction reducer.binaryOp (__p, l, r, OP_greaterthan); |
| |
| comparison_expression = Pattern greaterThanEqExpr: 1 |
| JBurg.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 lessEqExpr : 1 |
| JBurg.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 logicalAndExprLazy : 5 |
| JBurg.Reduction reducer.reduce_logicalAndExpr (__p, l, r); |
| |
| expression = Pattern logicalOrExprLazy : 5 |
| JBurg.Reduction reducer.reduce_logicalOrExpr (__p, l, r); |
| |
| expression = Pattern logicalNotExpr : 1 |
| JBurg.Reduction reducer.reduce_logicalNotExpr (__p, expr); |
| |
| expression = Pattern ternaryExpr : 1 |
| JBurg.Reduction reducer.reduce_ternaryExpr (__p, test, when_true, when_false); |
| |
| /* |
| * Binary arithmetic operators. |
| */ |
| |
| expression = Pattern divideExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_divide); |
| |
| expression = Pattern multExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_multiply); |
| |
| expression = Pattern moduloExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_modulo); |
| |
| expression = Pattern addExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_add); |
| |
| expression = Pattern subtractExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_subtract); |
| |
| expression = Pattern bitwiseLeftShiftExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_lshift); |
| |
| expression = Pattern bitwiseRightShiftExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_rshift); |
| |
| expression = Pattern bitwiseUnsignedRightShiftExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_urshift); |
| |
| expression = Pattern bitwiseAndExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_bitand); |
| |
| expression = Pattern bitwiseOrExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, l, r, OP_bitor); |
| |
| expression = Pattern bitwiseXorExpr : 1 |
| JBurg.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 preIncNameExpr : 7 |
| JBurg.Reduction reducer.reduce_preIncNameExpr(__p, unary, true); |
| |
| expression = Pattern preIncMemberExpr : 8 |
| JBurg.Reduction reducer.reduce_preIncMemberExpr(__p, stem, field, true); |
| |
| expression = Pattern postIncMemberExpr: 8 |
| JBurg.Reduction reducer.reduce_postIncMemberExpr(__p, stem, field, true); |
| |
| expression = Pattern preIncBracketExpr: 8 |
| JBurg.Reduction reducer.reduce_preIncBracketExpr(__p, stem, index, true); |
| |
| expression = Pattern postIncBracketExpr: 8 |
| JBurg.Reduction reducer.reduce_postIncBracketExpr(__p, stem, index, true); |
| |
| expression = Pattern postDecNameExpr : 7 |
| JBurg.Reduction reducer.reduce_postDecNameExpr(__p, unary, true); |
| |
| expression = Pattern preDecNameExpr : 7 |
| JBurg.Reduction reducer.reduce_preDecNameExpr(__p, unary, true); |
| |
| expression = Pattern preDecMemberExpr : 8 |
| JBurg.Reduction reducer.reduce_preDecMemberExpr(__p, stem, field, true); |
| |
| expression = Pattern postDecMemberExpr: 8 |
| JBurg.Reduction reducer.reduce_postDecMemberExpr(__p, stem, field, true); |
| |
| expression = Pattern preDecBracketExpr: 8 |
| JBurg.Reduction reducer.reduce_preDecBracketExpr(__p, stem, index, true); |
| |
| expression = Pattern postDecBracketExpr: 8 |
| JBurg.Reduction reducer.reduce_postDecBracketExpr(__p, stem, index, true); |
| |
| /* |
| * Unary expressions. |
| */ |
| expression = Pattern unaryMinusExpr: 1 |
| JBurg.Reduction reducer.unaryOp(__p, e, OP_negate); |
| |
| expression = Pattern unaryPlusExpr: 0 |
| { |
| return reducer.unaryOp(__p, e, OP_convert_d); |
| } |
| |
| expression = Pattern typeofExpr: 10 |
| JBurg.Reduction reducer.reduce_typeof_expr(__p, expr); |
| |
| expression = Pattern typeofName: 1 |
| JBurg.Reduction reducer.reduce_typeof_name(__p, n); |
| |
| expression = Pattern bitNotExpr: 1 |
| JBurg.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 astypeExprLate : 1 |
| JBurg.Reduction reducer.binaryOp(__p, expr, typename, OP_astypelate); |
| |
| expression = Pattern inExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, needle, haystack, OP_in); |
| |
| expression = Pattern instanceofExpr : 1 |
| JBurg.Reduction reducer.binaryOp(__p, expr, typename, OP_instanceof); |
| |
| // lhs += rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_add" \ |
| compoundAssignToName="assignPlusToNameExpr" \ |
| compoundAssignToMember="assignPlusToMemberExpr" \ |
| compoundAssignToBracket="assignPlusToBracketExpr" |
| |
| // lhs *= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_multiply" \ |
| compoundAssignToName="assignMultiplyToNameExpr" \ |
| compoundAssignToMember="assignMultiplyToMemberExpr" \ |
| compoundAssignToBracket="assignMultiplyToBracketExpr" |
| |
| // lhs -= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_subtract" \ |
| compoundAssignToName="assignMinusToNameExpr" \ |
| compoundAssignToMember="assignMinusToMemberExpr" \ |
| compoundAssignToBracket="assignMinusToBracketExpr" |
| |
| // lhs /= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_divide" \ |
| compoundAssignToName="assignDivideToNameExpr" \ |
| compoundAssignToMember="assignDivideToMemberExpr" \ |
| compoundAssignToBracket="assignDivideToBracketExpr" |
| |
| // lhs %= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_modulo" \ |
| compoundAssignToName="assignModuloToNameExpr" \ |
| compoundAssignToMember="assignModuloToMemberExpr" \ |
| compoundAssignToBracket="assignModuloToBracketExpr" |
| |
| // lhs <<= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_lshift" \ |
| compoundAssignToName="assignLeftShiftToNameExpr" \ |
| compoundAssignToMember="assignLeftShiftToMemberExpr" \ |
| compoundAssignToBracket="assignLeftShiftToBracketExpr" |
| |
| // lhs <<= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_rshift" \ |
| compoundAssignToName="assignRightShiftToNameExpr" \ |
| compoundAssignToMember="assignRightShiftToMemberExpr" \ |
| compoundAssignToBracket="assignRightShiftToBracketExpr" |
| |
| // lhs >>>= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_urshift" \ |
| compoundAssignToName="assignUnsignedRightShiftToNameExpr" \ |
| compoundAssignToMember="assignUnsignedRightShiftToMemberExpr" \ |
| compoundAssignToBracket="assignUnsignedRightShiftToBracketExpr" |
| |
| // lhs &= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_bitand" \ |
| compoundAssignToName="assignBitwiseAndToNameExpr" \ |
| compoundAssignToMember="assignBitwiseAndToMemberExpr" \ |
| compoundAssignToBracket="assignBitwiseAndToBracketExpr" |
| |
| // lhs |= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_bitor" \ |
| compoundAssignToName="assignBitwiseOrToNameExpr" \ |
| compoundAssignToMember="assignBitwiseOrToMemberExpr" \ |
| compoundAssignToBracket="assignBitwiseOrToBracketExpr" |
| |
| // lhs ^= rhs |
| JBurg.include "AS3DebuggerCompoundAssignmentRules.jbg" \ |
| Op_COMPOUND_ASSIGN="OP_bitxor" \ |
| compoundAssignToName="assignBitwiseXorToNameExpr" \ |
| compoundAssignToMember="assignBitwiseXorToMemberExpr" \ |
| compoundAssignToBracket="assignBitwiseXorToBracketExpr" |
| |
| /* |
| * Primary expressions. |
| */ |
| expression = Pattern memberAccessExpr : 10 |
| JBurg.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 qualifiedDescendantsExpr : 10 |
| JBurg.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 qualifiedAttributeExpr : 1 |
| JBurg.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 qualifiedAttributeRuntimeMemberExpr : 1 |
| JBurg.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); |
| |
| // Prefer the basic memberAccessExpr pattern where feasible. |
| expression = Pattern qualifiedMemberRuntimeNameExpr : 100 |
| JBurg.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 unqualifiedDescendantsAttributeExpr : 1 |
| JBurg.Reduction reducer.reduce_unqualifiedAttributeExpr(__p, stem, expr, OP_getdescendants); |
| |
| expression = Pattern runtimeAttributeExp : 1 |
| JBurg.Reduction reducer.reduce_runtimeAttributeExp(__p, expr); |
| |
| expression = Pattern arrayIndexExpr : 1 |
| JBurg.Reduction reducer.reduce_arrayIndexExpr (__p, stem, false, index); |
| |
| expression = Pattern superIndexExpr : 1 |
| JBurg.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 newVectorLiteral: 0 |
| JBurg.Reduction reducer.reduce_newVectorLiteral(__p, literal); |
| |
| // '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 newMemberProperty: 10 |
| JBurg.Reduction reducer.reduce_newMemberProperty(__p, stem, member, args); |
| |
| expression = Pattern newAsRandomExpr : 30 |
| JBurg.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 functionCallOfExplicitObjectSuperclassMethod : 2 |
| JBurg.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 functionAsBracketExpr : 4 |
| JBurg.Reduction reducer.reduce_functionAsBracketExpr (__p, stem, index, args); |
| |
| expression = Pattern functionAsRandomExpr : 30 |
| JBurg.Reduction reducer.reduce_functionAsRandomExpr (__p, random_expr, args); |
| |
| /* |
| * Delete expressions. |
| */ |
| expression = Pattern deleteNameExpr: 2 |
| JBurg.Reduction reducer.reduce_deleteNameExpr(__p, n); |
| |
| expression = Pattern deleteBracketExpr: 1 |
| JBurg.Reduction reducer.reduce_deleteBracketExpr(__p, stem, index); |
| |
| expression = Pattern deleteAtBracketExpr: 1 |
| JBurg.Reduction reducer.reduce_deleteAtBracketExpr(__p, stem, index); |
| |
| expression = Pattern deleteMemberExpr: 1 |
| JBurg.Reduction reducer.reduce_deleteMemberExpr(__p, stem, field); |
| |
| expression = Pattern deleteRuntimeNameExpr: 1 |
| JBurg.Reduction reducer.reduce_deleteRuntimeNameExpr(__p, stem, rt_name); |
| |
| expression = Pattern deleteDescendantsExpr: 1 |
| JBurg.Reduction reducer.reduce_deleteDescendantsExpr(__p, stem, field); |
| |
| expression = Pattern deleteAnyExprExprExpr: 2000 |
| JBurg.Reduction reducer.reduce_deleteExprExprExpr(__p, expr); |
| |
| /* |
| * Comma expression. |
| */ |
| expression = Pattern commaExpr: 0 |
| JBurg.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); |
| |
| qualifiedNamePart = Pattern simpleName: 0 |
| JBurg.Reduction reducer.getIdentifierContent(__p); |
| |
| name = Pattern typedVariableExpression : 0 |
| JBurg.Reduction reducer.reduce_typedVariableExpression (__p, var_name, var_type); |
| |
| dottedNamePart = Pattern dottedName : 0 |
| JBurg.Reduction reducer.reduce_by_concatenation (__p, first, second); |
| |
| dottedNamePart = qualifiedNamePart; |
| |
| name = Pattern dottedName : isDottedName() |
| JBurg.Reduction reducer.dottedName (__p, first, second); |
| |
| name = Pattern dottedName : isPackageName() |
| JBurg.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); |
| |
| // 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); |
| |
| // This reduction handles the bar.T part of foo.bar.T |
| dottedNamePart = Pattern fullName : 0 |
| JBurg.Reduction reducer.reduce_by_concatenation (__p, first, second); |
| |
| name = Pattern superAccess : 0 |
| JBurg.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. |
| // Note: this reduction gets an error-trapping cost if |
| // the parameter type is not constant; this forces |
| // expression-oriented reductions to try and reduce |
| // the type parameter as an expression. |
| type_name = Pattern parameterizedName : parameterTypeIsConstant() |
| JBurg.Reduction reducer.reduce_parameterizedTypeName (__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); |
| |
| // The 'new' expression takes a pseduo-type name: |
| // when it can be resolved, the semantic analysis |
| // code can check the constructor. When it can't |
| // be resolved, it's a generalized expression. |
| 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); |
| |
| // The parameter of a parameterized type expression may be an expression |
| // or a type name; if it resolves to a type, it's a type name. |
| type_param_expression = name: isKnownType() |
| JBurg.Reduction reducer.reduce_typeNameParameterAsType(__p, name); |
| |
| // any 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 = name: 2000 |
| JBurg.Reduction reducer.transform_name_to_expression(__p, name); |
| |
| type_name = Pattern voidExpr : 0 |
| JBurg.Reduction reducer.reduce_voidExpr_to_type_name(__p); |
| |
| name = Pattern attributeName : 0 |
| JBurg.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); |
| |
| // 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); |
| |
| // A namespace-qualified name reference whose name |
| // is a runtime expression, e.g., ns1::[foo]. |
| // The parser doesn't know the difference between |
| // 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); |
| |
| runtime_name_expression = Pattern namespaceRTQName : 2000 |
| JBurg.Reduction reducer.reduce_namespaceRTQName (__p, qualifier, qualfied_name); |
| |
| expression = Pattern embedExpression : 2 |
| JBurg.Reduction reducer.reduce_embed(__p); |
| |
| /* |
| * E4X expressions (except literals) |
| */ |
| |
| expression = Pattern e4xFilter : 3 |
| JBurg.Reduction reducer.reduce_e4xFilter (__p, stem, filter); |
| |
| runtime_name_expression = Pattern namespaceRTQNameL : 2000 |
| JBurg.Reduction reducer.reduce_namespaceRTQNameL (__p, qualifier, expr); |
| |
| expression = runtime_name_expression : 1 |
| JBurg.Reduction reducer.transform_runtime_name_expression(__p, runtime_name_expression); |
| |
| expression = Pattern runtimeNameExpression: 1 |
| JBurg.Reduction reducer.reduce_runtimeNameExpression(__p, expr); |
| |
| name = Pattern namespaceAsName: 1 |
| JBurg.Reduction reducer.reduce_namespaceAsName_to_name(__p); |
| |
| expression = Pattern namespaceAsName: 1 |
| JBurg.Reduction reducer.reduce_namespaceAsName_to_expression(__p); |
| |
| void_expression = Pattern assignToRuntimeNameExpr: 1 |
| JBurg.Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, DISCARD_VALUE); |
| |
| expression = Pattern assignToRuntimeNameExpr: 1 |
| JBurg.Reduction reducer.reduce_assignToRuntimeNameExpr(__p, lval, r, NEED_VALUE); |
| |
| expression = Pattern descendantsExpression : 1 |
| JBurg.Reduction reducer.reduce_memberAccessExpr(__p, stem, descendants, OP_getdescendants); |
| |
| /* |
| * Literals. |
| */ |
| e4x_literal = Pattern XMLLiteral : 0 |
| JBurg.Reduction reducer.getStringLiteralContent (__p); |
| |
| string_constant = e4x_literal; |
| |
| expression = Pattern XMLContent: 1 |
| JBurg.Reduction reducer.reduce_XMLContent(__p, exprs); |
| |
| expression = Pattern XMLList: 2 |
| JBurg.Reduction reducer.reduce_XMLList(__p, exprs); |
| |
| expression = Pattern XMLListConst: 1 |
| JBurg.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); |
| |
| integer_constant = Pattern numericLiteral: isIntLiteral() |
| JBurg.Reduction reducer.getIntegerContent(__p); |
| |
| expression = integer_constant : 1 |
| JBurg.Reduction reducer.transform_integer_constant(__p, integer_constant); |
| |
| uint_constant = Pattern numericLiteral: isIntLiteral() |
| JBurg.Reduction reducer.getUintContent(__p); |
| |
| expression = uint_constant : 1 |
| JBurg.Reduction reducer.transform_uint_constant(__p, uint_constant); |
| |
| expression = boolean_constant : 1 |
| JBurg.Reduction reducer.transform_boolean_constant(__p, boolean_constant); |
| |
| |
| /** |
| * Constant values |
| */ |
| // 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); |
| |
| // 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. |
| |
| integer_constant = LiteralIntegerZeroID(void) : 1 |
| JBurg.Reduction reducer.getIntegerZeroContent(__p); |
| |
| uint_constant = LiteralIntegerZeroID(void) : 1 |
| JBurg.Reduction reducer.getIntegerZeroContentAsLong(__p); |
| |
| float_constant = Pattern numericLiteral : isFloatLiteral() |
| JBurg.Reduction reducer.getFloatContent(__p); |
| |
| constant_value = Pattern nullLiteral : 0 |
| JBurg.Reduction reducer.reduce_nullLiteral_to_constant_value (__p); |
| |
| constant_value = Pattern void0Literal: 0 |
| JBurg.Reduction reducer.reduce_void0Literal_to_constant_value(__p); |
| |
| constant_value = Pattern voidConstant: 0 |
| JBurg.Reduction reducer.reduce_voidOperator_to_constant_value(__p, value); |
| |
| boolean_constant = Pattern booleanLiteral: 0 |
| JBurg.Reduction reducer.reduce_booleanLiteral(__p); |
| |
| string_constant = Pattern stringLiteral : 0 |
| JBurg.Reduction reducer.getStringLiteralContent (__p); |
| |
| numeric_constant = integer_constant; |
| numeric_constant = uint_constant; |
| numeric_constant = double_constant; |
| numeric_constant = float_constant; |
| |
| |
| constant_value = string_constant : 1 |
| JBurg.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 = numeric_constant : 1 |
| JBurg.Reduction reducer.transform_numeric_constant_to_constant(__p, numeric_constant); |
| |
| required_constant_value = constant_value; |
| |
| double_constant = Pattern numericLiteral : isDoubleLiteral() |
| JBurg.Reduction reducer.getDoubleContent(__p); |
| |
| // Fallback code-gen choice if conversion to |
| // 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); |
| |
| expression = double_constant : 5 |
| JBurg.Reduction reducer.transform_double_constant(__p, double_constant); |
| |
| expression = numeric_constant : 5 |
| JBurg.Reduction reducer.transform_numeric_constant(__p, numeric_constant); |
| |
| expression = float_constant : 5 |
| JBurg.Reduction reducer.transform_float_constant(__p, float_constant); |
| |
| expression = constant_value : 0 |
| JBurg.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 objectLiteral : 3 |
| JBurg.Reduction reducer.reduce_objectLiteral (__p, elements); |
| |
| object_literal_element = Pattern objectLiteralElement : 0 |
| JBurg.Reduction reducer.reduce_objectLiteralElement (__p, id, value); |
| |
| non_resolving_identifier = Pattern nonResolvingIdentifier : 0 |
| JBurg.Reduction reducer.getIdentifierContent(__p); |
| |
| expression = non_resolving_identifier : 1 |
| JBurg.Reduction reducer.transform_non_resolving_identifier(__p, non_resolving_identifier); |
| |
| object_literal = Pattern regexLiteral: 5 |
| JBurg.Reduction reducer.reduce_regexLiteral(__p); |
| |
| object_literal = Pattern void0Literal: 1 |
| JBurg.Reduction reducer.reduce_void0Literal_to_object_literal(__p); |
| |
| object_literal = Pattern void0Operator: 1 |
| JBurg.Reduction reducer.reduce_void0Operator(__p); |
| |
| expression = Pattern voidOperator : 1 |
| JBurg.Reduction reducer.reduce_voidOperator_to_expression (__p, expr); |
| |
| boolean_literal = boolean_constant: 1 |
| JBurg.Reduction reducer.transform_boolean_constant(__p, boolean_constant); |
| |
| array_literal = Pattern arrayLiteral : 1 |
| JBurg.Reduction reducer.reduce_arrayLiteral (__p, elements); |
| |
| vector_literal = Pattern vectorLiteral: 1 |
| JBurg.Reduction reducer.reduce_vectorLiteral(__p, type_param, elements); |
| |
| decl_name = Pattern simpleName : 0 |
| JBurg.Reduction reducer.reduce_declName(__p); |
| |
