public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { Visit(node.Target); WriteToken("["); Visit(node.Indices); WriteToken("]"); }
public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { Visit(node.Target); expressions.Push(ExpressionKind.None); Visit(node.Indices); expressions.Pop(); }
private TypeReference GetUseInArrayIndexer(ArrayIndexerExpression arrayIndexerExpression, VariableReference variable) { V_0 = arrayIndexerExpression.get_Indices().GetEnumerator(); try { while (V_0.MoveNext()) { V_1 = V_0.get_Current(); if (V_1 as VariableReferenceExpression == null || (object)(V_1 as VariableReferenceExpression).get_Variable() != (object)variable) { continue; } V_2 = this.typeSystem.get_Int32(); goto Label1; } goto Label0; } finally { if (V_0 != null) { V_0.Dispose(); } } Label1: return(V_2); Label0: return(new TypeReference("System", "Array", this.typeSystem.get_Object().get_Module(), this.typeSystem.get_Object().get_Scope())); }
public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { this.states.Push(0); this.VisitArrayIndexerExpression(node); dummyVar0 = this.states.Pop(); return; }
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node) { MethodReferenceExpression methodReference = node.MethodExpression; if ((methodReference == null) || (methodReference.Method.CallingConvention == MethodCallingConvention.StdCall)) { return(null); } MethodReference method = methodReference.Method; BinaryOperator binaryOperator; if (binaryOperators.TryGetValue(method.Name, out binaryOperator)) { return(BuildBinaryExpression(binaryOperator, node.Arguments[0], node.Arguments[1], method.FixedReturnType, node.InvocationInstructions)); } UnaryOperator unaryOperator; if (unaryOperators.TryGetValue(method.Name, out unaryOperator)) { return(BuildUnaryExpression(unaryOperator, node.Arguments[0], node.InvocationInstructions)); } if (method.Name == "op_True") { return((Expression)codeTransformer.Visit(node.Arguments[0])); } else if (method.Name == "op_False") { //TODO: Must consider better representation return(new ConditionExpression((Expression)codeTransformer.Visit(node.Arguments[0]), new LiteralExpression(false, typeSystem, null), new LiteralExpression(true, typeSystem, null), node.InvocationInstructions)); } if (method.Name == "op_Explicit") { return(new ExplicitCastExpression((Expression)codeTransformer.Visit(node.Arguments[0]), node.ExpressionType, node.InvocationInstructions)); } if (method.Name == "op_Implicit") { return(new ImplicitCastExpression((Expression)codeTransformer.Visit(node.Arguments[0]), node.ExpressionType, node.InvocationInstructions)); } if (method.Name == "get_Chars" && node.MethodExpression.Target.ExpressionType.FullName == "System.String") { ArrayIndexerExpression stringIndexing = new ArrayIndexerExpression(node.MethodExpression.Target, node.InvocationInstructions); foreach (Expression arg in node.Arguments) { stringIndexing.Indices.Add(arg); } return(stringIndexing); } return(null); }
private void Assign(ArrayIndexerExpression expression, IScriptObject value) { if (expression.Target is SuperReferenceExpression) { var t = This as ISuperIndexableObject; if (t != null) { var args = new List <IScriptObject>(); foreach (var idx in expression.Indices) { args.Add(EvaluateExpression(idx)); } try { t.SetSuperItem(this, args, value); return; } catch (RuntimeException) { throw; } catch (Exception ex) { throw new RuntimeException(expression.LinePragma, ex.Message, ex); } } } { var target = EvaluateExpression(expression.Target); if (target is ScriptNull) { throw new RuntimeException(expression.Target.LinePragma, ExceptionResource.NullReference); } var ind = target as IIndexableObject; if (ind == null) { throw new RuntimeException(expression.LinePragma, ExceptionResource.IndexerNotSupported); } var args = new List <IScriptObject>(); foreach (var idx in expression.Indices) { args.Add(EvaluateExpression(idx)); } try { ind.SetItem(this, args, value); } catch (RuntimeException) { throw; } catch (Exception ex) { throw new RuntimeException(expression.LinePragma, ex.Message, ex); } } }
private bool CheckArrayIndexerExpression(ArrayIndexerExpression expression, VariableReference arrayVariable, int index) { return(expression.Target.CodeNodeType == CodeNodeType.VariableReferenceExpression && (expression.Target as VariableReferenceExpression).Variable == arrayVariable && expression.Indices.Count == 1 && expression.Indices[0].CodeNodeType == CodeNodeType.LiteralExpression && Convert.ToInt32((expression.Indices[0] as LiteralExpression).Value) == index); }
public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { this.Visit(node.get_Target()); this.expressions.Push(0); this.Visit(node.get_Indices()); dummyVar0 = this.expressions.Pop(); return; }
private bool CheckArrayIndexerExpression(ArrayIndexerExpression expression, VariableReference arrayVariable, int index) { if (expression.get_Target().get_CodeNodeType() != 26 || (object)(expression.get_Target() as VariableReferenceExpression).get_Variable() != (object)arrayVariable || expression.get_Indices().get_Count() != 1 || expression.get_Indices().get_Item(0).get_CodeNodeType() != 22) { return(false); } return(Convert.ToInt32((expression.get_Indices().get_Item(0) as LiteralExpression).get_Value()) == index); }
void PushArrayIndexer() { var indexer = new ArrayIndexerExpression(); indexer.Indices.Add(Pop()); indexer.Target = Pop(); Push(indexer); }
public void ArrayIndexerExpressions() { var indexer = new ArrayIndexerExpression(new VariableReferenceExpression("Foo"), new Expression[] { new PrimitiveExpression(1) }); Assert.AreEqual("Foo['1' (type:System.Int32)]", indexer.ToString()); indexer = new ArrayIndexerExpression(new VariableReferenceExpression("Foo"), new Expression[] { new PrimitiveExpression("Key") }); Assert.AreEqual("Foo['Key' (type:System.String)]", indexer.ToString()); }
public void CSharpCodeGenerator_ArrayIndexer_Multiple() { var array = new VariableReference("array"); Expression expression = new ArrayIndexerExpression(array, 10, "test"); var generator = new CSharpCodeGenerator(); var result = generator.Write(expression); Assert.That.StringEquals(@"array[10, ""test""]", result); }
/// <summary> /// Execute an expression /// </summary> /// <param name="expression">The expression to interpret</param> /// <returns>Returns the returned value of the expression</returns> internal object RunExpression(AlgorithmExpression expression) { object result = null; switch (expression.DomType) { case AlgorithmDomType.PrimitiveExpression: result = new PrimitiveValue(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.PropertyReferenceExpression: result = new PropertyReference(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.VariableReferenceExpression: result = new VariableReference(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.ClassReferenceExpression: result = new ClassReference(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.ThisReferenceExpression: result = new ThisReference(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.InstanciateExpression: result = new Instanciate(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.InvokeCoreMethodExpression: result = new InvokeCoreMethod(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.InvokeMethodExpression: result = new InvokeMethod(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.BinaryOperatorExpression: result = new BinaryOperator(DebugMode, this, expression).Execute(); break; case AlgorithmDomType.ArrayIndexerExpression: result = new ArrayIndexerExpression(DebugMode, this, expression).Execute(); break; default: ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new InvalidCastException($"Unable to find an interpreter for this expression : '{expression.GetType().FullName}'"), expression), GetDebugInfo())); break; } return(FailedOrStop ? null : result); }
/// <summary> /// Generates the code for an <see cref="ArrayIndexerExpression"/>. /// </summary> /// <param name="expression">The expression</param> /// <returns>A BaZic code</returns> private string GenerateArrayIndexerExpression(ArrayIndexerExpression expression) { Requires.NotNull(expression.TargetObject, nameof(expression.TargetObject)); Requires.NotNull(expression.Indexes, nameof(expression.Indexes)); var targetObject = GenerateReferenceExpression(expression.TargetObject); var indexes = new List <string>(); foreach (var index in expression.Indexes) { indexes.Add(GenerateExpression(index)); } return($"{targetObject}[{string.Join(", ", indexes)}]"); }
public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { this.VisitArrayIndexerExpression(node); V_0 = 0; while (V_0 < node.get_Indices().get_Count()) { V_1 = node.get_Indices().get_Item(V_0); if (V_1.get_HasType() && this.ShouldAddCast(V_1.get_ExpressionType().Resolve(), this.typeSystem.get_Int32())) { node.get_Indices().set_Item(V_0, new ExplicitCastExpression(V_1, this.typeSystem.get_Int32(), null)); } V_0 = V_0 + 1; } return; }
/// <summary> /// Determines the use type of <paramref name="variable"/> in <paramref name="arrayIndexerExpression"/>. /// </summary> /// <param name="arrayIndexerExpression">The array indexer expression.</param> /// <param name="variable">The variable.</param> /// <returns>Returns the ClassHierarchyNode corresponding to the infered type.</returns> private TypeReference GetUseInArrayIndexer(ArrayIndexerExpression arrayIndexerExpression, VariableReference variable) { foreach (Expression expr in arrayIndexerExpression.Indices) { if (expr is VariableReferenceExpression && (expr as VariableReferenceExpression).Variable == variable) { return(typeSystem.Int32); } } ///If the variable is not indexer, it might be of any array type. ///System.Array is returned, since it's the parent type of every array type. TypeReference result = new TypeReference("System", "Array", typeSystem.Object.Module, typeSystem.Object.Scope); return(result); }
public override void VisitArrayIndexerExpression(ArrayIndexerExpression node) { base.VisitArrayIndexerExpression(node); for (int i = 0; i < node.Indices.Count; i++) { Expression index = node.Indices[i]; if (index.HasType) { TypeDefinition indexType = index.ExpressionType.Resolve(); if (ShouldAddCast(indexType, typeSystem.Int32)) { node.Indices[i] = new CastExpression(index, typeSystem.Int32, null); } } } }
private bool TryUpdateInitializer(ExpressionStatement node) { BinaryExpression assignment = node.Expression as BinaryExpression; ArrayIndexerExpression indexerExpression = assignment.Left as ArrayIndexerExpression; if (indexerExpression.Target == null || indexerExpression.Target.CodeNodeType != CodeNodeType.VariableReferenceExpression) { return(false); } VariableReference variable = (indexerExpression.Target as VariableReferenceExpression).Variable; int lastUninitializedIndex; if (!this.variableToLastUninitializedIndex.TryGetValue(variable, out lastUninitializedIndex)) { return(false); } if (indexerExpression.Indices == null || indexerExpression.Indices.Count != 1) { return(false); } int index = GetIntegerValue(indexerExpression.Indices[0] as LiteralExpression); if (index != lastUninitializedIndex) { this.variableToLastUninitializedIndex.Remove(variable); this.variableToValueMap.Remove(variable); this.variableToAssigingStatementsMap.Remove(variable); if (this.usedVariables.Contains(variable)) { this.failure = true; } return(false); } ArrayCreationExpression arrayCreation = this.variableToValueMap[variable] as ArrayCreationExpression; arrayCreation.Initializer.Expressions.Add((Expression)Visit(assignment.Right.CloneExpressionOnly())); this.variableToAssigingStatementsMap[variable].Add(node); this.variableToLastUninitializedIndex[variable] = index + 1; return(true); }
/// <summary> /// Analyze an array indexer. /// </summary> /// <param name="arrayIndexer">The expression to analyze.</param> private void ValidateArrayIndexerExpression(ArrayIndexerExpression arrayIndexer) { if (arrayIndexer.TargetObject is VariableReferenceExpression variableReference) { ValidateVariableReferenceExpression(variableReference, true); if (arrayIndexer.Indexes.Length != 1) { AddIssue(arrayIndexer, BaZicParserExceptionLevel.Error, L.BaZic.Parser.FormattedOneDimensionVariable(variableReference.Name)); } } else { AnalyzeExpression(arrayIndexer.TargetObject); } foreach (var expression in arrayIndexer.Indexes) { AnalyzeExpression(expression); } }
private uint GetAssignmentIndex(Expression assignee) { if (assignee.CodeNodeType != CodeNodeType.ArrayIndexerExpression) { throw new ArgumentOutOfRangeException("Expected ArrayIndexerExpression."); } ArrayIndexerExpression arrayIndexer = assignee as ArrayIndexerExpression; if (arrayIndexer.Indices.Count != 1) { throw new ArgumentOutOfRangeException("Expected one-dimentional array."); } Expression index = arrayIndexer.Indices[0]; if (index.CodeNodeType != CodeNodeType.LiteralExpression) { throw new IndexOutOfRangeException(); } return(GetIndexFromLiteralExpression(index as LiteralExpression)); }
private bool IsArrayElementAssignment(BinaryExpression assignment, Expression assignee) { if (assignment == null || !assignment.IsAssignmentExpression) { return(false); } if (assignment.Left.CodeNodeType != CodeNodeType.ArrayIndexerExpression) { return(false); } ArrayIndexerExpression arrayIndexer = assignment.Left as ArrayIndexerExpression; if (arrayIndexer.Indices.Count != 1 || arrayIndexer.Indices[0].CodeNodeType != CodeNodeType.LiteralExpression) { return(false); } if (!CompareTargets(assignee, arrayIndexer.Target)) { return(false); } return(true); }
/// <summary> /// Run the interpretation /// </summary> internal override void Execute() { int indexValue = -1; object targetObject = null; object leftValue = null; object rightValue; PropertyInfo propertyInfo; Variable propertyVariable; IList propertyVariableList; var leftExpression = Statement._leftExpression; var rightExpression = Statement._rightExpression; if (DebugMode) { ParentInterpreter.Log(this, $"Assign '{leftExpression}' to '{rightExpression}'"); if (!typeof(IAlgorithmAssignable).IsAssignableFrom(leftExpression.GetType())) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression is not assignable."), Statement), ParentInterpreter.GetDebugInfo())); return; } } switch (leftExpression.DomType) { case AlgorithmDomType.PropertyReferenceExpression: var propertyReferenceInterpreter = new PropertyReference(DebugMode, ParentInterpreter, leftExpression); leftValue = propertyReferenceInterpreter.GetAssignableObject(); targetObject = propertyReferenceInterpreter.TargetObject; break; case AlgorithmDomType.VariableReferenceExpression: leftValue = new VariableReference(DebugMode, ParentInterpreter, leftExpression).GetAssignableObject(); break; case AlgorithmDomType.ArrayIndexerExpression: var arrayIndexerInterpreter = new ArrayIndexerExpression(DebugMode, ParentInterpreter, leftExpression); leftValue = arrayIndexerInterpreter.GetAssignableObject(); indexValue = arrayIndexerInterpreter.IndexValue; break; default: ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new InvalidCastException($"Unable to find an interpreter for this expression : '{leftExpression.GetType().FullName}'"), Statement), ParentInterpreter.GetDebugInfo())); break; } if (ParentInterpreter.FailedOrStop) { return; } rightValue = ParentInterpreter.RunExpression(rightExpression); if (ParentInterpreter.FailedOrStop) { return; } propertyInfo = leftValue as PropertyInfo; if (propertyInfo != null) { if (!propertyInfo.CanWrite) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"This core property is not assignable."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyInfo.SetValue(targetObject, rightValue); } propertyVariable = leftValue as Variable; if (propertyVariable != null) { if (propertyVariable.IsArray && !(typeof(Array).IsAssignableFrom(rightValue.GetType()) || typeof(IList).IsAssignableFrom(rightValue.GetType()))) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression wait for an array, but the right value is not an array."), Statement), ParentInterpreter.GetDebugInfo())); return; } if (!propertyVariable.IsArray && (typeof(Array).IsAssignableFrom(rightValue.GetType()) || typeof(IList).IsAssignableFrom(rightValue.GetType()))) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression does not support array value, but the right value is an array."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyVariable.Value = rightValue; } propertyVariableList = leftValue as IList; if (propertyVariableList != null) { if (indexValue < 0 || indexValue >= propertyVariableList.Count) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new IndexOutOfRangeException($"Unable to get the item number '{indexValue}' because the limit of the array is '{propertyVariableList.Count - 1}'."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyVariableList[indexValue] = rightValue; } if (DebugMode) { ParentInterpreter.Log(this, "'{0}' is now equal to {1}", leftExpression.ToString(), rightValue == null ? "{null}" : $"'{rightValue}' (type:{rightValue.GetType().FullName})"); } }
public override ICodeNode VisitArrayIndexerExpression(ArrayIndexerExpression node) { node.set_Target((Expression)this.VisitTargetExpression(node.get_Target())); node.set_Indices((ExpressionCollection)this.Visit(node.get_Indices())); return(node); }
/// <summary> /// Parse a part of an expression that can be a reference or primary value followed by an accesser like array indexer or method invocation. /// /// Corresponding grammar : /// Primary_Expression_Start Bracket_Expression* ((Member_Access | Method_Invocation) Bracket_Expression* )* /// </summary> /// <param name="isRequired">Defines whether it is required/expected to parse an expression. If true, throw an exception if no expression is parsed.</param> /// <returns>Returns an expression.</returns> private Expression ParsePrimaryExpression(bool isRequired) { Expression[] bracketExpression = null; var expressionLine = CurrentToken.Line; var expressionColumn = CurrentToken.Column; var expressionStartOffset = CurrentToken.StartOffset; var expressionParsedLength = CurrentToken.ParsedLength; // Primary_Expression_Start var expression = ParsePrimaryExpressionStart(isRequired); // Bracket_Expression * do { var bracketToken = CurrentToken; bracketExpression = ParseBracketExpression(); if (bracketExpression != null) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.UnexpectedIndexer)); } if (bracketExpression.Length == 0) { AddIssue(new BaZicParserException(bracketToken.Line, bracketToken.Column, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IndexerExpected)); return(null); } var arrayIndexer = new ArrayIndexerExpression(referenceExpression, bracketExpression) { Line = bracketToken.Line, Column = bracketToken.Column, StartOffset = bracketToken.StartOffset, NodeLength = bracketToken.ParsedLength }; ValidateArrayIndexerExpression(arrayIndexer); expression = arrayIndexer; } } while (bracketExpression != null); // ((Member_Access | Method_Invocation) Bracket_Expression* )* while (CurrentToken.TokenType == TokenType.Dot || CurrentToken.TokenType == TokenType.LeftParenth) { if (CurrentToken.TokenType == TokenType.Dot) { // Member_Access var memberNameToken = CurrentToken; var memberAccess = ParseMemberAccessPart(true); if (!string.IsNullOrEmpty(memberAccess)) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IllegalPropertyAccess)); } expression = new PropertyReferenceExpression(referenceExpression, memberAccess) { Line = memberNameToken.Line, Column = memberNameToken.Column + 1, // +1 because we don't want to show a potential error on the dot. StartOffset = memberNameToken.StartOffset + 1, // +1 because we don't want to show a potential error on the dot. NodeLength = memberNameToken.ParsedLength }; } } else if (CurrentToken.TokenType == TokenType.LeftParenth) { // Method_Invocation var methodInvocationParameters = ParseMethodInvocation(); var propertyReferenceExpression = expression as PropertyReferenceExpression; if (expression is VariableReferenceExpression variableReferenceExpression) { var methodInvoke = new InvokeMethodExpression(variableReferenceExpression.Name.ToString(), false) { Line = variableReferenceExpression.Line, Column = variableReferenceExpression.Column, StartOffset = variableReferenceExpression.StartOffset, NodeLength = variableReferenceExpression.NodeLength } .WithParameters(methodInvocationParameters); AddMethodInvocation(methodInvoke); expression = methodInvoke; } else if (propertyReferenceExpression != null) { var methodInvoke = new InvokeCoreMethodExpression(propertyReferenceExpression.TargetObject, propertyReferenceExpression.PropertyName.ToString(), false) { Line = propertyReferenceExpression.Line, Column = propertyReferenceExpression.Column, StartOffset = propertyReferenceExpression.StartOffset, NodeLength = propertyReferenceExpression.NodeLength }; methodInvoke.WithParameters(methodInvocationParameters); ValidateCoreMethodInvocation(methodInvoke); expression = methodInvoke; } else { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.MethodNameExpected)); } } else { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.MethodNameExpected)); } // Bracket_Expression* do { var bracketToken = CurrentToken; bracketExpression = ParseBracketExpression(); if (bracketExpression != null) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.UnexpectedIndexer)); } if (bracketExpression.Length == 0) { AddIssue(new BaZicParserException(bracketToken.Line, bracketToken.Column, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IndexerExpected)); } var arrayIndexer = new ArrayIndexerExpression(referenceExpression, bracketExpression) { Line = bracketToken.Line, Column = bracketToken.Column, StartOffset = bracketToken.StartOffset, NodeLength = bracketToken.ParsedLength }; ValidateArrayIndexerExpression(arrayIndexer); expression = arrayIndexer; } } while (bracketExpression != null); } return(expression); }
private void InitializeExpressionParsers() { var expRest = lex_op_assign.GetParsingRule() .Concat(p_expression.OrFail(ExceptionResource.ExpressionExpected), (l, r) => Tuple.Create(0, l, r)) | (lex_op_plusAssign.GetParsingRule() | lex_op_minusAssign.GetParsingRule() | lex_op_mutiplyAssign.GetParsingRule() | lex_op_divideAssign.GetParsingRule() | lex_op_modAssign.GetParsingRule() | lex_op_xorAssign.GetParsingRule() | lex_op_andAssign.GetParsingRule() | lex_op_orAssign.GetParsingRule() | lex_op_shiftLeftAssign.GetParsingRule() | lex_op_shiftRightAssign.GetParsingRule()) .Concat(p_expression.OrFail(ExceptionResource.ExpressionExpected), (l, r) => Tuple.Create(1, l, r)); p_expression.Content = p_exp_null .Concat(expRest | ParsingRule <Tuple <int, Token, Expression> > .Empty(Tuple.Create <int, Token, Expression>(-1, null, null)), (l, r) => { if (r.Item1 == -1) { return(l); } else if (r.Item1 == 0) { return((Expression) new AssignExpression(l.LinePragma, l, r.Item3)); } else if (r.Item1 == 1) { return((Expression) new BinaryOperatorExpression(l.LinePragma, l, r.Item2.Text, r.Item3)); } else { throw new Exception(); } }); var nullRest = lex_op_null.GetParsingRule() .Concat(p_exp_null.OrFail(ExceptionResource.ExpressionExpected), (t, e) => e); p_exp_null.Content = p_exp_conditional .Concat(nullRest | PE.Empty(null), (t, e) => { if (e != null) { return((Expression) new BinaryOperatorExpression(t.LinePragma, t, "??", e)); } else { return(t); } }); var conditionalRest = lex_op_question.GetParsingRule() .Concat(p_exp_conditional.OrFail(ExceptionResource.ExpressionExpected), (t, e) => e) .Concat(lex_op_colon.GetParsingRule().OrFailExpected(":"), (t, u) => t) .Concat(p_exp_conditional.OrFail(ExceptionResource.ExpressionExpected), (t, e) => Tuple.Create(t, e)); p_exp_conditional.Content = p_exp_orElse .Concat(conditionalRest | ParsingRule <Tuple <Expression, Expression> > .Empty(null), (t, e) => { if (e != null) { return((Expression) new TernaryOperatorExpression(t.LinePragma, t, "?", e.Item1, ":", e.Item2)); } else { return(t); } }); var orElseRest = lex_op_orElse.GetParsingRule() .Concat(p_exp_andAlso.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_orElse.Content = p_exp_andAlso .Concat( orElseRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var andAlsoRest = lex_op_andAlso.GetParsingRule() .Concat(p_exp_or.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_andAlso.Content = p_exp_or .Concat( andAlsoRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var orRest = lex_op_or.GetParsingRule() .Concat(p_exp_xor.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_or.Content = p_exp_xor .Concat( orRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var xorRest = lex_op_xor.GetParsingRule() .Concat(p_exp_and.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_xor.Content = p_exp_and .Concat( xorRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var andRest = lex_op_and.GetParsingRule() .Concat(p_exp_equality.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_and.Content = p_exp_equality .Concat( andRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var equalityRest = (lex_op_equal.GetParsingRule() | lex_op_notEqual.GetParsingRule()) .Concat(p_exp_compare.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_equality.Content = p_exp_compare .Concat( equalityRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var compareRest = (lex_op_less.GetParsingRule() | lex_op_greater.GetParsingRule() | lex_op_lessEqual.GetParsingRule() | lex_op_greaterEqual.GetParsingRule() | lex_kw_is.GetParsingRule()) .Concat(p_exp_shift.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_compare.Content = p_exp_shift .Concat( compareRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var shiftRest = (lex_op_shiftLeft.GetParsingRule() | lex_op_shiftRight.GetParsingRule()) .Concat(p_exp_add.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_shift.Content = p_exp_add .Concat( shiftRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var addRest = (lex_op_plus.GetParsingRule() | lex_op_minus.GetParsingRule()) .Concat(p_exp_multiply.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_add.Content = p_exp_multiply .Concat( addRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); var multiplyRest = (lex_op_multiply.GetParsingRule() | lex_op_divide.GetParsingRule() | lex_op_mod.GetParsingRule()) .Concat(p_exp_unary.OrFail(ExceptionResource.ExpressionExpected), (o, r) => Tuple.Create(o.Text, r)); p_exp_multiply.Content = p_exp_unary .Concat( multiplyRest.Repeat(), (f, i) => i.Aggregate(f, (a, b) => new BinaryOperatorExpression(a.LinePragma, a, b.Item1, b.Item2))); p_exp_unary.Content = (lex_op_not.GetParsingRule() | lex_op_inverse.GetParsingRule() | lex_op_increment.GetParsingRule() | lex_op_decrement.GetParsingRule() | lex_op_plus.GetParsingRule() | lex_op_minus.GetParsingRule()) .Concat(p_exp_unary.OrFail(ExceptionResource.ExpressionExpected), (o, r) => (Expression) new PrefixOperatorExpression(o.LinePragma, o.Text, r)) | p_exp_primary; var primaryRest = lex_op_dot.GetParsingRule() .Concat(lex_identifer.GetParsingRule().OrFail(ExceptionResource.IdentifierExpected), (dot, member) => Tuple.Create(dot, (object)member)) | lex_op_leftParenthesis.GetParsingRule() .Concat( p_argList | ParsingRule <ExpressionCollection> .Empty(new ExpressionCollection()), (id, args) => Tuple.Create(id, (object)args)) .Concat( lex_op_rightParenthesis.GetParsingRule().OrFailExpected(")"), (e, r) => e) | lex_op_leftBracket.GetParsingRule() .Concat( p_argList | ParsingRule <ExpressionCollection> .Empty(new ExpressionCollection()), (id, args) => Tuple.Create(id, (object)args)) .Concat( lex_op_rightBracket.GetParsingRule().OrFailExpected("]"), (e, r) => e) | (lex_op_increment.GetParsingRule() | lex_op_decrement.GetParsingRule()) .Map(op => Tuple.Create(op, (object)null)); p_exp_primary.Content = p_exp_atom .Concat( primaryRest.Repeat(), (e, i) => { Expression exp = e; foreach (var t in i) { if (t.Item1.Lexeme == lex_op_dot) { exp = new MemberReferenceExpression(exp.LinePragma, exp, ((Token)t.Item2).Text); } else if (t.Item1.Lexeme == lex_op_leftParenthesis) { exp = new FunctionInvokeExpression(exp.LinePragma, exp, (ExpressionCollection)t.Item2); } else if (t.Item1.Lexeme == lex_op_leftBracket) { exp = new ArrayIndexerExpression(exp.LinePragma, exp, (ExpressionCollection)t.Item2); } else if (t.Item1.Lexeme == lex_op_increment || t.Item1.Lexeme == lex_op_decrement) { exp = new PostfixOperatorExpression(exp.LinePragma, exp, t.Item1.Text); } else { throw new Exception(); } } return(exp); }); p_exp_new.Content = lex_kw_new.GetParsingRule() .Concat(p_exp_type.OrFail(ExceptionResource.TypeExpected), (t, e) => Tuple.Create(t, e)) .Concat( lex_op_leftParenthesis.GetParsingRule() .Concat( p_argList | ParsingRule <ExpressionCollection> .Empty(new ExpressionCollection()), (id, args) => args) .Concat( lex_op_rightParenthesis.GetParsingRule().OrFailExpected(")"), (e, r) => e) | ParsingRule <ExpressionCollection> .Empty(new ExpressionCollection()), (t, p) => (Expression) new NewExpression(t.Item1.LinePragma, t.Item2, p)); p_exp_atom.Content = p_exp_array | p_exp_function | p_exp_object | p_exp_new | lex_identifer.GetParsingRule(t => (Expression) new VariableReferenceExpression(t.LinePragma, t.Text)) | lex_kw_false.GetParsingRule(t => (Expression) new PrimitiveExpression(t.LinePragma, bool.Parse(t.Text))) | lex_kw_true.GetParsingRule(t => (Expression) new PrimitiveExpression(t.LinePragma, bool.Parse(t.Text))) | lex_li_string1.GetParsingRule(t => (Expression) new PrimitiveExpression(t.LinePragma, t.Text.Trim('\'').Replace("\\\'", "\'"))) | lex_li_string.GetParsingRule(t => { string str; try { str = t.Text.Trim('\"').ConvertFromEscapeChar(); } catch (ParserException ex) { var lp = new LinePragma(t.LinePragma.Line + ex.LinePragma.Line - 1, t.LinePragma.Span + ex.LinePragma.Span); throw new ParserException(lp, ExceptionResource.UnrecognizedEscapeCharacter); } return((Expression) new PrimitiveExpression(t.LinePragma, str)); }) | lex_li_num.GetParsingRule(t => (Expression) new PrimitiveExpression(t.LinePragma, double.Parse(t.Text))) | lex_kw_null.GetParsingRule(t => (Expression) new PrimitiveExpression(t.LinePragma, null)) | lex_kw_this.GetParsingRule(t => (Expression) new ThisReferenceExpression(t.LinePragma)) | lex_kw_super.GetParsingRule(t => (Expression) new SuperReferenceExpression(t.LinePragma)) | lex_op_leftParenthesis.GetParsingRule() .Concat( p_expression, (l, e) => e) .Concat( lex_op_rightParenthesis.GetParsingRule().OrFailExpected(")"), (e, r) => e); p_argList.Content = p_expression .Concat( lex_op_comma.GetParsingRule().Concat(p_expression.OrFail(ExceptionResource.ExpressionExpected), (comma, e) => e).Repeat(), (e, i) => { var list = i.ToList(); list.Insert(0, e); return(new ExpressionCollection(list)); }); p_exp_array.Content = lex_op_leftBracket.GetParsingRule() .Concat( p_argList | ParsingRule <ExpressionCollection> .Empty(new ExpressionCollection()), (t, eles) => Tuple.Create(t, eles)) .Concat( lex_op_rightBracket.GetParsingRule().OrFailExpected("]"), (eles, t) => (Expression) new ArrayExpression(eles.Item1.LinePragma, eles.Item2)); var para = lex_identifer.GetParsingRule() .Concat( lex_op_assign.GetParsingRule().Concat(p_expression, (t, e) => e) | PE.Empty(null), (t, e) => e == null ? new Parameter(t.LinePragma, t.Text) : new Parameter(t.LinePragma, t.Text, e)); p_paraList.Content = para.Concat( lex_op_comma.GetParsingRule().Concat(para.OrFail(ExceptionResource.IdentifierExpected), (comma, p) => p).Repeat(), (p, i) => { var list = i.ToList(); list.Insert(0, p); return(new ParameterCollection(list)); }) | ParsingRule <ParameterCollection> .Empty(null); p_paras.Content = lex_op_leftParenthesis.GetParsingRule() .Concat(p_paraList, (t, paras) => paras) .Concat(lex_op_rightParenthesis.GetParsingRule(), (paras, t) => paras); var funcExp = lex_kw_function.GetParsingRule() .Concat(p_paras.OrFail(ExceptionResource.ParemetersExpected), (t, paras) => Tuple.Create(t, paras)) .Concat(p_stats.OrFail(ExceptionResource.StatementsExpected), (paras, stats) => (Expression) new FunctionExpression(paras.Item1.LinePragma, paras.Item2, stats)); var lambda_paras = p_paras | para.Map(p => new ParameterCollection(p)); var lambda_stats = p_stats | p_expression.Map(e => new StatementCollection(new ReturnStatement(e.LinePragma, e))); var lambdaExp = lambda_paras .Concat(lex_op_lambda.GetParsingRule(), (paras, t) => Tuple.Create(paras, t)) .Concat(lambda_stats.OrFail(ExceptionResource.StatementsExpected), (paras, stats) => (Expression) new FunctionExpression(paras.Item2.LinePragma, paras.Item1, stats)); p_exp_function.Content = funcExp | lambdaExp; var objectMember = lex_identifer.GetParsingRule() .Concat(lex_op_colon.GetParsingRule(), (t, u) => t) .Concat(p_expression.OrFail(ExceptionResource.ExpressionExpected), (t, e) => Tuple.Create(t, e)); var objectMemberList = objectMember .Concat( lex_op_comma.GetParsingRule() .Concat(objectMember.OrFail(ExceptionResource.IdentifierExpected), (t, m) => m) .Repeat(), (t, i) => { var list = i.ToList(); list.Insert(0, t); return(list); }); p_exp_object.Content = lex_op_leftBrace.GetParsingRule() .Concat(objectMemberList | ParsingRule <List <Tuple <Token, Expression> > > .Empty(new List <Tuple <Token, Expression> >()), (t, m) => Tuple.Create(t, m)) .Concat(lex_op_rightBrace.GetParsingRule().OrFailExpected("}"), (t, u) => { var dict = new List <KeyValuePair <string, Expression> >(); foreach (var m in t.Item2) { dict.Add(new KeyValuePair <string, Expression>(m.Item1.Text, m.Item2)); } return((Expression) new ObjectExpression(t.Item1.LinePragma, dict)); }); var typeRest = lex_op_dot.GetParsingRule() .Concat(lex_identifer.GetParsingRule(), (dot, id) => id); p_exp_type.Content = lex_identifer.GetParsingRule(id => new VariableReferenceExpression(id.LinePragma, id.Text)) .Concat( typeRest.Repeat(), (e, i) => { Expression exp = e; foreach (var t in i) { exp = new MemberReferenceExpression(exp.LinePragma, exp, t.Text); } return(exp); }); }
public virtual void VisitArrayIndexerExpression(ArrayIndexerExpression node) { VisitIIndexerExpression(node); }
public virtual void VisitArrayIndexerExpression(ArrayIndexerExpression node) { this.VisitIIndexerExpression(node); return; }
/// <summary> /// Assigns the specified value to an array. /// </summary> /// <param name="arrayIndexer">The reference to the position in the array to set.</param> /// <param name="value">The value to assign.</param> private void AssignArrayValue(ArrayIndexerExpression arrayIndexer, object value) { var expressionValue = ParentInterpreter.RunExpression(arrayIndexer.TargetObject); if (ParentInterpreter.IsAborted) { return; } if (expressionValue == null) { BaZicInterpreter.ChangeState(this, new NullValueException(L.BaZic.Runtime.Interpreters.Statements.AssignInterpreter.TargetObjectNull), arrayIndexer); return; } var valueInfo = ValueInfo.GetValueInfo(expressionValue); if (!valueInfo.IsArray) { BaZicInterpreter.ChangeState(this, new BadTypeException(L.BaZic.Runtime.Interpreters.Expressions.ArrayIndexerInterpreter.FormattedIndexerForbidden(valueInfo.Type.Name)), arrayIndexer); return; } if (arrayIndexer.Indexes.Length != 1) { BaZicInterpreter.ChangeState(this, new OutOfRangeException(L.BaZic.Runtime.Interpreters.Expressions.ArrayIndexerInterpreter.OneIndexerAllowed), arrayIndexer); return; } var index = ParentInterpreter.RunExpression(arrayIndexer.Indexes[0]); if (ParentInterpreter.IsAborted) { return; } if (index == null) { BaZicInterpreter.ChangeState(this, new OutOfRangeException(L.BaZic.Runtime.Interpreters.Expressions.ArrayIndexerInterpreter.IndexMustNotBeNull), arrayIndexer.Indexes[0]); return; } if (valueInfo.Type == typeof(ObservableDictionary)) { ((ObservableDictionary)expressionValue)[index] = value; return; } else if (typeof(IDictionary).IsAssignableFrom(valueInfo.Type)) { ((IDictionary)expressionValue)[index] = value; return; } else { var indexValue = index as int?; if (indexValue == null) { BaZicInterpreter.ChangeState(this, new BadArgumentException(L.BaZic.Runtime.Interpreters.Expressions.ArrayIndexerInterpreter.CastToNumber), arrayIndexer); return; } if (indexValue < 0 || indexValue >= valueInfo.Length) { BaZicInterpreter.ChangeState(this, new OutOfRangeException(L.BaZic.Runtime.Interpreters.Statements.AssignInterpreter.FormattedOutOfRange(indexValue, valueInfo.Length - 1)), arrayIndexer); return; } if (valueInfo.Type.IsArray || valueInfo.Type == typeof(Array)) { ((Array)expressionValue).SetValue(value, indexValue.Value); return; } else if (typeof(IList).IsAssignableFrom(valueInfo.Type)) { ((IList)expressionValue)[indexValue.Value] = value; return; } } BaZicInterpreter.ChangeState(this, new InternalException(L.BaZic.Runtime.Interpreters.Statements.AssignInterpreter.FormattedUnsupportedArray(valueInfo.Type.FullName)), arrayIndexer); }
public virtual ICodeNode VisitArrayIndexerExpression(ArrayIndexerExpression node) { return(VisitIIndexerExpression(node)); }
public override ICodeNode VisitArrayIndexerExpression(ArrayIndexerExpression node) { node.Target = (Expression)VisitTargetExpression(node.Target); node.Indices = (ExpressionCollection)Visit(node.Indices); return(node); }