/// <summary>Native method representing the apply method</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="req">Request that obtained this method</param>
public GraceObject Apply(EvaluationContext ctx, MethodRequest req)
{
GraceObject ret = GraceObject.Done;
MethodNode.CheckArgCount(ctx, "apply", "apply",
parameters.Count, Variadic,
req[0].Arguments.Count);
ctx.Remember(lexicalScope);
var myScope = new LocalScope(req.Name);
// Bind any local methods (types) on the scope
foreach (var localMeth in body.OfType <MethodNode>())
{
myScope.AddMethod(localMeth.Name, new Method(localMeth,
lexicalScope));
}
// Bind parameters and arguments
foreach (var arg in parameters.Zip(req[0].Arguments, (a, b) => new { name = a, val = b }))
{
var id = arg.name as ParameterNode;
if (id != null && id.Variadic)
{
// Populate variadic parameter with all remaining
// arguments.
var gvl = new GraceVariadicList();
for (var i = parameters.Count - 1;
i < req[0].Arguments.Count;
i++)
{
gvl.Add(req[0].Arguments[i]);
}
myScope.AddLocalDef(id.Name, gvl);
}
else
{
string name = ((IdentifierNode)arg.name).Name;
myScope.AddLocalDef(name, arg.val);
}
}
if (Variadic && parameters.Count > req[0].Arguments.Count)
{
// Empty variadic parameter.
var param = parameters.Last();
var idNode = param as ParameterNode;
if (idNode != null && idNode.Variadic)
{
var gvl = new GraceVariadicList();
myScope.AddLocalDef(idNode.Name, gvl);
}
}
ctx.Extend(myScope);
foreach (Node n in body)
{
ret = n.Evaluate(ctx);
}
ctx.Unextend(myScope);
ctx.Forget(lexicalScope);
return(ret);
}
/// <summary>
/// Raise an error if too many or too few arguments
/// provided to a method.
/// </summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="req">Method request to check</param>
/// <param name="want">
/// Number of arguments this method wants.
/// </param>
public static void CheckArity(EvaluationContext ctx,
MethodRequest req, int want)
{
var got = req[0].Arguments.Count;
MethodNode.CheckArgCount(ctx, req.Name, req[0].Name,
want, false, got);
CheckNoInherits(ctx, req);
}
/// <summary>
/// Raise an error if too many or too few arguments
/// provided to a part of a method.
/// </summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="req">Method request to check</param>
/// <param name="counts">
/// Number of arguments required in each part
/// </param>
public static void CheckArity(EvaluationContext ctx,
MethodRequest req, params int[] counts)
{
for (int i = 0; i < counts.Length; i++)
{
var got = req[i].Arguments.Count;
var want = counts[i];
MethodNode.CheckArgCount(ctx, req.Name, req[i].Name,
want, false, got);
}
CheckNoInherits(ctx, req);
}
/// <inheritdoc/>
public override GraceObject Respond(
EvaluationContext ctx,
GraceObject self,
MethodRequest req
)
{
checkAccessibility(ctx, req);
MethodHelper.CheckNoInherits(ctx, req);
MethodNode.CheckArgCount(ctx, req.Name, req.Name,
0, false,
req[0].Arguments.Count);
if (cell.Value == GraceObject.Uninitialised)
{
ErrorReporting.RaiseError(ctx, "R2008",
new Dictionary <string, string> {
{ "name", req.Name },
{ "receiver", self.ToString() }
},
"UninitialisedReadError: Cannot read from " + req.Name
);
}
return(cell.Value);
}
/// <inheritdoc/>
/// <remarks>This method uses the indexer on the LocalScope
/// object the method was requested on.</remarks>
public override GraceObject Respond(EvaluationContext ctx, GraceObject self, MethodRequest req)
{
checkAccessibility(ctx, req);
MethodHelper.CheckNoInherits(ctx, req);
MethodNode.CheckArgCount(ctx, req.Name, req.Name,
0, false,
req[0].Arguments.Count);
LocalScope s = self as LocalScope;
string name = req.Name;
if (s[name] == GraceObject.Uninitialised ||
s[name] == null)
{
ErrorReporting.RaiseError(ctx, "R2008",
new Dictionary <string, string> {
{ "name", name },
{ "receiver", ToString() }
},
"UninitialisedReadError: Cannot read from «" + name + "»"
);
}
return(s[name]);
}
