public void GenerateCode(InvokeNode node, ICIL_CodeGenerator codeGenerator)
{
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
#region GenerateCode SelfNode
var self = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable(self));
var instance = node.OwnerType.Self.Holder;
codeGenerator.AddInstruction(
new Assign(self, instance));
#endregion
if (node.Parameters != null)
{
GenerateCode(node.Parameters, codeGenerator);
}
codeGenerator.AddInstruction(
new Param(self));
codeGenerator.AddInstruction(
new Call((Variable)node.Holder, $"{node.Method.ParentScope}_{node.FuncName}"));
}
public void CheckSemantic(InvokeNode node, IScope scope = null)
{
var copyScope = scope;
while (!(copyScope is IType))
{
copyScope = copyScope?.ParentScope;
}
var type = (IType)copyScope;
#region Ready to use for Code Generation
node.OwnerType = type;
#endregion
if (!type.IsDefinedMethod(node.FuncName, out var method))
{
Logger.LogError(node.Line, node.CharPositionInLine,
$"The name '{node.FuncName}' does not exist in the {type}'s context");
return;
}
node.Method = method;
//chek arguments
if (node.Parameters != null)
{
if (node.Parameters.Children.Count == method.Arguments.Length)
{
var i = 0;
foreach (var parameter in node.Parameters.Expressions)
{
CheckSemantic(parameter, scope);
if (!((CoolType)method.Arguments[i].Type <= (CoolType)parameter.ComputedType))
{
Logger.LogError(parameter.Line, parameter.CharPositionInLine,
$"Argument '{i}': cannot convert from '{parameter.ComputedType}' to {method.Arguments[i].Type}");
}
i++;
}
}
else
{
Logger.LogError(node.Line, node.CharPositionInLine,
$"No overload for method '{method.Name}' takes '{node.Parameters.Children.Count}' arguments");
}
}
else if (method.Arguments.Length > 0)
{
Logger.LogError(node.Line, node.CharPositionInLine,
$"No overload for method '{method.Name}' takes '0' arguments");
}
node.ComputedType = method.ReturnType;
}
public virtual Value evaluate(Context cx, InvokeNode node)
{
output("<InvokeNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.args != null)
{
node.args.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</InvokeNode>");
return(null);
}
public void Parse_InvokeAccessExpression_1Arg()
{
ASTNode root = ExpressionParser.Parse("someProperty(1)");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
InvokeNode invokeNode = (InvokeNode)node.parts[0];
Assert.AreEqual(1, invokeNode.parameters.Count);
Assert.IsInstanceOf <LiteralNode>(invokeNode.parameters[0]);
}
public void CreateInvokeNode()
{
IList <INode> arguments = new List <INode>()
{
new ConstantNode(42)
};
InvokeNode node = new InvokeNode(new NameNode("append"), arguments);
node.RegisterInContext(null);
Assert.AreSame(arguments, node.Arguments);
Assert.IsNotNull(node.Target);
Assert.IsInstanceOfType(node.Target, typeof(NameNode));
Assert.AreEqual("append", ((NameNode)node.Target).Name);
}
public void Parse_InvokeAccessExpression_2Arg_Chained()
{
ASTNode root = ExpressionParser.Parse("someProperty(1, something)()");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(2, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
Assert.IsInstanceOf <InvokeNode>(node.parts[1]);
InvokeNode invokeNode = (InvokeNode)node.parts[0];
Assert.AreEqual(2, invokeNode.parameters.Count);
Assert.IsInstanceOf <LiteralNode>(invokeNode.parameters[0]);
Assert.IsInstanceOf <IdentifierNode>(invokeNode.parameters[1]);
}
public void CheckType()
{
Context context = new Context();
DefNode defnode = new DefNode("append", null, TypeInfo.Int, null);
defnode.RegisterInContext(context);
IList <INode> arguments = new List <INode>()
{
new ConstantNode(42)
};
InvokeNode node = new InvokeNode(new NameNode("append"), arguments);
Assert.IsNull(node.TypeInfo);
node.CheckType(context);
Assert.AreEqual(TypeInfo.Int, node.TypeInfo);
}
public AstNode VisitInvoke(InvokeNode n)
{
Visit(n.Instance);
Append("(");
if (!n.Arguments.IsNullOrEmpty())
{
Visit(n.Arguments[0]);
for (var i = 1; i < n.Arguments.Count; i++)
{
Append(", ");
Visit(n.Arguments[i]);
}
}
Append(")");
return(n);
}
public virtual Value evaluate(Context cx, InvokeNode node)
{
output("<InvokeNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.args != null)
{
node.args.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</InvokeNode>");
return null;
}
public virtual AstNode VisitInvoke(InvokeNode n)
{
Visit(n.Instance);
Visit(n.Arguments);
return(n);
}
private INode ParseSimpleNode()
{
var token = this.NextToken();
if (token == null)
{
return(null);
}
if (token.Type == TokenType.Name && token.Value == "class")
{
return(this.ParseClassNode());
}
if (token.Type == TokenType.Name && token.Value == "object")
{
return(this.ParseObjectNode());
}
if (token.Type == TokenType.Name && token.Value == "val")
{
return(this.ParseValNode());
}
if (token.Type == TokenType.Name && token.Value == "var")
{
return(this.ParseVarNode());
}
if (token.Type == TokenType.Name && token.Value == "def")
{
return(this.ParseDefNode());
}
this.PushToken(token);
INode node = this.ParseExpressionNode();
if (node == null)
{
return(null);
}
while (true)
{
INode newnode = node;
while (this.TryParseToken(TokenType.Delimiter, "."))
{
newnode = new DotNameNode(newnode, this.ParseName());
}
while (this.TryParseToken(TokenType.Delimiter, "("))
{
IList <INode> arguments = new List <INode>();
while (!this.TryParseToken(TokenType.Delimiter, ")"))
{
if (arguments.Count > 0)
{
this.ParseToken(TokenType.Delimiter, ",");
}
arguments.Add(this.ParseExpressionNode());
}
if (newnode is DotNameNode)
{
newnode = new InvokeMethodNode(((DotNameNode)newnode).Target, ((DotNameNode)newnode).Name, arguments);
}
else
{
newnode = new InvokeNode(newnode, arguments);
}
}
if (node == newnode)
{
break;
}
node = newnode;
}
return(node);
}
