netruby/netruby/frmobj.cs

/*
 Copyright(C) 2001-2002 arton

 Permission is granted for use, copying, modification, distribution,
 and distribution of modified versions of this work as long as the
 above copyright notice is included.
*/

using System;
using System.Diagnostics;
using System.Collections;
using System.IO;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Security;

namespace arton.NETRuby
{
    public class RFrmworkObject : RObject
    {
        internal RFrmworkObject(NetRuby rb, RMetaObject spr, object o) :
            base(rb, spr)
        {
            obj = o;
        }

        public object GetOriginal()
        {
            return obj;
        }

        public override string ToString()
        {
            return obj.ToString();
        }
        
        public override object Missing(params object[] args)
        {
            ruby.CheckMissingParam(args);
            uint id = Symbol.SYM2ID((uint)args[0]);
            string func = ruby.id2name(id);
            if (func == "each")
            {
                return Each(args);
            }
            string cname = func;
            if (func == "[]")
            {
                cname = "get_Item";
            }
            else if (func == "[]=")
            {
                cname = "set_Item";
            }
            else if (func[func.Length - 1] == '=')
            {
                cname = "set_" + func.Substring(0, func.Length - 1);
            }
            Type[] param;
            object[] argv = RFrmworkClass.adjustCLS(1, args, out param);
            MethodInfo mtd = obj.GetType().GetMethod(cname, param);
            if (mtd == null)
            {
                mtd = obj.GetType().GetMethod("get_" + func, param);
                if (mtd == null)
                {
                    throw new ArgumentException(
                        String.Format("undefined method `{0}' for {1}", func, klass.Name));
                }
            }
            object o = mtd.Invoke(obj, argv);
            return o;
        }
        object Each(object[] args)
        {
            try
            {
                IEnumerable e = (IEnumerable)obj;
                foreach (object o in e)
                {
                    ruby.Yield(o);
                }
            }
            catch
            {
                throw new ArgumentException(
                      String.Format("undefined method `each' for {1}", klass.Name));
            }
            return this;
        }
        
        object obj;
    }

    public class RFrmworkClass : RClass
    {
        internal RFrmworkClass(NetRuby rb, string name, RMetaObject super, Type tp) :
            base(rb, name, super)
        {
            metaClass = tp;
        }
        protected Type metaClass;
        
        public override RBasic NewInstance(object[] args)
        {
            Type[] param;
            object[] argv = adjustCLS(0, args, out param);
            ConstructorInfo ctr = metaClass.GetConstructor(param);
            if (ctr == null)
                throw new ArgumentException(String.Format("Invalid Argument for {0}::new", Name));
            object o = ctr.Invoke(argv);
            return new RFrmworkObject(ruby, this, o);
        }
        public RBasic WrapObject(object o)
        {
            return new RFrmworkObject(ruby, this, o);
        }

        public override RArray SingletonMethods
        {
            get {
                BindingFlags bf = BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy;
                return methodList(bf);
            }
        }
        public override RArray ClassInstanceMethods(object[] argv)
        {
            BindingFlags bf = BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance;
            if (argv.Length > 0 && RTest(argv[0]))
                bf |= BindingFlags.FlattenHierarchy;
            return methodList(bf);
        }
        public override RArray ClassProtectedInstanceMethods(object[] argv)
        {
            BindingFlags bf = BindingFlags.InvokeMethod | BindingFlags.Instance;
            if (argv.Length > 0 && RTest(argv[0]))
                bf |= BindingFlags.FlattenHierarchy;
            return methodList(bf);
        }
        public override RArray ClassPrivateInstanceMethods(object[] argv)
        {
            BindingFlags bf = BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance;
            if (argv.Length > 0 && RTest(argv[0]))
                bf |= BindingFlags.FlattenHierarchy;
            return methodList(bf);
        }
        RArray methodList(BindingFlags bf)
        {
            MethodInfo[] mis = metaClass.GetMethods(bf);
            RArray ra = new RArray(ruby, true);
            foreach (MethodInfo m in mis)
            {
                ra.Add(m.ToString());
            }
            return ra;
        }
        
        public override object Missing(params object[] args)
        {
            ruby.CheckMissingParam(args);
            uint id = Symbol.SYM2ID((uint)args[0]);
            string func = ruby.id2name(id);

            Type[] param;
            object[] argv = adjustCLS(1, args, out param);
            MethodInfo mtd = metaClass.GetMethod(func, param);
            if (mtd == null)
            {
                if (func[func.Length - 1] == '=')
                    mtd = metaClass.GetMethod("set_" + func.Substring(0, func.Length - 1), param);
                else
                    mtd = metaClass.GetMethod("get_" + func, param);
                if (mtd == null)
                    throw new ArgumentException(
                             String.Format("undefined method `{0}' for {1}", func, klass.Name));
            }
            object o = mtd.Invoke(null, argv); // static
            return o;
        }

        internal static object[] adjustCLS(int idx, object[] args, out Type[] tps)
        {
            tps = null;
            object[] argv = new object[args.Length - idx];
            tps = new Type[args.Length - idx];
            for (int ix = idx; ix < args.Length; ix++)
            {
                int i = ix - idx;
                object o = args[ix];
                if (o is string || o is RString)
                {
                    argv[i] = o.ToString();
                    tps[i] = typeof(string);
                }
                else if (o is RFixnum)
                {
                    argv[i] = ((RFixnum)o).ToInt();
                    tps[i] = typeof(int);
                }
                else if (o is RBignum)
                {
                    RBignum b = (RBignum)o;
                    try
                    {
                        argv[i] = b.ToLong();
                        tps[i] = typeof(long);
                    }
                    catch
                    {
                        argv[i] = b.Big2Dbl();
                        tps[i] = typeof(double);
                    }
                }
                else if (o is RFloat)
                {
                    argv[i] = ((RFloat)o).Double;
                    tps[i] = typeof(double);
                }
                else if (o is RBool)
                {
                    argv[i] = ((RBool)o).ToBool();
                    tps[i] = typeof(bool);
                }
                else if (o is RChar)
                {
                    argv[i] = ((RChar)o).Char;
                    tps[i] = typeof(char);
                }
                else if (o is RNil)
                {
                    argv[i] = null;
                    tps[i] = typeof(object);
                }
                else if (o is RArray)
                {
                    argv[i] = ((RArray)o).Array;
                    tps[i] = typeof(object[]);
                }
                else if (o is RFrmworkObject)
                {
                    argv[i] = ((RFrmworkObject)o).GetOriginal();
                    tps[i] = argv[i].GetType();
                }
                else if (o is RBasic)
                {
                    argv[i] = o;
                    tps[i] = typeof(object);
                }
                else
                {
                    tps[i] = o.GetType();
                    argv[i] = Convert.ChangeType(o, tps[i]);
                }
            }
            return argv;
        }
        internal object attach(RBasic r, params object[] args)
        {
            return ((RFrmworkClass)r).WrapObject(args[0]);
        }
    }

    public class RDotNetClass : RClass
    {
        private RDotNetClass(NetRuby rb) : 
            base(rb, "DotNet", rb.cObject)
        {
            ulist = new ArrayList();
            tlist = new Hashtable();
            alist = new ArrayList();
            ulist.Add("System");
        }

        ArrayList ulist;
        Hashtable tlist;
        ArrayList alist;
        public bool Using(string nmspace)
        {
            ruby.GetCurrentContext().Secure(3);
            
            bool load = false;
            if (ulist.Contains(nmspace) == false)
            {
                lock (ulist.SyncRoot)
                {
                    if (ulist.Contains(nmspace) == false)
                    {
                        ulist.Add(nmspace);
                        load = true;
                    }
                }
                if (load)
                {
                    AssemblyName asm;
                    nmspace += ".dll";
                    if (CheckAssembly(nmspace + ".dll", out asm) == false)
                    {
                        string fname = typeof(Object).Assembly.CodeBase.Replace("mscorlib.dll", nmspace);
                        fname = fname.Replace("file:///", "");
                        CheckAssembly(fname, out asm);
                    }
                    if (asm != null)
                    {
                        Assembly a = Assembly.Load(asm);
                        Type[] ts = a.GetTypes();
                        foreach (Type t in ts)
                        {
                            lock (tlist.SyncRoot)
                            {
                                tlist[t.ToString()] = t;
                            }
                        }
                        alist.Add(a);
                    }
                }
            }
            return load;
        }
        static bool CheckAssembly(string fname, out AssemblyName asm)
        {
            asm = null;
            try
            {
                asm = AssemblyName.GetAssemblyName(fname);
            }
            catch
            {
                return false;
            }
            return true;
        }

        public string[] UsingList
        {
            get {
                string[] list = (string[])ulist.ToArray(typeof(string));
                return list;
            }
        }
        public Type[] TypeList
        {
            get {
                Type[] list = (Type[])ulist.ToArray(typeof(Type));
                return list;
            }
        }
        internal RFrmworkClass AddFrameworkClass(Type tp)
        {
            string cname = tp.ToString().Replace('.', '_');
            uint cid = ruby.intern(cname);
            if (IsConstDefined(cid))
            {
                return (RFrmworkClass)ConstGet(cid);
            }
            ruby.warning("Implicitly create DotNet class `{0}'", cname);
            if (ruby.SafeLevel >= 3)
                throw new SecurityException("Insecure: can't add DotNet Class");
            return NewFrameworkClass(tp);
        }
        public RFrmworkClass NewFrameworkClass(object[] args)
        {
            if (args.Length < 1)
                throw new ArgumentException("wrong # of arguments(at least 1)");
            string typename = args[0].ToString();
            Type tp = null;
            StringBuilder sb = new StringBuilder(255);
            if (typename.IndexOf('.') >= 0)
            {
                if (tlist.ContainsKey(typename))
                    tp = (Type)tlist[typename];
                else
                {
                    tp = Type.GetType(typename);
                    if (tp != null)
                    {
                        lock (tlist.SyncRoot)
                        {
                            tlist[typename] = tp;
                        }
                    }
                }
                sb.Append(typename);
            }
            else
            {
                lock (ulist.SyncRoot)
                {
                    foreach (string s in ulist)
                    {
                        sb.Length = 0;
                        string sname = sb.AppendFormat("{0}.{1}", s, typename).ToString();
                        if (tlist.ContainsKey(sname))
                        {
                            tp = (Type)tlist[sname];
                            break;
                        }
                        tp = Type.GetType(sname);
                        if (tp != null)
                        {
                            lock (tlist.SyncRoot)
                            {
                                tlist[sname] = tp;
                            }
                            break;
                        }
                    }
                }
            }
            if (tp == null)
            {
                sb.Length = 0;
                throw new ArgumentException(sb.AppendFormat("type {0} not found", typename).ToString());
            }
            return NewFrameworkClass(tp);
        }

        public RFrmworkClass NewFrameworkClass(Type tp)
        {
            StringBuilder sb = new StringBuilder(tp.ToString());
            sb[0] = Char.ToUpper(sb[0]);
            string cname = sb.Replace('.', '_').ToString();
            uint id = ruby.intern(cname);
            if (IsConstDefinedAt(id))
            {
                return (RFrmworkClass)ConstGetAt(id);
            }
            RFrmworkClass frm = new RFrmworkClass(ruby, cname, ruby.cObject, tp);
            frm.DefineClass(cname, ruby.cObject);
            ConstSet(id, frm);
            frm.DefineSingletonMethod("attach", new RMethod(frm.attach), 1);
            foreach (FieldInfo finf in tp.GetFields())
            {
                if (finf.IsLiteral && finf.IsStatic)
                {
                    frm.ConstSet(ruby.intern(finf.Name), finf.GetValue(null));
                }
            }
            return frm;
        }
        internal static object dn_new(RBasic r, params object[] args)
        {
            RBasic o = ((RDotNetClass)r).NewFrameworkClass(args);
            return o;
        }
        internal static object dn_ulist(RBasic r, params object[] args)
        {
            RDotNetClass rd = (RDotNetClass)r;
            return new RArray(rd.ruby, rd.ulist, true);
        }
        internal static object dn_tlist(RBasic r, params object[] args)
        {
            RDotNetClass rd = (RDotNetClass)r;
            ArrayList arry = new ArrayList(rd.tlist.Count);
            lock (rd.tlist.SyncRoot)
            {
                foreach (DictionaryEntry ent in rd.tlist)
                {
                    arry.Add(ent.Key);
                }
            }
            return new RArray(rd.ruby, arry);
        }
        internal static object dn_using(RBasic r, params object[] args)
        {
            string s = args[0].ToString();
            return r.ruby.cDotNet.Using(s);
        }
        internal static void Init(NetRuby rb)
        {
            RDotNetClass dn = new RDotNetClass(rb);
            dn.DefineClass("DotNet", rb.cObject);
            rb.cDotNet = dn;
            dn.DefineSingletonMethod("new", new RMethod(dn_new), -1);
            dn.DefineSingletonMethod("using_list", new RMethod(dn_ulist), 0);
            dn.DefineSingletonMethod("type_list", new RMethod(dn_tlist), 0);
            dn.DefineSingletonMethod("using", new RMethod(dn_using), 1);
            rb.DefineGlobalFunction("using", new RMethod(dn_using), 1);
        }
    }
}