Beispiel #1
0
        internal static List <ConstructorInfo> FilterConstructors(List <ConstructorInfo> ctors, Type i)
        {
            return(ctors.ToList().FindAll((CCtorInfo) =>
            {
                var exports = CCtorInfo.GetCustomAttributes(typeof(CSHotFixMonoTypeExportAttribute), true);
                if (exports != null && exports.Length > 0)
                {
                    var export = exports[0] as CSHotFixMonoTypeExportAttribute;
                    if (export.ExportFlag == CSHotFixMonoTypeExportFlagEnum.NoExport)
                    {
                        return false;
                    }
                }

                bool hr = CCtorInfo.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                          MethodBindingGenerator.IsConstructorPtrType(CCtorInfo) ||
                          GenConfigPlugins.SpecialBlackTypeList.Exists((_str) =>
                {
                    List <string> strpair = _str;
                    string _class = strpair[0];
                    string _name = strpair[1];
                    if (i.FullName.Contains(_class))
                    {
                        return CCtorInfo.Name.Contains(_name);
                    }
                    else
                    {
                        return false;
                    }
                });
                return !hr;
            }));
        }
Beispiel #2
0
        internal static List <FieldInfo> FilterFields(List <FieldInfo> fields, Type i)
        {
            return(fields.ToList().FindAll((field) =>
            {
                bool hr = field.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                          MethodBindingGenerator.IsFieldPtrType(field) ||
                          GenConfigPlugins.SpecialBlackTypeList.Exists((_str) =>
                {
                    List <string> strpair = _str;
                    string _class = strpair[0];
                    string _name = strpair[1];
                    if (i.FullName.Contains(_class))
                    {
                        return field.Name.Contains(_name);
                    }
                    else
                    {
                        return false;
                    }
                });

                return !hr;
            }));
        }
Beispiel #3
0
        public static void GenerateBindingCode(List <Type> types, string outputPath,
                                               HashSet <MethodBase> excludeMethods = null, HashSet <FieldInfo> excludeFields = null,
                                               List <Type> valueTypeBinders        = null, List <Type> delegateTypes = null)
        {
            m_IsGenerateDll = false;
            if (!System.IO.Directory.Exists(outputPath))
            {
                System.IO.Directory.CreateDirectory(outputPath);
            }
            string[] oldFiles = System.IO.Directory.GetFiles(outputPath, "*.cs");
            foreach (var i in oldFiles)
            {
                System.IO.File.Delete(i);
            }

            List <string> clsNames = new List <string>();

            foreach (var i in types)
            {
                string clsName, realClsName;
                bool   isByRef;
                if (i.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0)
                {
                    continue;
                }
                i.GetClassName(out clsName, out realClsName, out isByRef);
                clsNames.Add(clsName);

                using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputPath + "/" + clsName + ".cs", false, new UTF8Encoding(false)))
                {
                    StringBuilder sb = new StringBuilder();
                    sb.Append(@"
#if CSHotFix
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;

using CSHotFix.CLR.TypeSystem;
using CSHotFix.CLR.Method;
using CSHotFix.Runtime.Enviorment;
using CSHotFix.Runtime.Intepreter;
using CSHotFix.Runtime.Stack;
using CSHotFix.Reflection;
using CSHotFix.CLR.Utils;
using System.Linq;
namespace CSHotFix.Runtime.Generated
{
    unsafe class ");
                    sb.AppendLine(clsName);
                    sb.Append(@"    {
        public static void Register(CSHotFix.Runtime.Enviorment.AppDomain app)
        {
");
                    string flagDef    = "            BindingFlags flag = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;";
                    string methodDef  = "            MethodBase method;";
                    string methodsDef = "            MethodInfo[] methods = type.GetMethods(flag).Where(t => !t.IsGenericMethod).ToArray();";
                    string fieldDef   = "            FieldInfo field;";
                    string argsDef    = "            Type[] args;";
                    string typeDef    = string.Format("            Type type = typeof({0});", realClsName);

                    bool         needMethods;
                    MethodInfo[] methods = i.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    //过滤
                    methods = methods.ToList().FindAll((methodInfo) =>
                    {
                        bool hr = methodInfo.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                                  MethodBindingGenerator.IsMethodPtrType(methodInfo) ||
                                  GenConfigPlugins.SpecialBlackTypeList.Exists((_str) =>
                        {
                            List <string> strpair = _str;
                            string _class         = strpair[0];
                            string _name          = strpair[1];
                            if (i.FullName.Contains(_class))
                            {
                                return(methodInfo.Name.Contains(_name));
                            }
                            else
                            {
                                return(false);
                            }
                        });
                        return(!hr);
                    }).ToArray();
                    FieldInfo[] fields = i.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    fields = fields.ToList().FindAll((field) =>
                    {
                        bool hr = field.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                                  GenConfigPlugins.SpecialBlackTypeList.Exists((_str) =>
                        {
                            List <string> strpair = _str;
                            string _class         = strpair[0];
                            string _name          = strpair[1];
                            if (i.FullName.Contains(_class))
                            {
                                return(field.Name.Contains(_name));
                            }
                            else
                            {
                                return(false);
                            }
                        });

                        return(!hr);
                    }).ToArray();
                    string            registerMethodCode    = i.GenerateMethodRegisterCode(methods, excludeMethods, out needMethods);
                    string            registerFieldCode     = i.GenerateFieldRegisterCode(fields, excludeFields);
                    string            registerValueTypeCode = i.GenerateValueTypeRegisterCode(realClsName);
                    string            registerMiscCode      = i.GenerateMiscRegisterCode(realClsName, true, true);
                    string            commonCode            = i.GenerateCommonCode(realClsName);
                    ConstructorInfo[] ctors            = i.GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    string            ctorRegisterCode = i.GenerateConstructorRegisterCode(ctors, excludeMethods);
                    string            methodWraperCode = i.GenerateMethodWraperCode(methods, realClsName, excludeMethods, valueTypeBinders, null);
                    string            fieldWraperCode  = i.GenerateFieldWraperCode(fields, realClsName, excludeFields);
                    string            cloneWraperCode  = i.GenerateCloneWraperCode(fields, realClsName);
                    string            ctorWraperCode   = i.GenerateConstructorWraperCode(ctors, realClsName, excludeMethods, valueTypeBinders);

                    bool hasMethodCode    = !string.IsNullOrEmpty(registerMethodCode);
                    bool hasFieldCode     = !string.IsNullOrEmpty(registerFieldCode);
                    bool hasValueTypeCode = !string.IsNullOrEmpty(registerValueTypeCode);
                    bool hasMiscCode      = !string.IsNullOrEmpty(registerMiscCode);
                    bool hasCtorCode      = !string.IsNullOrEmpty(ctorRegisterCode);
                    bool hasNormalMethod  = methods.Where(x => !x.IsGenericMethod).Count() != 0;

                    if ((hasMethodCode && hasNormalMethod) || hasFieldCode || hasCtorCode)
                    {
                        sb.AppendLine(flagDef);
                    }
                    if (hasMethodCode || hasCtorCode)
                    {
                        sb.AppendLine(methodDef);
                    }
                    if (hasFieldCode)
                    {
                        sb.AppendLine(fieldDef);
                    }
                    if (hasMethodCode || hasFieldCode || hasCtorCode)
                    {
                        sb.AppendLine(argsDef);
                    }
                    if (hasMethodCode || hasFieldCode || hasValueTypeCode || hasMiscCode || hasCtorCode)
                    {
                        sb.AppendLine(typeDef);
                    }
                    if (needMethods)
                    {
                        sb.AppendLine(methodsDef);
                    }


                    sb.AppendLine(registerMethodCode);
                    sb.AppendLine(registerFieldCode);
                    sb.AppendLine(registerValueTypeCode);
                    sb.AppendLine(registerMiscCode);
                    sb.AppendLine(ctorRegisterCode);
                    sb.AppendLine("        }");
                    sb.AppendLine();
                    sb.AppendLine(commonCode);
                    sb.AppendLine(methodWraperCode);
                    sb.AppendLine(fieldWraperCode);
                    sb.AppendLine(cloneWraperCode);
                    sb.AppendLine(ctorWraperCode);
                    sb.AppendLine("    }");
                    sb.AppendLine("}");
                    sb.AppendLine("#endif");
                    sw.Write(Regex.Replace(sb.ToString(), "(?<!\r)\n", "\r\n"));
                    sw.Flush();
                }
            }

            var delegateClsNames = GenerateDelegateBinding(delegateTypes, outputPath);

            clsNames.AddRange(delegateClsNames);

            GenerateBindingInitializeScript(clsNames, valueTypeBinders, outputPath, "CLRBindings");
        }
Beispiel #4
0
        public static void GenerateBindingCode(List <Type> types, string outputPath, bool deleteOld = true, HashSet <MethodBase> excludeMethods = null, HashSet <FieldInfo> excludeFields = null)
        {
            if (!System.IO.Directory.Exists(outputPath))
            {
                System.IO.Directory.CreateDirectory(outputPath);
            }
            if (deleteOld)
            {
                string[] oldFiles = System.IO.Directory.GetFiles(outputPath, "*.cs");
                foreach (var i in oldFiles)
                {
                    System.IO.File.Delete(i);
                }
            }
            List <string> clsNames = new List <string>();

            foreach (var i in types)
            {
                string clsName, realClsName;
                bool   isByRef;
                if (i.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0)
                {
                    continue;
                }
                i.GetClassName(out clsName, out realClsName, out isByRef);
                clsNames.Add(clsName);
                using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputPath + "/" + clsName + ".cs", false, Encoding.UTF8))
                {
                    sw.Write(@"
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;

using CSHotFix.CLR.TypeSystem;
using CSHotFix.CLR.Method;
using CSHotFix.Runtime.Enviorment;
using CSHotFix.Runtime.Intepreter;
using CSHotFix.Runtime.Stack;
using CSHotFix.Reflection;
using CSHotFix.CLR.Utils;

namespace CSHotFix.Runtime.Generated
{
    unsafe class ");
                    sw.WriteLine(clsName);
                    sw.Write(@"    {
        public static void Register(CSHotFix.Runtime.Enviorment.AppDomain app)
        {
            BindingFlags flag = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
            MethodBase method;
            FieldInfo field;
            Type[] args;
            Type type = typeof(");
                    sw.Write(realClsName);
                    sw.WriteLine(");");
                    MethodInfo[] methods = i.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    //过滤
                    methods = methods.ToList().FindAll((methodInfo) =>
                    {
                        bool hr = methodInfo.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                                  MethodBindingGenerator.IsMethodPtrType(methodInfo) ||
                                  GenConfig.SpecialBlackTypeList.Exists((_str) =>
                        {
                            List <string> strpair = _str;
                            string _class         = strpair[0];
                            string _name          = strpair[1];
                            if (i.FullName.Contains(_class))
                            {
                                return(methodInfo.Name.Contains(_name));
                            }
                            else
                            {
                                return(false);
                            }
                        });
                        return(!hr);
                    }).ToArray();
                    FieldInfo[] fields = i.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    fields = fields.ToList().FindAll((field) =>
                    {
                        bool hr = field.GetCustomAttributes(typeof(ObsoleteAttribute), true).Length > 0 ||
                                  GenConfig.SpecialBlackTypeList.Exists((_str) =>
                        {
                            List <string> strpair = _str;
                            string _class         = strpair[0];
                            string _name          = strpair[1];
                            if (i.FullName.Contains(_class))
                            {
                                return(field.Name.Contains(_name));
                            }
                            else
                            {
                                return(false);
                            }
                        });

                        return(!hr);
                    }).ToArray();
                    string            registerMethodCode    = i.GenerateMethodRegisterCode(methods, excludeMethods);
                    string            registerFieldCode     = i.GenerateFieldRegisterCode(fields, excludeFields);
                    string            registerValueTypeCode = i.GenerateValueTypeRegisterCode(realClsName);
                    string            registerMiscCode      = i.GenerateMiscRegisterCode(realClsName, true, true);
                    string            commonCode            = i.GenerateCommonCode(realClsName);
                    ConstructorInfo[] ctors            = i.GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                    string            ctorRegisterCode = i.GenerateConstructorRegisterCode(ctors, excludeMethods);
                    string            methodWraperCode = i.GenerateMethodWraperCode(methods, realClsName, excludeMethods);
                    string            fieldWraperCode  = i.GenerateFieldWraperCode(fields, realClsName, excludeFields);
                    string            cloneWraperCode  = i.GenerateCloneWraperCode(fields, realClsName);
                    string            ctorWraperCode   = i.GenerateConstructorWraperCode(ctors, realClsName, excludeMethods);
                    sw.WriteLine(registerMethodCode);
                    sw.WriteLine(registerFieldCode);
                    sw.WriteLine(registerValueTypeCode);
                    sw.WriteLine(registerMiscCode);
                    sw.WriteLine(ctorRegisterCode);
                    sw.WriteLine("        }");
                    sw.WriteLine();
                    sw.WriteLine(commonCode);
                    sw.WriteLine(methodWraperCode);
                    sw.WriteLine(fieldWraperCode);
                    sw.WriteLine(cloneWraperCode);
                    sw.WriteLine(ctorWraperCode);
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                    sw.Flush();
                }
            }

            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputPath + "/CLRBindings.cs", false, Encoding.UTF8))
            {
                sw.WriteLine(@"using System;
using System.Collections.Generic;
using System.Reflection;

namespace CSHotFix.Runtime.Generated
{
    class CLRBindings
    {
        /// <summary>
        /// Initialize the CLR binding, please invoke this AFTER CLR Redirection registration
        /// </summary>
        public static void Initialize(CSHotFix.Runtime.Enviorment.AppDomain app)
        {");
                foreach (var i in clsNames)
                {
                    sw.Write("            ");
                    sw.Write(i);
                    sw.WriteLine(".Register(app);");
                }

                sw.WriteLine(@"        }
    }
}");
            }
        }