private void Emit(ArrayAccessExpression node)
{
Emit(node.ArrayExpression);
AppendUnindented("[");
EmitTuple(node.KeyExpressions.ToArray(), Emit, multiline: false);
AppendUnindented("]");
}
public virtual void Visit(ArrayAccessExpression s)
{
foreach (var index in s._indices)
{
index.Accept(this);
}
}
private AphidObject InterpretArrayAccessExpression(ArrayAccessExpression expression)
{
var val = ValueHelper.Unwrap(InterpretExpression(expression.ArrayExpression));
var index = Convert.ToInt32(ValueHelper.Unwrap(InterpretExpression(expression.KeyExpression)));
var array = val as List <AphidObject>;
string str;
if (array != null)
{
if (index < 0 || index >= array.Count)
{
throw new AphidRuntimeException("Index out of range: {0}.", index);
}
return(array[index]);
}
else if ((str = val as string) != null)
{
return(new AphidObject(str[index].ToString()));
}
else
{
throw new AphidRuntimeException("Array access not supported by {0}.", val);
}
}
public override Object Visit(ArrayAccessExpression node, Object obj)
{
node.FirstOperand.Accept(this, obj);
node.SecondOperand.Accept(this, obj);
return(null);
}
protected virtual void EmitArrayAccessExpression(ArrayAccessExpression expression, bool isStatement = false)
{
Emit(expression.ArrayExpression);
Append("[");
EmitTuple(expression.KeyExpressions);
Append("]");
}
// . .$ :: ::$ call [ ]
private Expression ParseScopeExpression()
{
Expression result = ParseConstructorExpression();
SkipWhitespace();
while (ConsumeIfType(out Token token, TokenType.Period, TokenType.PeriodDollarSign, TokenType.ColonColon, TokenType.ColonColonDollarSign, TokenType.OpenSquareBracket, TokenType.OpenParenthesis))
{
Expression rhs = null;
if (token.Type == TokenType.OpenSquareBracket)
{
Expression index = ParseExpression();
SkipWhitespace();
Token closeSquareBracket = Consume();
// TODO: Assert that that was actually a close square bracket
// once we have a proper panic & sync system
result = new ArrayAccessExpression(result.Span + closeSquareBracket.Span, result, index);
}
else if (token.Type == TokenType.OpenParenthesis)
{
SkipWhitespace();
List <Expression> arguments = new List <Expression>();
bool isFirst = true;
while (Peek().Type != TokenType.CloseParenthesis)
{
SkipWhitespace();
if (!isFirst)
{
ConsumeType(TokenType.Comma, "Expected a comma between call arguments.", "LSS050");
}
Expression argument = ParseExpression();
arguments.Add(argument);
isFirst = false;
SkipWhitespace();
}
Token closeParenthesis = ConsumeType(TokenType.CloseParenthesis, "Expected a close parenthesis after function call.", "LSS051");
result = new CallExpression(result.Span + closeParenthesis.Span, result, arguments);
}
else
{
// . :: .$, ::$
if (token.Type == TokenType.PeriodDollarSign || token.Type == TokenType.ColonColonDollarSign)
{
// Don't allow function calls as part of the lookup expression - this would be ambiguous, consider thing.$foo(bar), is '(bar)' part of the lookup expression, or calling the looked-up function?
rhs = ParseTerminalExpression();
}
else
{
rhs = ParseTerminalExpression();
}
result = new BinaryExpression(result, token, rhs);
}
SkipWhitespace();
}
return(result);
}
public object VisitArrayAccessExpression(ArrayAccessExpression expr, object context)
{
expr.Array.AcceptVisitor(this, context);
StringBuilder.Append("[");
expr.Index.AcceptVisitor(this, context);
StringBuilder.Append("]");
return(null);
}
public override object Visit(ArrayAccessExpression node, object obj)
{
if (node.Location == ((AstNode)obj).Location || found)
{
found = true;
return(this.table);
}
return(base.Visit(node, obj));
}
public void GetSecondElement()
{
Vector vector = new Vector(new object[] { 1, 2, 3 });
IExpression arrexpr = new ConstantExpression(vector);
IExpression indexpr = new ConstantExpression(1);
IExpression expr = new ArrayAccessExpression(arrexpr, new IExpression[] { indexpr });
Assert.AreEqual(2, expr.Evaluate(null));
}
public override object Visit(ArrayAccessExpression node, object obj)
{
if (node.Location > (Location)obj)
{
return(null);
}
arrayStack.Push(node);
return(base.Visit(node, obj));
}
public override Object Visit(ArrayAccessExpression node, Object obj)
{
int indent = Convert.ToInt32(obj);
this.printIndentation(indent);
this.output.WriteLine("ArrayAccessExpression Type: {0} [{1}:{2}]", printType(node.ExpressionType), node.Location.Line, node.Location.Column);
node.FirstOperand.Accept(this, indent + 1);
node.SecondOperand.Accept(this, indent + 1);
return(null);
}
public override Object Visit(ArrayAccessExpression node, Object obj)
{
Expression clonedFirstOperand = (Expression)node.FirstOperand.Accept(this, obj);
Expression clonedSecondOperand = (Expression)node.SecondOperand.Accept(this, obj);
ArrayAccessExpression clonedArrayAccessExpression = new ArrayAccessExpression(clonedFirstOperand, clonedSecondOperand, node.Location);
if (node.ExpressionType != null)
{
clonedArrayAccessExpression.ExpressionType = node.ExpressionType.CloneType(this.typeVariableMappings, this.typeExpresionVariableMapping);
}
return(clonedArrayAccessExpression);
}
/// <summary>
/// Returns expression from parser's <see cref="CQLParser.ComplexFactorContext"/>.
/// Represents complex factors like array access, property lookup or function call.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override IExpression VisitComplexFactor([NotNull] CQLParser.ComplexFactorContext context)
{
var primary = Visit(context.pe);
foreach (var element in context.chain_element())
{
if (element is ArrayAccessContext)
{
var arrayAccess = element as ArrayAccessContext;
var indices = exprListVisitor.Visit(arrayAccess.elems);
primary = new ArrayAccessExpression((ParserLocation)arrayAccess, primary, indices);
}
else if (element is MemberCallContext)
{
var memberCall = element as MemberCallContext;
var memberName = nameVisitor.Visit(memberCall.id);
var delimiter = IdDelimiter.Dot;
switch (memberCall.sep.Text)
{
case "$": delimiter = IdDelimiter.Dollar; break;
case ".": delimiter = IdDelimiter.Dot; break;
case "#": delimiter = IdDelimiter.Hash; break;
case "->": delimiter = IdDelimiter.SingleArrow; break;
case "/": delimiter = IdDelimiter.Slash; break;
}
primary = new MemberExpression((ParserLocation)memberCall, primary, delimiter, memberName);
}
else if (element is MethodCallContext)
{
var methodCall = element as MethodCallContext;
IEnumerable <IExpression> parameters = Enumerable.Empty <IExpression>();
if (methodCall.@params != null)
{
parameters = exprListVisitor.Visit(methodCall.@params);
}
primary = new FunctionCallExpression((ParserLocation)methodCall, primary, parameters);
}
else
{
throw new InvalidOperationException("Unhandled chain element!");
}
}
return(primary);
}
public static Result Run(ArrayAccessExpression expression, Scope scope)
{
Result res = Result.NULL;
Resolve(expression, scope, (arr, key) =>
{
if (arr.TryGetValue(key, out ArrayItem item))
{
res = new Result(item.Value);
}
else
{
Log.Debug($"Undefined index: {key}, array: {arr}, scope: {scope}");
Log.Error($" existing indexes: {arr.GetAll ().Select (f => f.Key).Join (", ")}");
}
});
return(res);
}
public override Object Visit(ArrayAccessExpression node, Object obj)
{
Object aux = null;
//node.FirstOperand.LeftExpression = node.LeftExpression;
node.FirstOperand.LeftExpression = false;
node.SecondOperand.LeftExpression = false;
if ((aux = node.FirstOperand.Accept(this, false)) is SingleIdentifierExpression)
{
node.FirstOperand = (SingleIdentifierExpression)aux;
}
if ((aux = node.SecondOperand.Accept(this, false)) is SingleIdentifierExpression)
{
node.SecondOperand = (SingleIdentifierExpression)aux;
}
node.FirstOperand.LeftExpression = node.LeftExpression;
return(null);
}
public static void Resolve(ArrayAccessExpression expression, Scope scope, Action <IArray, ArrayKey> action)
{
FinalExpression key_expr = Interpreters.Execute(expression.Index, scope).ResultValue;
ArrayKey key = new ArrayKey(key_expr.GetStringValue());
FinalExpression array_expr = Interpreters.Execute(expression.Array, scope).ResultValue;
if (array_expr is ArrayPointerExpression pointer)
{
if (pointer.Array is IArray arr)
{
action(arr, key);
}
else
{
Log.Error($"Array could not be found: {pointer.Array.Name}, key: '{key}', scope: {scope}");
}
}
else
{
Log.Error($"Array access of key '{key}' is not performed on an array, but on: {array_expr}, scope: {scope}");
}
}
private IExpression ReadArrayAccess(Predicate <TokenMarker> terminatingPredicate, DslToken token, Stack <IExpression> previousExpressions)
{
var expArray = new ArrayAccessExpression();
Reader.DiscardToken();
var left = previousExpressions.Pop();
expArray.Object = left;
var marker = Reader.Marker.Clone();
var fnEndPredicate = DonutSyntaxReader.Filters.IndexArgumentsEnd(marker);
while (!Reader.IsComplete && !fnEndPredicate(Reader.Marker))
{
ParameterExpression fnParameter = ReadIndexParameter();
expArray.Parameters.Add(fnParameter);
if (Reader.Current.TokenType == TokenType.Comma)
{
Reader.DiscardToken();
}
}
Reader.DiscardToken(TokenType.CloseBracket);
return(expArray);
}
private Expression ParseArrayAccessExpression(Expression hint)
{
List <Expression> arguments = new List <Expression>();
MakeBlock(() =>
{
arguments.Add(ParseExpression());
while (_current == TokenKind.Comma)
{
Take(TokenKind.Comma);
arguments.Add(ParseExpression());
}
}, TokenKind.LeftBrace, TokenKind.RightBrace);
var expr = new ArrayAccessExpression(CreateSpan(hint), hint, arguments);
if (_current == TokenKind.Dot)
{
return(ParseReferenceExpression(expr));
}
return(expr);
}
private CodeExpression GenerateImperativeExpression(ArrayAccessExpression node) => new CodeArrayIndexerExpression(
GenerateImperativeExpression(node.ArrayExpression),
node.KeyExpressions.Select(x => GenerateImperativeExpression(x)).ToArray());
public override void Visit(ArrayAccessExpression s)
{
base.Visit(s);
Console.WriteLine(s._variable);
}
private System.Linq.Expressions.Expression EvaluateArrayAccessExpression(ArrayAccessExpression arrayAccessExpression)
{
return(System.Linq.Expressions.Expression.ArrayAccess(Evaluate(arrayAccessExpression.Target), Evaluate(arrayAccessExpression.Index)));
}
protected abstract void VisitArrayAccess(ArrayAccessExpression expression);
protected virtual void VisitArrayAccessExpression(ArrayAccessExpression arrayAccessExpression)
{
Visit(arrayAccessExpression.Target);
Visit(arrayAccessExpression.Index);
}
public abstract Object Visit(ArrayAccessExpression node, Object obj);
/// <summary>
/// Reads an array access expression.
/// </summary>
/// <param name="array">The array being accessed.</param>
/// <param name="previousPrecedence">The precedence of the previous expression.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the expression.</returns>
private ArrayAccessExpression GetArrayAccessExpression(
Expression array, ExpressionPrecedence previousPrecedence, bool unsafeCode)
{
Param.AssertNotNull(array, "array");
Param.Ignore(previousPrecedence);
Param.Ignore(unsafeCode);
ArrayAccessExpression expression = null;
if (this.CheckPrecedence(previousPrecedence, ExpressionPrecedence.Primary))
{
// The next symbol will be the opening bracket.
Bracket openingBracket = this.GetBracketToken(CsTokenType.OpenSquareBracket, SymbolType.OpenSquareBracket);
Node<CsToken> openingBracketNode = this.tokens.InsertLast(openingBracket);
// Get the argument list now.
ICollection<Expression> argumentList = this.GetArgumentList(SymbolType.CloseSquareBracket, unsafeCode);
// Get the closing bracket.
Bracket closingBracket = this.GetBracketToken(CsTokenType.CloseSquareBracket, SymbolType.CloseSquareBracket);
Node<CsToken> closingBracketNode = this.tokens.InsertLast(closingBracket);
openingBracket.MatchingBracketNode = closingBracketNode;
closingBracket.MatchingBracketNode = openingBracketNode;
// Pull out the first token from the array.
Node<CsToken> firstTokenNode = array.Tokens.First;
// Create the token list for the method invocation expression.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Create and return the expression.
expression = new ArrayAccessExpression(partialTokens, array, argumentList);
}
return expression;
}
public virtual void VisitArrayAccessExpression(ArrayAccessExpression node) => DefaultVisit(node);
public ArrayAssignmentStatement(ArrayAccessExpression array, IExpression expression)
{
_array = array;
_expression = expression;
}
private Statement assignmentStatement()
{
Token current = null;
if (match(TokenType.DESTRUCT))
{
return(destructuringAssignment());
}
if ((match(TokenType.CONST) || match(TokenType.LET)) && match(TokenType.LBRACE))
{
Dictionary <string, Value> variables = new Dictionary <string, Value>();
while (!match(TokenType.RBRACE))
{
var varname = consume(TokenType.WORD).getText();
consume(TokenType.EQ);
Value value = expression().eval();
variables.Add(varname, value);
}
return(new VarEnumerableAssignmentStatement(variables));
}
if (match(TokenType.LET))
{
current = get(0);
if (match(TokenType.WORD) && get(0).getType() == TokenType.EQ)
{
string variable = current.getText();
consume(TokenType.EQ);
return(new AssignmentStatement(variable, expression()));
}
if (current.getType() == TokenType.WORD)
{
string variable = current.getText();
return(new AssignmentStatement(variable, null));
}
}
if (match(TokenType.CONST))
{
current = get(0);
if (match(TokenType.WORD) && get(0).getType() == TokenType.EQ)
{
string variable = current.getText();
consume(TokenType.EQ);
return(new AssignmentStatement(variable, expression()));
}
}
else
{
current = get(0);
if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.EQ))
{
string variable = consume(TokenType.WORD).getText();
consume(TokenType.EQ);
return(new AssignmentStatement(variable, expression()));
}
// Проверка для массивов
if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.LBRACKET))
{
ArrayAccessExpression array = element();
consume(TokenType.EQ);
return(new ArrayAssignmentStatement(array, expression()));
}
}
throw new Exception("Unknown statement");
}
