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);
}
