public object VisitInvocationExpression(InvocationExpression ie, object data) { B.Expression e = ConvertExpression(ie.TargetObject); if (e == null) { return(null); } if (settings.IsVisualBasic && ie.TargetObject is IdentifierExpression && currentStatement != null) { VariableResolver resolver = new VariableResolver(nameComparer); TypeReference typeRef = resolver.FindType((ie.TargetObject as IdentifierExpression).Identifier, currentStatement); if (typeRef != null && typeRef.IsArrayType) { // Visual Basic: indexer expression B.SlicingExpression s = new B.SlicingExpression(GetLexicalInfo(ie)); s.Target = e; foreach (Expression expr in ie.Arguments) { s.Indices.Add(new B.Slice(ConvertExpression(expr))); } return(s); } } B.MethodInvocationExpression r = new B.MethodInvocationExpression(GetLexicalInfo(ie), e); foreach (Expression expr in ie.Arguments) { e = ConvertExpression(expr); if (e != null) { r.Arguments.Add(e); } } return(r); }
override public object Clone() { SlicingExpression clone = (SlicingExpression)FormatterServices.GetUninitializedObject(typeof(SlicingExpression)); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._expressionType = _expressionType; if (null != _target) { clone._target = _target.Clone() as Expression; clone._target.InitializeParent(clone); } if (null != _indices) { clone._indices = _indices.Clone() as SliceCollection; clone._indices.InitializeParent(clone); } return(clone); }
override public object Clone() { SlicingExpression clone = new SlicingExpression(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._expressionType = _expressionType; if (null != _target) { clone._target = _target.Clone() as Expression; clone._target.InitializeParent(clone); } if (null != _indices) { clone._indices = _indices.Clone() as SliceCollection; clone._indices.InitializeParent(clone); } return(clone); }
public object VisitIndexerExpression(IndexerExpression indexerExpression, object data) { B.SlicingExpression s = new B.SlicingExpression(GetLexicalInfo(indexerExpression)); s.Target = ConvertExpression(indexerExpression.TargetObject); foreach (Expression expr in indexerExpression.Indexes) { s.Indices.Add(new B.Slice(ConvertExpression(expr))); } return(s); }
public override void OnSlicingExpression(SlicingExpression node) { base.OnSlicingExpression(node); var arrayType = GetExpressionType(node.Target) as IArrayType; if (arrayType == null) return; if (arrayType.Rank != node.Indices.Count) Error(CompilerErrorFactory.InvalidArrayRank(node, node.Target.ToCodeString(), arrayType.Rank, node.Indices.Count)); }
public static bool IsComplexSlicing(SlicingExpression node) { foreach (Slice slice in node.Indices) { if (IsComplexSlice(slice)) { return(true); } } return(false); }
public override void LeaveSlicingExpression(SlicingExpression node) { if (IsDuckTyped(node.Target) && !HasDefaultMember(node.Target)) { BindDuck(node); } else { base.LeaveSlicingExpression(node); } }
private void ExpandComplexSlicing(SlicingExpression node) { var targetType = GetExpressionType(node.Target); if (IsString(targetType)) ExpandComplexStringSlicing(node); else if (IsList(targetType)) ExpandComplexListSlicing(node); else if (targetType.IsArray) ExpandComplexArraySlicing(node); else NotImplemented(node, "complex slicing for anything but lists, arrays and strings"); }
void ExpandComplexArraySlicing(SlicingExpression node) { if (node.Indices.Count > 1) { MethodInvocationExpression mie = null; var computeEnd = new ArrayLiteralExpression(); var collapse = new ArrayLiteralExpression(); var ranges = new ArrayLiteralExpression(); for (int i = 0; i < node.Indices.Count; i++) { ranges.Items.Add(node.Indices[i].Begin); if (node.Indices[i].End == null ) { var end = new BinaryExpression(BinaryOperatorType.Addition, node.Indices[i].Begin, new IntegerLiteralExpression(1)); ranges.Items.Add(end); BindExpressionType(end, GetExpressionType(node.Indices[i].Begin)); computeEnd.Items.Add(new BoolLiteralExpression(false)); collapse.Items.Add(new BoolLiteralExpression(true)); } else if (node.Indices[i].End == OmittedExpression.Default) { var end = new IntegerLiteralExpression(0); ranges.Items.Add(end); BindExpressionType(end, GetExpressionType(node.Indices[i].Begin)); computeEnd.Items.Add(new BoolLiteralExpression(true)); collapse.Items.Add(new BoolLiteralExpression(false)); } else { ranges.Items.Add(node.Indices[i].End); computeEnd.Items.Add(new BoolLiteralExpression(false)); collapse.Items.Add(new BoolLiteralExpression(false)); } } mie = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges); mie.Arguments.Add(computeEnd); mie.Arguments.Add(collapse); BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[]))); BindExpressionType(computeEnd, TypeSystemServices.Map(typeof(bool[]))); BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[]))); node.ParentNode.Replace(node, mie); } else { var slice = node.Indices[0]; var mie = IsNullOrOmitted(slice.End) ? CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange1, node.Target, slice.Begin) : CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End); node.ParentNode.Replace(node, mie); } }
public override void OnSlicingExpression(SlicingExpression node) { base.OnSlicingExpression(node); if (!node.IsComplexSlicing()) return; if (node.IsTargetOfAssignment()) return; CompleteOmittedExpressions(node); ExpandComplexSlicing(node); }
void ExpandComplexListSlicing(SlicingExpression node) { var slice = node.Indices[0]; MethodInvocationExpression mie; if (IsNullOrOmitted(slice.End)) { mie = CodeBuilder.CreateMethodInvocation(node.Target, MethodCache.List_GetRange1); mie.Arguments.Add(slice.Begin); } else { mie = CodeBuilder.CreateMethodInvocation(node.Target, MethodCache.List_GetRange2); mie.Arguments.Add(slice.Begin); mie.Arguments.Add(slice.End); } node.ParentNode.Replace(node, mie); }
public override void Apply(Node targetNode) { var cls = targetNode as ClassDefinition; if(cls==null) { this.Context.Errors.Add(new CompilerError(this.LexicalInfo, "ControllerAttribute is applyable only to classes")); return; } targetNode.GetEnclosingModule().Imports.Add(new Import(this.LexicalInfo,"Comdiv.Controllers")); cls.BaseTypes.Clear(); cls.BaseTypes.Insert(0, new SimpleTypeReference("Comdiv.Controllers.ExtensionBaseController")); if(!cls.Name.EndsWith("Controller")) { cls.Name = cls.Name + "Controller"; } var body = targetNode.GetEnclosingModule()["regmethod"] as Block; var registrycall = new SlicingExpression(new ReferenceExpression("registry"), new StringLiteralExpression(cls.Name.ToLower())); var assign = new ReferenceExpression(cls.Name); var aexpr = new BinaryExpression(BinaryOperatorType.Assign, registrycall, assign); body.Add(aexpr); }
private void tryClass(Node targetNode) { var cls = targetNode as ClassDefinition; if (cls == null) { return; } if (cls.BaseTypes.Count == 0) { cls.BaseTypes.Insert(0, new SimpleTypeReference("Comdiv.Framework.Quick.QuickBase")); } var attr = new Attribute("Comdiv.Framework.Quick.actionAttribute"); attr.Arguments.Add(new StringLiteralExpression(cls.Name.Replace("_", "."))); cls.Attributes.Add(attr); var body = targetNode.GetEnclosingModule()["regmethod"] as Block; var registrycall = new SlicingExpression(new ReferenceExpression("registry"), new StringLiteralExpression(cls.Name.Replace("_", ".") + ".quick")); var assign = new ReferenceExpression(cls.Name); var aexpr = new BinaryExpression(BinaryOperatorType.Assign, registrycall, assign); body.Add(aexpr); }
override public void OnSlicingExpression(SlicingExpression node) { var tern = ProcessTargets(node); if (tern != null) { Visit(node.Indices); ReplaceCurrentNode(tern); } base.OnSlicingExpression(node); }
private ArrayLiteralExpression GetArrayForIndices(SlicingExpression node) { ArrayLiteralExpression args = new ArrayLiteralExpression(); foreach (Slice index in node.Indices) { if (AstUtil.IsComplexSlice(index)) { throw CompilerErrorFactory.NotImplemented(index, "complex slice for duck"); } args.Items.Add(index.Begin); } BindExpressionType(args, TypeSystemServices.ObjectArrayType); return args; }
private static Expression GetSlicingTarget(SlicingExpression node) { Expression target = node.Target; if (NodeType.MemberReferenceExpression == target.NodeType) { MemberReferenceExpression mre = ((MemberReferenceExpression)target); return mre.Target; } return target; }
private IType ResultingTypeForComplexSlicing(SlicingExpression node) { var targetType = GetExpressionType(node.Target); return targetType.IsArray ? ResultingTypeForArraySlicing(node) : targetType; }
public override void OnSlicingExpression(SlicingExpression node) { if (AstUtil.IsLhsOfAssignment(node)) return; Visit(node.Target); IArrayType type = (IArrayType)PopType(); EmitNormalizedArrayIndex(node, node.Indices[0].Begin); IType elementType = type.ElementType; OpCode opcode = GetLoadEntityOpCode(elementType); if (OpCodes.Ldelema.Value == opcode.Value) { Type systemType = GetSystemType(elementType); _il.Emit(opcode, systemType); if (!IsByAddress(elementType)) _il.Emit(OpCodes.Ldobj, systemType); } else if (OpCodes.Ldelem.Value == opcode.Value) { _il.Emit(opcode, GetSystemType(elementType)); } else { _il.Emit(opcode); } PushType(elementType); }
void AssertIsNotComplexSlicing(SlicingExpression node) { if (node.IsComplexSlicing()) NotImplemented(node, "complex slicing"); }
protected void slice( SlicingExpression se ) //throws RecognitionException, TokenStreamException { Expression begin = null; Expression end = null; Expression step = null; try { // for error handling { switch ( LA(1) ) { case COLON: { { match(COLON); if (0==inputState.guessing) { begin = OmittedExpression.Default; } { switch ( LA(1) ) { case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case THEN: case TRUE: case TYPEOF: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { end=expression(); break; } case COLON: { { match(COLON); if (0==inputState.guessing) { end = OmittedExpression.Default; } step=expression(); } break; } case RBRACK: case COMMA: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } break; } case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case THEN: case TRUE: case TYPEOF: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { begin=expression(); { switch ( LA(1) ) { case COLON: { match(COLON); { switch ( LA(1) ) { case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case THEN: case TRUE: case TYPEOF: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { end=expression(); break; } case RBRACK: case COMMA: case COLON: { if (0==inputState.guessing) { end = OmittedExpression.Default; } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1) ) { case COLON: { match(COLON); step=expression(); break; } case RBRACK: case COMMA: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } break; } case RBRACK: case COMMA: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } if (0==inputState.guessing) { se.Indices.Add(new Slice(begin, end, step)); } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "slice"); recover(ex,tokenSet_52_); } else { throw ex; } } }
//throws RecognitionException, TokenStreamException protected Expression slicing_expression() { Expression e; IToken lbrack = null; IToken oft = null; IToken lparen = null; e = null; SlicingExpression se = null; MethodInvocationExpression mce = null; TypeReference genericArgument = null; TypeReferenceCollection genericArguments = null; Expression initializer = null; try { // for error handling e=atom(); { // ( ... )* for (;;) { switch ( LA(1) ) { case LBRACK: { { lbrack = LT(1); match(LBRACK); { switch ( LA(1) ) { case OF: { { match(OF); if (0==inputState.guessing) { GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(lbrack)); gre.Target = e; e = gre; genericArguments = gre.GenericArguments; } type_reference_list(genericArguments); } break; } case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case TRUE: case TYPEOF: case ID: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case LBRACK: case SUBTRACT: case SPLICE_BEGIN: case DOT: case COLON: case MULTIPLY: case LBRACE: case QQ_BEGIN: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { if (0==inputState.guessing) { se = new SlicingExpression(SourceLocationFactory.ToLexicalInfo(lbrack)); se.Target = e; e = se; } slice(se); { // ( ... )* for (;;) { if ((LA(1)==COMMA)) { match(COMMA); slice(se); } else { goto _loop525_breakloop; } } _loop525_breakloop: ; } // ( ... )* break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } match(RBRACK); } break; } case OF: { { oft = LT(1); match(OF); genericArgument=type_reference(); if (0==inputState.guessing) { GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(oft)); gre.Target = e; e = gre; gre.GenericArguments.Add(genericArgument); } } break; } case DOT: { { match(DOT); { // ( ... )* for (;;) { if ((LA(1)==NEWLINE)) { match(NEWLINE); } else { goto _loop529_breakloop; } } _loop529_breakloop: ; } // ( ... )* e=member_reference_expression(e); } break; } case LPAREN: { { lparen = LT(1); match(LPAREN); if (0==inputState.guessing) { mce = new MethodInvocationExpression(SourceLocationFactory.ToLexicalInfo(lparen)); mce.Target = e; e = mce; } { switch ( LA(1) ) { case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case TRUE: case TYPEOF: case ID: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case LBRACK: case SUBTRACT: case SPLICE_BEGIN: case DOT: case MULTIPLY: case LBRACE: case QQ_BEGIN: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { argument(mce); { // ( ... )* for (;;) { if ((LA(1)==COMMA)) { match(COMMA); argument(mce); } else { goto _loop533_breakloop; } } _loop533_breakloop: ; } // ( ... )* break; } case RPAREN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } match(RPAREN); { switch ( LA(1) ) { case LBRACE: { { bool synPredMatched537 = false; if (((LA(1)==LBRACE) && (tokenSet_71_.member(LA(2))))) { int _m537 = mark(); synPredMatched537 = true; inputState.guessing++; try { { hash_literal_test(); } } catch (RecognitionException) { synPredMatched537 = false; } rewind(_m537); inputState.guessing--; } if ( synPredMatched537 ) { initializer=hash_literal(); } else if ((LA(1)==LBRACE) && (tokenSet_71_.member(LA(2)))) { initializer=list_initializer(); } else { throw new NoViableAltException(LT(1), getFilename()); } } if (0==inputState.guessing) { e = new CollectionInitializationExpression(e, initializer); } break; } case EOF: case ESEPARATOR: case AND: case AS: case CAST: case DEF: case DO: case ELSE: case FOR: case IS: case ISA: case IF: case IN: case NOT: case OF: case OR: case UNLESS: case WHILE: case ID: case EOS: case NEWLINE: case LPAREN: case RPAREN: case LBRACK: case RBRACK: case ASSIGN: case SUBTRACT: case COMMA: case DOT: case COLON: case MULTIPLY: case EXPONENTIATION: case BITWISE_OR: case RBRACE: case QQ_END: case INPLACE_BITWISE_OR: case INPLACE_EXCLUSIVE_OR: case INPLACE_BITWISE_AND: case INPLACE_SHIFT_LEFT: case INPLACE_SHIFT_RIGHT: case CMP_OPERATOR: case GREATER_THAN: case LESS_THAN: case ADD: case EXCLUSIVE_OR: case DIVISION: case MODULUS: case BITWISE_AND: case SHIFT_LEFT: case SHIFT_RIGHT: case INCREMENT: case DECREMENT: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } break; } default: { goto _loop538_breakloop; } } } _loop538_breakloop: ; } // ( ... )* } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_72_); } else { throw ex; } } return e; }
private Expression CreateSideEffectAwareSlicingOperation(LexicalInfo lexicalInfo, BinaryOperatorType binaryOperator, SlicingExpression lvalue, Expression rvalue, InternalLocal returnValue) { MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(lexicalInfo); if (HasSideEffect(lvalue.Target)) { InternalLocal temp = AddInitializedTempLocal(eval, lvalue.Target); lvalue.Target = CodeBuilder.CreateReference(temp); } foreach (Slice slice in lvalue.Indices) { Expression index = slice.Begin; if (HasSideEffect(index)) { InternalLocal temp = AddInitializedTempLocal(eval, index); slice.Begin = CodeBuilder.CreateReference(temp); } } BinaryExpression addition = CodeBuilder.CreateBoundBinaryExpression( GetExpressionType(lvalue), binaryOperator, CloneOrAssignToTemp(returnValue, lvalue), rvalue); Expression expansion = CodeBuilder.CreateAssignment( lvalue.CloneNode(), addition); // Resolve operator overloads if any BindArithmeticOperator(addition); if (eval.Arguments.Count > 0 || null != returnValue) { eval.Arguments.Add(expansion); if (null != returnValue) { eval.Arguments.Add(CodeBuilder.CreateReference(returnValue)); } BindExpressionType(eval, GetExpressionType(lvalue)); expansion = eval; } return expansion; }
void EmitNormalizedArrayIndex(SlicingExpression sourceNode, Expression index) { bool isNegative = false; if (CanBeNegative(index, ref isNegative) && !_rawArrayIndexing && !AstAnnotations.IsRawIndexing(sourceNode)) { if (isNegative) { _il.Emit(OpCodes.Dup); _il.Emit(OpCodes.Ldlen); EmitLoadInt(index); _il.Emit(OpCodes.Add); } else { _il.Emit(OpCodes.Dup); EmitLoadInt(index); _il.EmitCall(OpCodes.Call, RuntimeServices_NormalizeArrayIndex, null); } } else { EmitLoadInt(index); } }
public override void LeaveSlicingExpression(SlicingExpression node) { if (node.Target.Entity.IsAmbiguous()) { BindIndexedPropertySlicing(node); return; } // target[indices] var targetType = GetExpressionType(node.Target); if (IsError(targetType)) { Error(node); return; } if (node.IsComplexSlicing()) { BindExpressionType(node, ResultingTypeForComplexSlicing(node)); return; } if (IsIndexedProperty(node.Target)) { BindIndexedPropertySlicing(node); return; } if (targetType.IsArray) { BindExpressionType(node, targetType.ElementType); return; } var member = TypeSystemServices.GetDefaultMember(targetType); if (member == null) { Error(node, CompilerErrorFactory.TypeDoesNotSupportSlicing(node.Target, targetType)); return; } node.Target = new MemberReferenceExpression(node.LexicalInfo, node.Target, member.Name) { Entity = member, ExpressionType = Null.Default // to be resolved later }; SliceMember(node, member); }
void BindMultiDimensionalArraySlicing(SlicingExpression node) { if (AstUtil.IsLhsOfAssignment(node)) { // leave it to LeaveBinaryExpression to resolve return; } MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation( node.Target, CachedMethod("Array_GetValue", () => Methods.InstanceFunctionOf<Array, int[], object>(a => a.GetValue))); for (int i = 0; i < node.Indices.Count; i++) { mie.Arguments.Add(node.Indices[i].Begin); } IType elementType = node.Target.ExpressionType.ElementType; node.ParentNode.Replace(node, CodeBuilder.CreateCast(elementType, mie)); }
public static bool IsComplexSlicing(this SlicingExpression node) { return(node.Indices.Any(IsComplexSlice)); }
protected Expression slicing_expression() //throws RecognitionException, TokenStreamException { Expression e; IToken lbrack = null; IToken oft = null; IToken begin = null; IToken lparen = null; e = null; SlicingExpression se = null; MethodInvocationExpression mce = null; IToken memberName = null; TypeReference genericArgument = null; TypeReferenceCollection genericArguments = null; Expression nameSplice = null; Expression initializer = null; UnaryExpression ue = null; try { // for error handling e=safe_atom(); { // ( ... )* for (;;) { if ((LA(1)==LBRACK) && (tokenSet_72_.member(LA(2)))) { { lbrack = LT(1); match(LBRACK); { switch ( LA(1) ) { case OF: { { match(OF); if (0==inputState.guessing) { GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(lbrack)); gre.Target = e; e = gre; genericArguments = gre.GenericArguments; } type_reference_list(genericArguments); } break; } case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case THEN: case TRUE: case TYPEOF: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case COLON: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { if (0==inputState.guessing) { se = new SlicingExpression(ToLexicalInfo(lbrack)); se.Target = e; e = se; } slice(se); { // ( ... )* for (;;) { if ((LA(1)==COMMA)) { match(COMMA); slice(se); } else { goto _loop591_breakloop; } } _loop591_breakloop: ; } // ( ... )* break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } match(RBRACK); { switch ( LA(1) ) { case NULLABLE_SUFFIX: { match(NULLABLE_SUFFIX); if (0==inputState.guessing) { ue = new UnaryExpression(e.LexicalInfo); ue.Operator = UnaryOperatorType.SafeAccess; ue.Operand = e; e = ue; } break; } case EOF: case DEDENT: case ESEPARATOR: case EOL: case ASSEMBLY_ATTRIBUTE_BEGIN: case MODULE_ATTRIBUTE_BEGIN: case ABSTRACT: case AND: case AS: case BREAK: case CONTINUE: case CALLABLE: case CAST: case CHAR: case CLASS: case CONSTRUCTOR: case DEF: case DESTRUCTOR: case DO: case ELSE: case ENUM: case EVENT: case FINAL: case FOR: case FALSE: case GOTO: case INTERFACE: case INTERNAL: case IS: case ISA: case IF: case IN: case NEW: case NOT: case NULL: case OF: case OR: case OVERRIDE: case PARTIAL: case PUBLIC: case PROTECTED: case PRIVATE: case RAISE: case RETURN: case SELF: case SUPER: case STATIC: case STRUCT: case THEN: case TRY: case TRANSIENT: case TRUE: case TYPEOF: case UNLESS: case VIRTUAL: case WHILE: case YIELD: case TRIPLE_QUOTED_STRING: case EOS: case LPAREN: case RPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case RBRACK: case ASSIGN: case COMMA: case SPLICE_BEGIN: case DOT: case COLON: case EXPONENTIATION: case BITWISE_OR: case LBRACE: case RBRACE: case QQ_BEGIN: case QQ_END: case INPLACE_BITWISE_OR: case INPLACE_EXCLUSIVE_OR: case INPLACE_BITWISE_AND: case INPLACE_SHIFT_LEFT: case INPLACE_SHIFT_RIGHT: case CMP_OPERATOR: case GREATER_THAN: case LESS_THAN: case ADD: case SUBTRACT: case EXCLUSIVE_OR: case DIVISION: case MODULUS: case BITWISE_AND: case SHIFT_LEFT: case SHIFT_RIGHT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } } else if ((LA(1)==OF)) { { oft = LT(1); match(OF); genericArgument=type_reference(); if (0==inputState.guessing) { GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(oft)); gre.Target = e; e = gre; gre.GenericArguments.Add(genericArgument); } } } else if ((LA(1)==DOT) && (tokenSet_33_.member(LA(2)))) { { match(DOT); { switch ( LA(1) ) { case EVENT: case GET: case INTERNAL: case PUBLIC: case PROTECTED: case REF: case SET: case YIELD: case ID: { { memberName=member(); if (0==inputState.guessing) { e = MemberReferenceForToken(e, memberName); } } break; } case SPLICE_BEGIN: { { begin = LT(1); match(SPLICE_BEGIN); nameSplice=atom(); if (0==inputState.guessing) { e = new SpliceMemberReferenceExpression( ToLexicalInfo(begin), e, nameSplice); } } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1) ) { case NULLABLE_SUFFIX: { match(NULLABLE_SUFFIX); if (0==inputState.guessing) { ue = new UnaryExpression(e.LexicalInfo); ue.Operator = UnaryOperatorType.SafeAccess; ue.Operand = e; e = ue; } break; } case EOF: case DEDENT: case ESEPARATOR: case EOL: case ASSEMBLY_ATTRIBUTE_BEGIN: case MODULE_ATTRIBUTE_BEGIN: case ABSTRACT: case AND: case AS: case BREAK: case CONTINUE: case CALLABLE: case CAST: case CHAR: case CLASS: case CONSTRUCTOR: case DEF: case DESTRUCTOR: case DO: case ELSE: case ENUM: case EVENT: case FINAL: case FOR: case FALSE: case GOTO: case INTERFACE: case INTERNAL: case IS: case ISA: case IF: case IN: case NEW: case NOT: case NULL: case OF: case OR: case OVERRIDE: case PARTIAL: case PUBLIC: case PROTECTED: case PRIVATE: case RAISE: case RETURN: case SELF: case SUPER: case STATIC: case STRUCT: case THEN: case TRY: case TRANSIENT: case TRUE: case TYPEOF: case UNLESS: case VIRTUAL: case WHILE: case YIELD: case TRIPLE_QUOTED_STRING: case EOS: case LPAREN: case RPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case RBRACK: case ASSIGN: case COMMA: case SPLICE_BEGIN: case DOT: case COLON: case EXPONENTIATION: case BITWISE_OR: case LBRACE: case RBRACE: case QQ_BEGIN: case QQ_END: case INPLACE_BITWISE_OR: case INPLACE_EXCLUSIVE_OR: case INPLACE_BITWISE_AND: case INPLACE_SHIFT_LEFT: case INPLACE_SHIFT_RIGHT: case CMP_OPERATOR: case GREATER_THAN: case LESS_THAN: case ADD: case SUBTRACT: case EXCLUSIVE_OR: case DIVISION: case MODULUS: case BITWISE_AND: case SHIFT_LEFT: case SHIFT_RIGHT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } } else if ((LA(1)==LPAREN) && (tokenSet_73_.member(LA(2)))) { { lparen = LT(1); match(LPAREN); if (0==inputState.guessing) { mce = new MethodInvocationExpression(ToLexicalInfo(lparen)); mce.Target = e; e = mce; } { switch ( LA(1) ) { case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case THEN: case TRUE: case TYPEOF: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { argument(mce); { // ( ... )* for (;;) { if ((LA(1)==COMMA)) { match(COMMA); argument(mce); } else { goto _loop602_breakloop; } } _loop602_breakloop: ; } // ( ... )* break; } case RPAREN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } match(RPAREN); { switch ( LA(1) ) { case NULLABLE_SUFFIX: { match(NULLABLE_SUFFIX); if (0==inputState.guessing) { ue = new UnaryExpression(e.LexicalInfo); ue.Operator = UnaryOperatorType.SafeAccess; ue.Operand = e; e = ue; } break; } case EOF: case DEDENT: case ESEPARATOR: case EOL: case ASSEMBLY_ATTRIBUTE_BEGIN: case MODULE_ATTRIBUTE_BEGIN: case ABSTRACT: case AND: case AS: case BREAK: case CONTINUE: case CALLABLE: case CAST: case CHAR: case CLASS: case CONSTRUCTOR: case DEF: case DESTRUCTOR: case DO: case ELSE: case ENUM: case EVENT: case FINAL: case FOR: case FALSE: case GOTO: case INTERFACE: case INTERNAL: case IS: case ISA: case IF: case IN: case NEW: case NOT: case NULL: case OF: case OR: case OVERRIDE: case PARTIAL: case PUBLIC: case PROTECTED: case PRIVATE: case RAISE: case RETURN: case SELF: case SUPER: case STATIC: case STRUCT: case THEN: case TRY: case TRANSIENT: case TRUE: case TYPEOF: case UNLESS: case VIRTUAL: case WHILE: case YIELD: case TRIPLE_QUOTED_STRING: case EOS: case LPAREN: case RPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case RBRACK: case ASSIGN: case COMMA: case SPLICE_BEGIN: case DOT: case COLON: case EXPONENTIATION: case BITWISE_OR: case LBRACE: case RBRACE: case QQ_BEGIN: case QQ_END: case INPLACE_BITWISE_OR: case INPLACE_EXCLUSIVE_OR: case INPLACE_BITWISE_AND: case INPLACE_SHIFT_LEFT: case INPLACE_SHIFT_RIGHT: case CMP_OPERATOR: case GREATER_THAN: case LESS_THAN: case ADD: case SUBTRACT: case EXCLUSIVE_OR: case DIVISION: case MODULUS: case BITWISE_AND: case SHIFT_LEFT: case SHIFT_RIGHT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { if ((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2)))) { { bool synPredMatched607 = false; if (((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2))))) { int _m607 = mark(); synPredMatched607 = true; inputState.guessing++; try { { hash_literal_test(); } } catch (RecognitionException) { synPredMatched607 = false; } rewind(_m607); inputState.guessing--; } if ( synPredMatched607 ) { initializer=hash_literal(); } else if ((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2)))) { initializer=list_initializer(); } else { throw new NoViableAltException(LT(1), getFilename()); } } if (0==inputState.guessing) { e = new CollectionInitializationExpression(e, initializer); } } else if ((tokenSet_75_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) { } else { throw new NoViableAltException(LT(1), getFilename()); } } } } else { goto _loop608_breakloop; } } _loop608_breakloop: ; } // ( ... )* } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "slicing_expression"); recover(ex,tokenSet_76_); } else { throw ex; } } return e; }
bool CheckComplexSlicingParameters(SlicingExpression node) { foreach (Slice slice in node.Indices) { if (!CheckComplexSlicingParameters(slice)) { return false; } } return true; }
private void BindIndexedPropertySlicing(SlicingExpression node) { AssertIsNotComplexSlicing(node); SliceMember(node, node.Target.Entity); }
void CheckNoComplexSlicing(SlicingExpression node) { if (AstUtil.IsComplexSlicing(node)) { NotImplemented(node, "complex slicing"); } }
private Expression GetIndexedPropertySlicingTarget(SlicingExpression node) { Expression target = node.Target; MemberReferenceExpression mre = target as MemberReferenceExpression; if (null != mre) return mre.Target; return CreateSelfReference(); }
public override void LeaveSlicingExpression(SlicingExpression node) { if (IsAmbiguous(node.Target.Entity)) { BindIndexedPropertySlicing(node); return; } // target[indices] IType targetType = GetExpressionType(node.Target); if (IsError(targetType)) { Error(node); return; } if (IsIndexedProperty(node.Target)) { BindIndexedPropertySlicing(node); } else { if (targetType.IsArray) { IArrayType arrayType = (IArrayType)targetType; if (arrayType.Rank != node.Indices.Count) { Error(node, CompilerErrorFactory.InvalidArrayRank(node, node.Target.ToString(), arrayType.Rank, node.Indices.Count)); } if (AstUtil.IsComplexSlicing(node)) { BindComplexArraySlicing(node); } else { if (arrayType.Rank > 1) { BindMultiDimensionalArraySlicing(node); } else { BindExpressionType(node, arrayType.ElementType); } } } else { if (AstUtil.IsComplexSlicing(node)) { if (TypeSystemServices.StringType == targetType) { BindComplexStringSlicing(node); } else { if (IsAssignableFrom(TypeSystemServices.ListType, targetType)) { BindComplexListSlicing(node); } else { NotImplemented(node, "complex slicing for anything but lists, arrays and strings"); } } } else { IEntity member = TypeSystemServices.GetDefaultMember(targetType); if (null == member) { Error(node, CompilerErrorFactory.TypeDoesNotSupportSlicing(node.Target, targetType.ToString())); } else { node.Target = new MemberReferenceExpression(node.LexicalInfo, node.Target, member.Name); node.Target.Entity = member; // to be resolved later node.Target.ExpressionType = Null.Default; SliceMember(node, member); } } } } }
IType ResultingTypeForArraySlicing(SlicingExpression node) { var arrayType = GetExpressionType(node.Target); if (node.Indices.Count > 1) { var collapseCount = node.Indices.Count(t => t.End == null); return arrayType.ElementType.MakeArrayType(node.Indices.Count - collapseCount); } return arrayType; }
override public void LeaveSlicingExpression(SlicingExpression node) { if (!IsDuckTyped(node.Target)) return; if (AstUtil.IsLhsOfAssignment(node)) return; // todo // a[foo] // RuntimeServices.GetSlice(a, "", (foo,)) MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation( node.LexicalInfo, RuntimeServices_GetSlice, GetSlicingTarget(node), CodeBuilder.CreateStringLiteral(GetSlicingMemberName(node)), GetArrayForIndices(node)); Replace(mie); }
void SliceMember(SlicingExpression node, IEntity member) { EnsureRelatedNodeWasVisited(node, member); if (node.IsTargetOfAssignment()) { // leave it to LeaveBinaryExpression to resolve Bind(node, member); return; } MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo); foreach (Slice index in node.Indices) { mie.Arguments.Add(index.Begin); } IMethod getter = null; if (EntityType.Ambiguous == member.EntityType) { IEntity result = ResolveAmbiguousPropertyReference((ReferenceExpression)node.Target, (Ambiguous)member, mie.Arguments); IProperty found = result as IProperty; if (null != found) { getter = found.GetGetMethod(); } else if (EntityType.Ambiguous == result.EntityType) { Error(node); return; } } else if (EntityType.Property == member.EntityType) { getter = ((IProperty)member).GetGetMethod(); } if (null != getter) { if (AssertParameters(node, getter, mie.Arguments)) { Expression target = GetIndexedPropertySlicingTarget(node); mie.Target = CodeBuilder.CreateMemberReference(target, getter); BindExpressionType(mie, getter.ReturnType); node.ParentNode.Replace(node, mie); } else { Error(node); } } else { NotImplemented(node, "slice for anything but arrays and default properties"); } }
private static string GetSlicingMemberName(SlicingExpression node) { if (NodeType.MemberReferenceExpression == node.Target.NodeType) { MemberReferenceExpression mre = ((MemberReferenceExpression)node.Target); return mre.Name; } return ""; }