public static object ActivateWithCallAndData(IokeObject receiver, IokeObject context, IokeObject message, object obj, object c, IDictionary <string, object> d1)
{
switch (receiver.data.type)
{
case IokeData.TYPE_DEFAULT_METHOD:
return(DefaultMethod.ActivateWithCallAndDataFixed(receiver, context, message, obj, c, d1));
case IokeData.TYPE_DEFAULT_MACRO:
return(DefaultMacro.ActivateWithCallAndDataFixed(receiver, context, message, obj, c, d1));
case IokeData.TYPE_DEFAULT_SYNTAX:
return(DefaultSyntax.ActivateWithCallAndDataFixed(receiver, context, message, obj, c, d1));
case IokeData.TYPE_LEXICAL_MACRO:
return(LexicalMacro.ActivateWithCallAndDataFixed(receiver, context, message, obj, c, d1));
case IokeData.TYPE_NATIVE_METHOD:
return(NativeMethod.ActivateFixed(receiver, context, message, obj));
case IokeData.TYPE_METHOD_PROTOTYPE:
return(Method.ActivateFixed(receiver, context, message, obj));
case IokeData.TYPE_LEXICAL_BLOCK:
return(LexicalBlock.ActivateWithCallAndDataFixed(receiver, context, message, obj, c, d1));
case IokeData.TYPE_ALIAS_METHOD:
return(AliasMethod.ActivateFixed(receiver, context, message, obj));
case IokeData.TYPE_NONE:
default:
return(IokeData.ActivateFixed(receiver, context, message, obj));
}
}
public static object ActivateWithDataFixed(IokeObject self, IokeObject context, IokeObject message, object on, IDictionary <string, object> data)
{
DefaultSyntax dm = (DefaultSyntax)self.data;
object result = dm.Expand(self, context, message, on, data);
if (result == context.runtime.nil)
{
// Remove chain completely
IokeObject prev = Message.GetPrev(message);
IokeObject next = Message.GetNext(message);
if (prev != null)
{
Message.SetNext(prev, next);
if (next != null)
{
Message.SetPrev(next, prev);
}
}
else
{
message.Become(next, message, context);
Message.SetPrev(next, null);
}
return(null);
}
else
{
// Insert resulting value into chain, wrapping it if it's not a message
IokeObject newObj = null;
if (IokeObject.dataOf(result) is Message)
{
newObj = IokeObject.As(result, context);
}
else
{
newObj = context.runtime.CreateMessage(Message.Wrap(IokeObject.As(result, context)));
}
IokeObject prev = Message.GetPrev(message);
IokeObject next = Message.GetNext(message);
message.Become(newObj, message, context);
IokeObject last = newObj;
while (Message.GetNext(last) != null)
{
last = Message.GetNext(last);
}
Message.SetNext(last, next);
if (next != null)
{
Message.SetPrev(next, last);
}
Message.SetPrev(newObj, prev);
// We need to distinguish explicit calls to self, and calls through a local context.
object receiver = (prev == null || Message.IsTerminator(prev)) ? context : on;
return(Interpreter.Send(message, context, receiver));
}
}
public override void Init(IokeObject obj)
{
obj.Kind = "DefaultSyntax";
obj.SetActivatable(true);
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the name of the syntax",
new TypeCheckingNativeMethod.WithNoArguments("name", obj,
(method, on, args, keywords, _context, message) => {
return(_context.runtime.NewText(((DefaultSyntax)IokeObject.dataOf(on)).name));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("activates this syntax with the arguments given to call",
new NativeMethod("call", DefaultArgumentsDefinition.builder()
.WithRestUnevaluated("arguments")
.Arguments,
(method, _context, message, on, outer) => {
return(Interpreter.Activate(IokeObject.As(on, _context), _context, message, _context.RealContext));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the result of activating this syntax without actually doing the replacement or execution part.",
new NativeMethod("expand", DefaultArgumentsDefinition.builder()
.WithRestUnevaluated("arguments")
.Arguments,
(method, _context, message, on, outer) => {
object onAsSyntax = _context.runtime.DefaultSyntax.ConvertToThis(on, message, _context);
return(((DefaultSyntax)IokeObject.dataOf(onAsSyntax)).Expand(IokeObject.As(onAsSyntax, context), context, message, context.RealContext, null));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the message chain for this syntax",
new TypeCheckingNativeMethod.WithNoArguments("message", obj,
(method, on, args, keywords, _context, message) => {
return(((AssociatedCode)IokeObject.dataOf(on)).Code);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the code for the argument definition",
new TypeCheckingNativeMethod.WithNoArguments("argumentsCode", obj,
(method, on, args, keywords, _context, message) => {
return(_context.runtime.NewText(((AssociatedCode)IokeObject.dataOf(on)).ArgumentsCode));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("inspect", obj,
(method, on, args, keywords, _context, message) => {
return(_context.runtime.NewText(DefaultSyntax.GetInspect(on)));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("Returns a brief text inspection of the object",
new TypeCheckingNativeMethod.WithNoArguments("notice", obj,
(method, on, args, keywords, _context, message) => {
return(_context.runtime.NewText(DefaultSyntax.GetNotice(on)));
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the full code of this syntax, as a Text",
new TypeCheckingNativeMethod.WithNoArguments("code", obj,
(method, on, args, keywords, _context, message) => {
IokeData data = IokeObject.dataOf(on);
if (data is DefaultSyntax)
{
return(_context.runtime.NewText(((DefaultSyntax)data).CodeString));
}
else
{
return(_context.runtime.NewText(((AliasMethod)data).CodeString));
}
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns idiomatically formatted code for this syntax",
new TypeCheckingNativeMethod.WithNoArguments("formattedCode", obj,
(method, on, args, keywords, _context, message) => {
return(_context.runtime.NewText(((AssociatedCode)IokeObject.dataOf(on)).FormattedCode(method)));
})));
}
