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))); }))); }