// R(1, -) public override object Invoke(BlockParam/*!*/ param, object self, object arg1) { if (_parameterCount > 0) { return InvokeSplatInternal(param, self, ArrayUtils.EmptyObjects, arg1); // TODO: optimize } else { return InvokeInternal(param, self, new object[] { arg1 }); // TODO: optimize } }
private object InvokeInternal(BlockParam/*!*/ param, object self, object[]/*!*/ args) { // TODO if (args.Length < _parameterCount) { Array.Resize(ref args, _parameterCount); return _block(param, self, args, RubyOps.MakeArray0()); } else if (args.Length == _parameterCount) { return _block(param, self, args, RubyOps.MakeArray0()); } else { var actualArgs = new object[_parameterCount]; for (int i = 0; i < actualArgs.Length; i++) { actualArgs[i] = args[i]; } var array = new RubyArray(args.Length - _parameterCount); for (int i = _parameterCount; i < args.Length; i++) { array.Add(args[i]); } return _block(param, self, actualArgs, array); } }
public static object Each(RubyContext /*!*/ context, BlockParam block, object self, DynamicNull separator) { RubyIOOps.Each(context, block, context.InputProvider.GetOrResetCurrentStream(), separator); return(self); }
public abstract object InvokeSplatRhs(BlockParam/*!*/ param, object self, object[]/*!*/ args, object splattee, object rhs);
public static object NewAnonymousStruct(BlockParam block, RubyClass /*!*/ self, [NotNull] string /*!*/ firstAttibuteName, [DefaultProtocol, NotNullItems] params string /*!*/[] /*!*/ attributeNames) { return(CreateAnonymousWithFirstAttribute(block, self, firstAttibuteName, attributeNames)); }
// R(N, -) public override object Invoke(BlockParam/*!*/ param, object self, object[]/*!*/ args) { Debug.Assert(args.Length > MaxBlockArity); return _block(param, self); }
public abstract object InvokeNoAutoSplat(BlockParam/*!*/ param, object self, object arg1);
// R(1, -) public override object InvokeNoAutoSplat(BlockParam/*!*/ param, object self, object arg1) { return _block(param, self, arg1, null, null, null); }
// R(3, -) public override object Invoke(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3) { return _block(param, self); }
public static object OpenPipe(RubyContext /*!*/ context, BlockParam block, RubyClass /*!*/ self, [DefaultProtocol, NotNull] MutableString /*!*/ command, [DefaultProtocol, Optional, NotNull] MutableString modeString) { return(TryInvokeOpenBlock(context, block, OpenPipe(context, self, command, modeString))); }
public static object Times1(BlockParam block, int self) { return(1); }
public static void ForEach(BlockParam block, RubyClass /*!*/ self, [DefaultProtocol, NotNull] MutableString /*!*/ path, [DefaultProtocol] MutableString separator) { using (RubyIO io = new RubyIO(self.Context, File.OpenRead(path.ConvertToString()), IOMode.ReadOnly)) { Each(self.Context, block, io, separator); } }
public static object Each(RubyContext /*!*/ context, BlockParam block, RubyIO /*!*/ self) { return(Each(context, block, self, context.InputSeparator)); }
public static void ForEach(BlockParam block, RubyClass /*!*/ self, [DefaultProtocol, NotNull] MutableString /*!*/ path) { ForEach(block, self, path, self.Context.InputSeparator); }
public static object EachByte(RubyContext /*!*/ context, BlockParam block, object self) { RubyIOOps.EachByte(block, context.InputProvider.GetOrResetCurrentStream()); return(self); }
public static object Each(RubyContext /*!*/ context, BlockParam block, object self, [DefaultProtocol] MutableString separator, [DefaultProtocol] int limit) { RubyIOOps.Each(context, block, context.InputProvider.GetOrResetCurrentStream(), separator, limit); return(self); }
// R(4, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, object splattee) { return InvokeSplatInternal(param, self, RubyOps.MakeArray4(arg1, arg2, arg3, arg4), splattee); }
public static object Times3([NotNull] BlockParam /*!*/ block, int self) { return(3); }
// R(N, *, =) public override object InvokeSplatRhs(BlockParam/*!*/ param, object self, object[]/*!*/ args, object splattee, object rhs) { var array = new RubyArray(args); RubyOps.SplatAppend(array, splattee); array.Add(rhs); if (array.Count == 1) { return _block(param, self, rhs); } Debug.Assert(array.Count >= 2); if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(array.Count); } return _block(param, self, array); }
public static object Times4(RubyContext /*!*/ context, BlockParam block, object self) { return(4); }
// R(0, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object splattee) { return InvokeSplatInternal(param, self, splattee); }
// R(4, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, IList /*!*/ splattee) { return(InvokeSplatInternal(param, self, new object[] { arg1, arg2, arg3, arg4 }, splattee)); }
// R(N, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object[]/*!*/ args, object splattee) { Debug.Assert(args.Length > MaxBlockArity); return _block(param, self, args[0], args[1], args[2], args[3]); }
// R(0, -) public override object Invoke(BlockParam /*!*/ param, object self) { return(InvokeInternal(param, self, ArrayUtils.EmptyObjects)); }
// method_missing on main singleton in DLR Scope bound code. // Might be called via a site -> needs to be public in partial trust. public static object TopMethodMissing(RubyScope/*!*/ scope, BlockParam block, object/*!*/ self, SymbolId name, [NotNull]params object[]/*!*/ args) { Assert.NotNull(scope, self); Debug.Assert(!scope.IsEmpty); Scope globalScope = scope.GlobalScope.Scope; Debug.Assert(globalScope != null); // TODO: error when arguments non-empty, block != null, ... // TODO: name-mangling if (args.Length == 0) { object value; if (globalScope.TryGetName(name, out value)) { return value; } } else if (args.Length == 1) { string str = SymbolTable.IdToString(name); if (str.Length > 0 && str[str.Length - 1] == '=') { SymbolId plainName = SymbolTable.StringToId(str.Substring(0, str.Length - 1)); globalScope.SetName(plainName, args[0]); return args[0]; } } // TODO: call super throw RubyExceptions.CreateMethodMissing(scope.RubyContext, self, SymbolTable.IdToString(name)); }
// R(1, -) public override object InvokeNoAutoSplat(BlockParam /*!*/ param, object self, object arg1) { return(InvokeInternal(param, self, new object[] { arg1 })); // TODO: optimize }
public abstract object Invoke(BlockParam/*!*/ param, object self, object[]/*!*/ args);
// R(N, -) public override object Invoke(BlockParam/*!*/ param, object self, object[]/*!*/ args) { Debug.Assert(args.Length > MaxBlockArity); if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(args.Length); } return _block(param, self, RubyOps.MakeArrayN(args)); }
// "method_missing" on main singleton in DLR Scope bound code. // Might be called via a site -> needs to be public in partial trust. public static object TopMethodMissing(RubyScope/*!*/ localScope, BlockParam block, object/*!*/ self, SymbolId name, [NotNull]params object[]/*!*/ args) { return ScopeMethodMissing(localScope.RubyContext, localScope.GlobalScope.Scope, block, self, name, args); }
// R(1, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object arg1, object splattee) { var list = splattee as IList; if (list == null) { if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(2); } arg1 = RubyOps.MakeArray2(arg1, splattee); } else if (list.Count > 0) { var array = RubyOps.MakeArray1(arg1); array.AddRange(list); arg1 = array; if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(array.Count); } } return _block(param, self, arg1); }
// R(4, -) public override object Invoke(BlockParam /*!*/ param, object self, object arg1, object arg2, object arg3, object arg4) { return(InvokeInternal(param, self, new object[] { arg1, arg2, arg3, arg4 }));// TODO: optimize }
public static object CreateAnonymousWithFirstAttribute(BlockParam block, RubyClass /*!*/ self, string /*!*/ firstAttribute, string /*!*/[] /*!*/ attributeNames) { return(Create(block, self, null, ArrayUtils.Insert(firstAttribute, attributeNames))); }
// R(0, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object splattee) { var list = splattee as IList; if (list != null) { switch (list.Count) { case 0: if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(list.Count); } splattee = null; break; case 1: splattee = list[0]; break; default: if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(list.Count); } splattee = new RubyArray(list); break; } } return _block(param, self, splattee); }
// R(N, -) public override object Invoke(BlockParam /*!*/ param, object self, object[] /*!*/ args) { return(InvokeInternal(param, self, args)); }
private object InvokeSplatInternal(BlockParam/*!*/ param, object self, RubyArray/*!*/ array, object splattee) { Debug.Assert(array.Count >= 2); RubyOps.SplatAppend(array, splattee); if (!HasSingleCompoundParameter) { param.MultipleValuesForBlockParameterWarning(array.Count); } return _block(param, self, array); }
public static Object Css(RubyContext /*!*/ context, BlockParam /*!*/ block, RubyModule /*!*/ self) { return(null); }
// R(N, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object[]/*!*/ args, object splattee) { Debug.Assert(args.Length > MaxBlockArity); return InvokeSplatInternal(param, self, RubyOps.MakeArrayN(args), splattee); }
// R(N, *, =) public override object InvokeSplatRhs(BlockParam /*!*/ param, object self, object[] /*!*/ args, IList /*!*/ splattee, object rhs) { return(_block(param, self)); }
// R(0, -) public override object Invoke(BlockParam/*!*/ param, object self) { return _block(param, self, null, null, null, null); }
// R(4, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, IList /*!*/ splattee) { return(InvokeSplatInternal(param, self, RubyOps.MakeArray4(arg1, arg2, arg3, arg4), splattee)); }
// R(1, -) public override object Invoke(BlockParam/*!*/ param, object self, object arg1) { return InvokeSplatInternal(param, self, arg1); }
// R(N, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, object[] /*!*/ args, IList /*!*/ splattee) { Debug.Assert(args.Length > MaxBlockArity); return(InvokeSplatInternal(param, self, RubyOps.MakeArrayN(args), splattee)); }
private object InvokeSplatInternal(BlockParam/*!*/ param, object self, object splattee) { var list = splattee as IList; if (list != null) { switch (list.Count) { case 0: return _block(param, self, null, null, null, null); case 1: return _block(param, self, list[0], null, null, null); case 2: return _block(param, self, list[0], list[1], null, null); case 3: return _block(param, self, list[0], list[1], list[2], null); default: return _block(param, self, list[0], list[1], list[2], list[3]); } } return _block(param, self, splattee, null, null, null); }
// R(0, -) public override object Invoke(BlockParam /*!*/ param, object self) { return(_block(param, self, null, null, null, null)); }
// R(3, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3, object splattee) { var list = splattee as IList; if (list != null) { switch (list.Count) { case 0: return _block(param, self, arg1, arg2, arg3, null); default: return _block(param, self, arg1, arg2, arg3, list[0]); } } return _block(param, self, arg1, arg2, arg3, splattee); }
// R(1, -) public override object InvokeNoAutoSplat(BlockParam /*!*/ param, object self, object arg1) { return(_block(param, self, arg1, null, null, null)); }
// R(N, *, =) public override object InvokeSplatRhs(BlockParam/*!*/ param, object self, object[]/*!*/ args, object splattee, object rhs) { args = CreateArgumentsFromSplatteeAndRhs(4, args, splattee, rhs); return _block(param, self, args[0], args[1], args[2], args[3]); }
// R(N, -) public override object Invoke(BlockParam /*!*/ param, object self, object[] /*!*/ args) { Debug.Assert(args.Length > MaxBlockArity); return(_block(param, self, args[1], args[2], args[3], args[4])); }
// R(4, *) public override object InvokeSplat(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, object splattee) { return _block(param, self); }
// R(0, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, IList /*!*/ splattee) { return(InvokeSplatInternal(param, self, splattee)); }
public abstract object Invoke(BlockParam/*!*/ param, object self);
// R(3, -) public override object Invoke(BlockParam /*!*/ param, object self, object arg1, object arg2, object arg3) { return(_block(param, self)); }
public abstract object Invoke(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3, object arg4);
// R(4, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, IList /*!*/ splattee) { return(_block(param, self, arg1, arg2, arg3, arg4)); }
public abstract object InvokeSplat(BlockParam/*!*/ param, object self, object arg1, object arg2, object arg3, object arg4, object splattee);
// R(N, *) public override object InvokeSplat(BlockParam /*!*/ param, object self, object[] /*!*/ args, IList /*!*/ splattee) { Debug.Assert(args.Length > MaxBlockArity); return(_block(param, self, args[0], args[1], args[2], args[3])); }
internal RubyBlockScope(MutableTuple locals, SymbolId[]/*!*/ variableNames, BlockParam/*!*/ blockFlowControl, object selfObject, InterpretedFrame interpretedFrame) { var parent = blockFlowControl.Proc.LocalScope; // RuntimeFlowControl: _activeFlowControlScope = parent.FlowControlScope; // RubyScope: _parent = parent; _top = parent.Top; _selfObject = selfObject; _methodAttributes = RubyMethodAttributes.PublicInstance; _locals = locals; _variableNames = variableNames; InterpretedFrame = interpretedFrame; // RubyBlockScope: _blockFlowControl = blockFlowControl; }
// R(N, *, =) public override object InvokeSplatRhs(BlockParam /*!*/ param, object self, object[] /*!*/ args, IList /*!*/ splattee, object rhs) { args = CreateArgumentsFromSplatteeAndRhs(4, args, splattee, rhs); return(_block(param, self, args[0], args[1], args[2], args[3])); }
public static object ScopeMethodMissing(RubyContext/*!*/ context, Scope/*!*/ globalScope, BlockParam block, object self, SymbolId name, object[]/*!*/ args) { Assert.NotNull(context, globalScope); // TODO: invoke member: string str = SymbolTable.IdToString(name); if (str.LastCharacter() == '=') { if (args.Length != 1) { throw RubyOps.MakeWrongNumberOfArgumentsError(args.Length, 1); } // Consider this case: // There is {"Foo" -> 1} in the scope. // x.foo += 1 // Without name mangling this would result to {"Foo" -> 1, "foo" -> 2} while the expected result is {"Foo" -> 2}. str = str.Substring(0, str.Length - 1); if (!RubyOps.ScopeContainsMember(globalScope, str)) { var unmangled = RubyUtils.TryUnmangleName(str); if (unmangled != null && RubyOps.ScopeContainsMember(globalScope, unmangled)) { str = unmangled; } } var value = args[0]; RubyOps.ScopeSetMember(globalScope, str, value); return value; } else { object result; if (RubyOps.TryGetGlobalScopeMethod(context, globalScope, str, out result)) { if (args.Length != 0) { throw RubyOps.MakeWrongNumberOfArgumentsError(args.Length, 0); } return result; } if (self != null && str == "scope") { if (args.Length != 0) { throw RubyOps.MakeWrongNumberOfArgumentsError(args.Length, 0); } return self; } } // TODO: call super throw RubyExceptions.CreateMethodMissing(context, self, SymbolTable.IdToString(name)); }
public static object Select(CallSiteStorage <EachSite> /*!*/ each, BlockParam predicate, RubyStruct /*!*/ self) { return(Enumerable.Select(each, predicate, self)); }