public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
if (args.Length == 0)
return Call1(last_class, recv, caller, args.block, 1);
else
return Call1(last_class, recv, caller, args.block, args[0]);
}
public object yield(Frame caller, ArgList args)
{
args.block = this.block;
// return body.Calln(my_class, self, caller, args); // BBTAG: last_class should be nearest lexical class definition rather than Proc
Class last_class = Init.rb_cObject;
if (caller != null && caller.nesting().Length > 0)
last_class = caller.nesting()[0];
return body.Calln(last_class, self, caller, args);
}
internal object yield(Frame caller, params object[] args)
{
ArgList list = new ArgList(block, args);
if (args.Length == 1)
list.single_arg = true;
return yield(caller, list);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
if (args.Length >= 1)
{
string path = String.StringValue(args[0], caller);
if (path.StartsWith("|"))
{
String newpath = new String(path.Remove(0, 1));
args[0] = newpath;
return rb_io_s_popen.singleton.Calln(last_class, Ruby.Runtime.Init.rb_cIO, caller, args);
}
}
return rb_io_s_open.singleton.Calln(last_class, Ruby.Runtime.Init.rb_cFile, caller, args);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
Proc proc = (Proc)recv;
switch (proc.kind)
{
case ProcKind.Method:
case ProcKind.Lambda:
{
args.single_arg = false;
if (!proc.HasCorrectArgs(args.Length))
throw new ArgumentError(string.Format(CultureInfo.InvariantCulture, "wrong number of arguments ({0} for {1})", args.Length, System.Math.Abs(proc._arity))).raise(caller);
try
{
return Proc.rb_yield(proc, caller, args);
}
catch (ReturnException exception)
{
return exception.return_value;
}
catch (BreakException exception)
{
return exception.return_value;
}
}
case ProcKind.RawProc:
{
try
{
return Proc.rb_yield(proc, caller, args);
}
catch (BreakException)
{
throw new LocalJumpError("break from proc-closure").raise(caller);
}
}
default:
case ProcKind.Block:
{
return Proc.rb_yield(proc, caller, args);
}
}
}
public override object Calln(Class last_class, object self, Frame caller, ArgList args)
{
int safe = -1;
Method method = (Method)self;
object result = null;
if (method.recv == null)
throw new TypeError("you cannot call unbound method; bind first").raise(caller);
if (method.Tainted)
{
safe = Eval.ruby_safe_level;
if (Eval.ruby_safe_level < 4)
Eval.ruby_safe_level = 4;
}
result = method.body.body.Calln(last_class, method.recv, caller, args);
if (safe >= 0)
Eval.ruby_safe_level = safe;
return result;
}
internal static object method_missing(object recv, Frame caller, string methodId, ArgList args) {
ArgList newargs = new ArgList(args.block);
newargs.Add(new Symbol(methodId));
newargs.AddRange(args);
Class origin;
RubyMethod method = FindPrivateMethod(recv, caller, "method_missing", out origin);
if (method != null)
return method.body.Calln(origin, recv, caller, newargs);
else
throw new NoMethodError("method_missing method missing").raise(caller);
}
public static object CallPrivateA(object recv, Frame caller, string methodId, ArgList args) {
Class origin;
RubyMethod method = FindPrivateMethod(recv, caller, methodId, out origin);
if (method != null)
return method.body.Calln(origin, recv, caller, args);
else
return method_missing(recv, caller, methodId, args);
}
public abstract object Calln(Class last_class, Class ruby_class, object recv, Frame caller, ArgList args);
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
return Eval.CallSuperA(klass, caller, recv, methodId, args);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
return Call(last_class, recv, caller, args.block, Remaining(args, 0));
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
if (args.Length == 9)
return Call9(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
else
throw new ArgumentError("wrong number of arguments (" + args.Length + " for 9)").raise(caller);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
Errors.rb_warn(string.Format(CultureInfo.InvariantCulture, "Hash#{0} is deprecated; use Hash#values_at", "indexes")); //rb_frame_last_func
System.Collections.ArrayList result = new System.Collections.ArrayList(args.Length);
for (int i = 0; i < args.Length; i++)
result.Add(rb_hash_aref.singleton.Call1(last_class, recv, caller, null, args[i]));
return Array.CreateUsing(result);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
System.Collections.ArrayList result = new System.Collections.ArrayList(args.Length);
for (int i = 0; i < args.Length; i++)
result.Add(rb_hash_aref.singleton.Call1(last_class, recv, caller, null, args[i]));
return Array.CreateUsing(result);
}
public override object Call0(Class last_class, object recv, Frame caller, Proc block)
{
ArrayList ary = ((Array)recv).value;
try
{
for (int i = 0; i < ary.Count; i++)
{
ArgList args = new ArgList(null, ary[i]);
args.single_arg = true;
Proc.rb_yield(block, caller, args);
}
}
catch (BreakException)
{
}
return recv;
}
public virtual object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
switch (args.Length)
{
case 0: return Call0(last_class, recv, caller, args.block);
case 1: return Call1(last_class, recv, caller, args.block, args[0]);
case 2: return Call2(last_class, recv, caller, args.block, args[0], args[1]);
case 3: return Call3(last_class, recv, caller, args.block, args[0], args[1], args[2]);
case 4: return Call4(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3]);
case 5: return Call5(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4]);
case 6: return Call6(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4], args[5]);
case 7: return Call7(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
case 8: return Call8(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
case 9: return Call9(last_class, recv, caller, args.block, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
default:
throw new System.Exception("wrong number of arguments");
}
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
if (args.Length == 1)
return Call1(last_class, recv, caller, args.block, args[0]);
else
throw new ArgumentError("wrong number of arguments (" + args.Length + " for 1)").raise(caller);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
char[] table = new char[256];
int s, send;
string sString;
bool init = true;
int i;
if (args.Length < 1)
{
throw new ArgumentError("wrong number of arguments").raise(caller);
}
for (i = 0; i < args.Length; i++)
{
string sValue;
sValue = String.StringValue(args[i], caller);
String.SetupTable(sValue, table, init);
init = false;
}
s = 0;
sString = ((String)recv).value;
if (sString == null || sString.Length == 0)
{
return 0;
}
send = s + sString.Length;
i = 0;
while (s < send)
{
if (table[(int)sString[s++]] > 0)
{
i++;
}
}
return i;
}
protected Array Remaining(ArgList args, int count)
{
object[] rest = new object[args.Length - count];
for (int i = 0; i < args.Length - count; i++)
rest[i] = args[i + count];
return new Array(rest);
}
//needs retesting
public override object Call1(Class last_class, object recv, Frame caller, Proc block, object arg)
{
if (arg is Array)
{
ArgList argv = new ArgList(block, new object[] { recv });
argv.AddRange((Array)arg);
return rb_f_sprintf.singleton.Calln(last_class, null, caller, argv);
}
return rb_f_sprintf.singleton.Call2(last_class, null, caller, block, recv, arg);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
if (args.Length < 3)
throw new ArgumentError("wrong number of arguments (" + args.Length + " for 3)").raise(caller);
return Call(last_class, recv, caller, args.block, args[0], args[1], args[2], Remaining(args, 3));
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
System.Text.RegularExpressions.CaptureCollection captures
= ((Match)recv).value.Captures;
Array result = new Array();
foreach (int index in args)
{
int i = (index < 0) ? captures.Count - index : index;
result.value.Add(new String(captures[i].Value));
}
return result;
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
Method bound = (Method)(Methods.umethod_bind.singleton.Call1(last_class, orig, caller, args.block, recv));
return bound.body.body.Calln(last_class, recv, caller, args);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
object idx, rest = null;
Array argv = args.ToRubyArray();
if (Class.rb_scan_args(caller, argv, 1, 1, false) == 2)
rest = args[1];
idx = args[0];
if (rest != null || !(idx is int) || ((int)idx) < 0)
{
return rb_ary_aref.singleton.Call(last_class, match_to_a.singleton.Call0(last_class, recv, caller, null), caller, null, argv);
}
return Regexp.rb_reg_nth_match((int)idx, (Match)recv);
}
public override object Calln(Class last_class, object recv, Frame caller, ArgList args)
{
return Calln(last_class, null, recv, caller, args);
}
public override object Calln(Class klass, object recv, Frame caller, ArgList args)
{
Eval.rb_secure(4, caller);
Array keys = (Array)env_keys.singleton.Call0(klass, recv, caller, null);
foreach (object key in keys)
{
object val = rb_f_getenv.singleton.Call1(klass, recv, caller, null, key);
if (val != null)
Env.env_delete(caller, val);
}
return recv;
}
public static object CallSuperA(Class klass, Frame caller, object recv, string methodId, ArgList args) {
Class origin;
RubyMethod method = FindSuperMethod(klass, caller, methodId, out origin);
if (method != null)
return method.body.Calln(origin, recv, caller, args);
else {
caller.call_status = CallStatus.Super;
return method_missing(recv, caller, methodId, args);
}
}
public override object Calln(Class klass, object recv, Frame caller, ArgList args)
{
return new String("ENV");
}
internal static object specific_eval(Class last_class, object self, Class ruby_class, Frame caller, Proc block, Array args) //author: Brian, status: partial
{
if (block != null) {
ArgList argList = new ArgList();
argList.AddArray(args, caller);
return block.yield_under(caller, argList, ruby_class, self);
} else {
string file = "eval";
int line = 1;
object scope = null;
object vfile = null;
object vline = null;
String src = null;
if (args.Count > 0) {
src = (String)(args[0]);
if (args.Count > 1) {
vfile = args[1];
file = ((String)vfile).value;
if (args.Count > 2) {
vline = args[2];
line = (int)vline;
}
}
}
scope = new Binding(caller, self);
if (!(scope is IContext))
throw new TypeError(string.Format(CultureInfo.InvariantCulture, "wrong argument type {0} (expected Proc/Binding)", scope.GetType())).raise(caller);
object ret = Eval.eval_under(ruby_class, self, (String)src, (IContext)scope, file, line, caller);
return ret;
}
}
public override object Calln(Class klass, object recv, Frame caller, ArgList args)
{
Array values = new Array();
foreach (string val in System.Environment.GetEnvironmentVariables().Values)
values.Add(Env.env_str_new2(caller, val));
return values;
}