public CalledAndIndexedMemberNode(MemberNode member, CallExpressionNode call, ExpressionNode index,
SourceCodePosition pos) : base(pos)
{
Member = member;
Call = call;
Index = index;
}
private CallExpressionNode BuildCallExpressionNode(LexSpan func, LexSpan lPar, SyntaxNodeOrToken args, LexSpan rPar)
{
var callExp = new CallExpressionNode();
callExp.AddNode(new GlobalFunctionToken(func));
callExp.AddNode(new ParenToken(lPar));
callExp.AddNode(args);
callExp.AddNode(new ParenToken(rPar));
return(callExp);
}
private EbiValueBase Evaluate(EbiScope scope, ExpressionNode expr)
{
return(expr switch
{
LiteralNode l => l.Value,
IdentifierNode id => scope[id.Name]?.Value ?? throw new RuntimeException($"No such identifier named '{id.Name}'"),
CallExpressionNode call => Evaluate(scope, call),
UnaryExpressionNode un => Evaluate(scope, un),
BinaryExpressionNode bin => Evaluate(scope, bin),
_ => new EbiNull(),
});
private CallExpressionNode Call(IdentifierNode ident)
{
CallExpressionNode itsAST;
SourceCodePosition itsPos = _currentToken.SourcePosition;
Accept(Token.TokenType.LeftParen);
ArgumentSequenceNode itsArgs = Arguments();
Accept(Token.TokenType.RightParen);
itsAST = new CallExpressionNode(ident, itsArgs, itsPos);
return(itsAST);
}
public object Visit(CallExpressionNode n, object o)
{
Append("(");
n.Arguments.Accept(this, null);
if (StandardLibrary.IsStdlibMethod(n.Identifier.Value))
{
// if the call is to a stdlib method, append the source code position to the string such that errors
// from external libraries can be emitted with the position of the offending Deslang code piece
Append($", \"{n.SourcePosition}\"");
}
Append(")");
return(null);
}
private MemberExpressionNode MemberReference()
{
MemberExpressionNode itsAST;
SourceCodePosition itsPos = _currentToken.SourcePosition;
IdentifierNode itsName = new IdentifierNode(_currentToken);
Accept(Token.TokenType.Identifier);
MemberNode itsMember = new SimpleMemberNode(itsName, itsPos);
if (_currentToken.Type == Token.TokenType.LeftParen)
{
CallExpressionNode itsCall = Call(itsName); // add the associated identifier to the call
itsMember = new CalledMemberNode(itsMember, itsCall, itsPos);
if (_currentToken.Type == Token.TokenType.LeftBracket)
{
ExpressionNode itsIndex = ArrayExpression();
itsMember = new CalledAndIndexedMemberNode(itsMember, itsCall, itsIndex, itsPos);
}
}
else if (_currentToken.Type == Token.TokenType.LeftBracket)
{
ExpressionNode itsIndex = ArrayExpression();
itsMember = new IndexedMemberNode(itsMember, itsIndex, itsPos);
}
while (_currentToken.Type == Token.TokenType.Dot)
{
Accept(Token.TokenType.Dot);
itsName = new IdentifierNode(_currentToken);
Accept(Token.TokenType.Identifier);
itsMember = new DotMemberNode(itsMember, itsName, itsPos);
if (_currentToken.Type == Token.TokenType.LeftParen)
{
CallExpressionNode itsCall = Call(itsName); // add the associated identifier to the call
itsMember = new CalledMemberNode(itsMember, itsCall, itsPos);
if (_currentToken.Type == Token.TokenType.LeftBracket)
{
ExpressionNode itsIndex = ArrayExpression();
itsMember = new CalledAndIndexedMemberNode(itsMember, itsCall, itsIndex, itsPos);
}
}
else if (_currentToken.Type == Token.TokenType.LeftBracket)
{
ExpressionNode itsIndex = ArrayExpression();
itsMember = new IndexedMemberNode(itsMember, itsIndex, itsPos);
}
}
itsAST = new MemberExpressionNode(itsMember, itsPos);
return(itsAST);
}
private CallExpressionNode BuildCallExpressionNode(
SyntaxNodeOrToken member,
LexSpan lPar,
SyntaxNodeOrToken args,
LexSpan rPar)
{
var callExp = new CallExpressionNode();
callExp.AddNode(member);
callExp.AddNode(new ParenToken(lPar));
callExp.AddNode(args);
callExp.AddNode(new ParenToken(rPar));
return(callExp);
}
private static PythonNode Wrap(CallExpression exp, PythonNode parent)
{
var result = new CallExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Target, result));
for (var i = 0; i < exp.Args.Count; i++)
{
var arg = exp.Args[i];
result.AddChild(Wrap(arg, result));
}
return(result);
}
private void Write(CallExpressionNode exp)
{
Write(exp.Children[0]);
_code.Append("(");
for (var i = 1; i < exp.Children.Count; i++)
{
var arg = exp.Children[i];
Write(arg);
if (i < exp.Children.Count - 1)
{
_code.Append(", ");
}
}
_code.Append(")");
}
public virtual Value evaluate(Context cx, CallExpressionNode node)
{
output("<CallExpressionNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
if (node.args != null)
{
node.args.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</CallExpressionNode>");
return(null);
}
private static void Walk([NotNull] Agent agent, [NotNull] CallExpressionNode callExpression, bool isStrict)
{
if (callExpression.Callee is SuperNode)
{
//TODO
}
else
{
//TODO
Walk(agent, callExpression.Callee, isStrict);
}
foreach (var argument in callExpression.Arguments)
{
if (argument != null)
{
Walk(agent, argument, isStrict);
}
}
}
public CalledMemberNode(MemberNode member, CallExpressionNode call, SourceCodePosition pos)
: base(pos)
{
Member = member;
Call = call;
}
public object Visit(CallExpressionNode n, object o)
{
return(null);
}
public virtual Value evaluate(Context cx, CallExpressionNode node)
{
output("<CallExpressionNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
if (node.args != null)
{
node.args.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</CallExpressionNode>");
return null;
}
private void PerformIdentificationOnCallDeclaration(CallExpressionNode callExpression)
{
PerformIdentification(callExpression.Identifier);
PerformIdentification(callExpression.Parameter);
}
