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