Пример #1
0
        public static MethodDefinition CreateMethod(ModuleDefinition module,
                                                    TypeDefinition type,
                                                    string methodName,
                                                    MethodAttributes attributes,
                                                    TypeReference returnType,
                                                    bool isEmpty = false)
        {
            MethodDefinition method = ResolveHelper.ResolveMethod(type, methodName);

            if (method == null)
            {
                method = new MethodDefinition(methodName, attributes, returnType);
                method.Body.InitLocals = true;
                type.Methods.Add(method);
            }

            method.Parameters.Clear();
            method.Body.Variables.Clear();
            method.Body.Instructions.Clear();

            if (!isEmpty)
            {
                ILProcessor processor = method.Body.GetILProcessor();
                processor.Append(processor.Create(OpCodes.Nop));
                processor.Append(processor.Create(OpCodes.Ret));
            }

            return(method);
        }
Пример #2
0
        private static void AppendOpInequalityInstruction(ModuleDefinition module, ILProcessor processor, FieldDefinition field, FieldDefinition dirty, int offset)
        {
            Instruction end = processor.Create(OpCodes.Ret);

            processor.Append(processor.Create(OpCodes.Nop));
            processor.Append(processor.Create(OpCodes.Ldarg_0));
            processor.Append(processor.Create(OpCodes.Ldfld, field));
            processor.Append(processor.Create(OpCodes.Ldarg_1));
            processor.Append(processor.Create(OpCodes.Call, module.ImportReference(ResolveHelper.ResolveMethod(field.FieldType, "op_Inequality"))));
            processor.Append(processor.Create(OpCodes.Stloc_0));
            processor.Append(processor.Create(OpCodes.Ldloc_0));
            processor.Append(processor.Create(OpCodes.Brfalse_S, end));
            processor.Append(processor.Create(OpCodes.Nop));
            processor.Append(processor.Create(OpCodes.Ldarg_0));
            processor.Append(processor.Create(OpCodes.Ldarg_1));
            processor.Append(processor.Create(OpCodes.Stfld, field));
            processor.Append(processor.Create(OpCodes.Ldarg_0));
            processor.Append(processor.Create(OpCodes.Ldarg_0));
            processor.Append(processor.Create(OpCodes.Ldfld, dirty));
            processor.Append(processor.Create(OpCodes.Ldc_I8, 1L << offset));
            processor.Append(processor.Create(OpCodes.Or));
            processor.Append(processor.Create(OpCodes.Stfld, dirty));
            processor.Append(processor.Create(OpCodes.Nop));
            processor.Append(end);
        }
Пример #3
0
        private static void SetupBaseModuleTypes()
        {
            ChannelMessageType         = BaseAssembly.MainModule.GetType("Nice.Game.Base.ChannelMessage");
            ChannelMessageBufferField  = ResolveHelper.ResolveField(ChannelMessageType, "Buffer");
            ByteBufferType             = BaseAssembly.MainModule.GetType("Nice.Game.Base.ByteBuffer");
            ByteBufferAllocateMethod   = ResolveHelper.ResolveMethod(ByteBufferType, "Allocate");
            ByteUtilsType              = BaseAssembly.MainModule.GetType("Nice.Game.Base.ByteUtils");
            ByteUtilsReadMethod        = ResolveHelper.ResolveMethod(ByteUtilsType, "Read");
            ByteUtilsWriteMethod       = ResolveHelper.ResolveMethod(ByteUtilsType, "Write");
            ByteBufferUtilsType        = BaseAssembly.MainModule.GetType("Nice.Game.Base.ByteBufferUtils");
            ByteBufferUtilsReadMethod  = ResolveHelper.ResolveMethod(ByteBufferUtilsType, "Read");
            ByteBufferUtilsWriteMethod = ResolveHelper.ResolveMethod(ByteBufferUtilsType, "Write");

            SendType      = BaseAssembly.MainModule.GetType("Nice.Game.Base.SendAttribute");
            RecvType      = BaseAssembly.MainModule.GetType("Nice.Game.Base.RecvAttribute");
            ProtocolType  = BaseAssembly.MainModule.GetType("Nice.Game.Base.AutoProtocolAttribute");
            BroadcastType = BaseAssembly.MainModule.GetType("Nice.Game.Base.BroadcastAttribute");
            SyncClassType = BaseAssembly.MainModule.GetType("Nice.Game.Base.SyncClassAttribute");
            SyncFieldType = BaseAssembly.MainModule.GetType("Nice.Game.Base.SyncFieldAttribute");

            AbsCopType            = BaseAssembly.MainModule.GetType("Nice.Game.Base.AbsCop");
            AbsCopOnRemoveMethod  = ResolveHelper.ResolveMethod(AbsCopType, "OnRemove");
            AbsCopGetEntityMethod = ResolveHelper.ResolveMethod(AbsCopType, "get_Entity");

            IConnectionType = BaseAssembly.MainModule.GetType("Nice.Game.Base.IConnection");
            IConnectionRegisterHandlerMethod   = ResolveHelper.ResolveMethod(IConnectionType, "RegisterHandler");
            IConnectionUnregisterHandlerMethod = ResolveHelper.ResolveMethod(IConnectionType, "UnRegisterHandler");

            NetworkClientManagerType       = BaseAssembly.MainModule.GetType("Nice.Game.Base.NetworkClientManager");
            NetworkClientManagerSendMethod = ResolveHelper.ResolveMethod(NetworkClientManagerType, "Send");

            NetworkServerManagerType            = BaseAssembly.MainModule.GetType("Nice.Game.Base.NetworkServerManager");
            NetworkServerManagerSendMethod      = ResolveHelper.ResolveMethod(NetworkServerManagerType, "Send");
            NetworkServerManagerBroadcastMethod = ResolveHelper.ResolveMethod(NetworkServerManagerType, "Broadcast");
        }
Пример #4
0
        public static FieldDefinition CreateField(ModuleDefinition module, TypeDefinition type, string fieldName, FieldAttributes attributes, TypeReference fieldType)
        {
            FieldDefinition field = ResolveHelper.ResolveField(type, fieldName);

            if (field == null)
            {
                field = new FieldDefinition(fieldName, attributes, fieldType);
                type.Fields.Add(field);
            }
            return(field);
        }
Пример #5
0
        private static void ModifyIsDirtyMethod(ModuleDefinition module, TypeDefinition type, FieldDefinition dirty)
        {
            MethodDefinition method = ResolveHelper.ResolveMethod(type, "IsDirty");

            method.Body.Variables.Clear();
            method.Body.Instructions.Clear();

            method.Body.Variables.Add(new VariableDefinition(module.ImportReference(typeof(bool))));

            ILProcessor processor = method.Body.GetILProcessor();
            Instruction ins       = processor.Create(OpCodes.Ldloc_0);

            processor.Append(processor.Create(OpCodes.Nop));
            processor.Append(processor.Create(OpCodes.Ldarg_0));
            processor.Append(processor.Create(OpCodes.Ldfld, dirty));
            processor.Append(processor.Create(OpCodes.Ldc_I8, 0L));
            processor.Append(processor.Create(OpCodes.Cgt));
            processor.Append(processor.Create(OpCodes.Stloc_0));
            processor.Append(processor.Create(OpCodes.Br_S, ins));
            processor.Append(ins);
            processor.Append(processor.Create(OpCodes.Ret));
        }
Пример #6
0
        public static void Weave(ModuleDefinition module, Dictionary <ushort, MethodDefinition> methods, TypeDefinition protocol)
        {
            if (module == null || methods.Count == 0 || protocol == null)
            {
                return;
            }

            FieldReference connectionField = module.ImportReference(ResolveHelper.ResolveField(protocol.BaseType, "m_Connection"));
            {
                //public void Register();
                MethodDefinition registerMethod = ResolveHelper.ResolveMethod(protocol, "Register");
                registerMethod.Body.Variables.Clear();
                registerMethod.Body.Instructions.Clear();

                ILProcessor registerProcessor = registerMethod.Body.GetILProcessor();
                registerProcessor.Append(registerProcessor.Create(OpCodes.Nop));

                foreach (ushort msgId in methods.Keys)
                {
                    MethodDefinition method = methods[msgId];

                    if (!CheckHelper.CheckMethodParams(WeaverProgram.Client, method))
                    {
                        continue;
                    }

                    MethodDefinition protoMethodImpl = MethodFactory.CreateMethod(module, protocol, "OnProtocol_" + msgId, MethodAttributes.Private | MethodAttributes.HideBySig, true);
                    protoMethodImpl.Parameters.Add(new ParameterDefinition("msg", ParameterAttributes.None, module.ImportReference(WeaverProgram.ChannelMessageType)));
                    protoMethodImpl.Body.Variables.Add(new VariableDefinition(module.ImportReference(WeaverProgram.ByteBufferType)));

                    {
                        ILProcessor processor = protoMethodImpl.Body.GetILProcessor();
                        processor.Append(processor.Create(OpCodes.Nop));
                        processor.Append(processor.Create(OpCodes.Ldarg_1));
                        processor.Append(processor.Create(OpCodes.Ldfld, module.ImportReference(WeaverProgram.ChannelMessageBufferField)));
                        processor.Append(processor.Create(OpCodes.Stloc_0));

                        List <int> indexs = new List <int>();
                        Collection <ParameterDefinition> parms = method.Parameters;
                        for (int i = 0; i < parms.Count; ++i)
                        {
                            ParameterDefinition parm     = parms[i];
                            TypeDefinition      parmType = parm.ParameterType.Resolve();
                            protoMethodImpl.Body.Variables.Add(new VariableDefinition(module.ImportReference(parm.ParameterType)));
                            int index = protoMethodImpl.Body.Variables.Count - 1;
                            indexs.Add(index);

                            if (parm.ParameterType.FullName == typeof(byte[]).FullName)
                            {
                                processor.Append(processor.Create(OpCodes.Ldloc_0));
                                processor.Append(processor.Create(OpCodes.Call, module.ImportReference(WeaverProgram.ByteUtilsReadMethod)));
                                processor.Append(processor.Create(OpCodes.Stloc, index));
                                continue;
                            }

                            if (parm.ParameterType.FullName == typeof(ByteBuffer).FullName)
                            {
                                processor.Append(processor.Create(OpCodes.Ldloc_0));
                                processor.Append(processor.Create(OpCodes.Call, module.ImportReference(WeaverProgram.ByteBufferUtilsReadMethod)));
                                processor.Append(processor.Create(OpCodes.Stloc, index));
                                continue;
                            }

                            if (parm.ParameterType.IsArray)
                            {
                                ArrayReadFactory.CreateMethodVariableReadInstruction(module, protoMethodImpl, processor, parmType);
                                continue;
                            }

                            if (BaseTypeFactory.IsBaseType(parmType))
                            {
                                processor.Append(processor.Create(OpCodes.Ldloc_0));
                                processor.Append(BaseTypeFactory.CreateReadInstruction(module, processor, parmType));
                                processor.Append(processor.Create(OpCodes.Stloc, index));
                                continue;
                            }

                            if (parmType.IsValueType)
                            {
                                MethodDefinition deserialize = StructMethodFactory.CreateDeserialize(module, parmType);
                                processor.Append(processor.Create(OpCodes.Ldloca, index));
                                processor.Append(processor.Create(OpCodes.Initobj, module.ImportReference(parmType)));
                                processor.Append(processor.Create(OpCodes.Ldloca, index));
                                processor.Append(processor.Create(OpCodes.Ldloc_0));
                                processor.Append(processor.Create(OpCodes.Call, module.ImportReference(deserialize)));
                            }
                        }

                        for (int i = 0; i < indexs.Count; ++i)
                        {
                            processor.Append(processor.Create(OpCodes.Ldloc, indexs[i]));
                        }

                        processor.Append(processor.Create(OpCodes.Call, method));
                        processor.Append(processor.Create(OpCodes.Nop));
                        processor.Append(processor.Create(OpCodes.Ret));
                    }

                    registerProcessor.Append(registerProcessor.Create(OpCodes.Ldarg_0));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Ldfld, connectionField));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Ldc_I4, msgId));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Ldarg_0));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Ldftn, protoMethodImpl));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Newobj, module.ImportReference(typeof(ChannelMessageDelegate).GetConstructor(new Type[] { typeof(object), typeof(IntPtr) }))));
                    registerProcessor.Append(registerProcessor.Create(OpCodes.Callvirt, module.ImportReference(WeaverProgram.IConnectionRegisterHandlerMethod)));
                }
                registerProcessor.Append(registerProcessor.Create(OpCodes.Ret));
            }

            {
                //public void Unregister();
                MethodDefinition unregisterMethod = ResolveHelper.ResolveMethod(protocol, "UnRegister");
                unregisterMethod.Body.Variables.Clear();
                unregisterMethod.Body.Instructions.Clear();

                ILProcessor unregisterProcessor = unregisterMethod.Body.GetILProcessor();
                unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Nop));
                foreach (ushort key in methods.Keys)
                {
                    unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldarg_0));
                    unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldfld, connectionField));
                    unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldc_I4, key));
                    unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Callvirt, module.ImportReference(WeaverProgram.IConnectionUnregisterHandlerMethod)));
                }
                unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ret));
            }
        }
Пример #7
0
 public static MethodReference FindSerialize(ModuleDefinition module, TypeDefinition type)
 {
     return(module.ImportReference(ResolveHelper.ResolveMethod(type, "Serialize")));
 }
Пример #8
0
        public static void Weave(ModuleDefinition module, List <TypeDefinition> syncs, out Dictionary <FieldDefinition, MethodDefinition> gets, out Dictionary <FieldDefinition, MethodDefinition> sets)
        {
            sets = new Dictionary <FieldDefinition, MethodDefinition>();
            gets = new Dictionary <FieldDefinition, MethodDefinition>();

            foreach (TypeDefinition type in syncs)
            {
                List <FieldDefinition> fields = new List <FieldDefinition>();

                foreach (FieldDefinition field in type.Fields)
                {
                    if (field.CustomAttributes.Count > 0 && field.CustomAttributes[0].AttributeType.FullName == WeaverProgram.SyncFieldType.FullName)
                    {
                        fields.Add(field);
                    }
                }

                if (fields.Count == 0)
                {
                    return;
                }

                FieldDefinition dirty = FieldFactory.CreateField(module, type, "m_Dirty", FieldAttributes.Private, module.ImportReference(typeof(long)));

                //public bool IsDirty();
                ModifyIsDirtyMethod(module, type, dirty);

                //get set method
                for (int i = 0; i < fields.Count; ++i)
                {
                    FieldDefinition field = fields[i];

                    if (!CheckHelper.CheckSyncFiled(WeaverProgram.Server, type, field.FieldType.Resolve()))
                    {
                        continue;
                    }

                    string           name = field.Name;
                    MethodDefinition get  = CreateGetMethod(module, type, field, name);
                    MethodDefinition set  = CreateSetMethod(module, type, field, name, dirty, i);

                    PropertyDefinition propertyDefinition = new PropertyDefinition("Sync" + name, PropertyAttributes.None, field.FieldType)
                    {
                        GetMethod = get,
                        SetMethod = set
                    };

                    type.Properties.Add(propertyDefinition);

                    gets.Add(field, get);
                    sets.Add(field, set);
                }

                //Serialize
                MethodDefinition serialize = ResolveHelper.ResolveMethod(type, "Serialize");

                ILProcessor processor = serialize.Body.GetILProcessor();
                processor.Body.Instructions.Clear();

                Instruction ins1 = processor.Create(OpCodes.Nop);
                Instruction ins2 = processor.Create(OpCodes.Ldarg_0);
                Instruction ins3 = processor.Create(OpCodes.Ldc_I8, 0L);
                Instruction ins4 = processor.Create(OpCodes.Stfld, dirty);
                Instruction ins5 = processor.Create(OpCodes.Nop);
                Instruction ins6 = processor.Create(OpCodes.Ret);

                processor.Append(processor.Create(OpCodes.Nop));
                processor.Append(processor.Create(OpCodes.Ldarg_0));
                processor.Append(processor.Create(OpCodes.Ldfld, dirty));
                processor.Append(processor.Create(OpCodes.Ldc_I8, 0L));
                processor.Append(processor.Create(OpCodes.Cgt));
                processor.Append(processor.Create(OpCodes.Stloc_0));
                processor.Append(processor.Create(OpCodes.Ldloc_0));
                processor.Append(processor.Create(OpCodes.Brfalse, ins6));
                processor.Append(processor.Create(OpCodes.Nop));
                processor.Append(processor.Create(OpCodes.Ldarg_1));
                processor.Append(processor.Create(OpCodes.Ldarg_0));
                processor.Append(processor.Create(OpCodes.Ldfld, dirty));
                processor.Append(BaseTypeFactory.CreateWriteInstruction(module, processor, dirty.FieldType.Resolve()));

                serialize.Body.Variables.Add(new VariableDefinition(module.ImportReference(typeof(bool))));

                int offset = serialize.Body.Variables.Count;

                for (int i = 0; i < fields.Count; ++i)
                {
                    WriteSerializeInstruction(module, serialize, processor, fields[i], dirty, i, offset);
                }

                processor.Append(ins1);
                processor.Append(ins2);
                processor.Append(ins3);
                processor.Append(ins4);
                processor.Append(ins5);
                processor.Append(ins6);
            }
        }
Пример #9
0
        public static void Weave(ModuleDefinition module, List <TypeDefinition> syncs)
        {
            if (module == null || syncs.Count == 0)
            {
                return;
            }

            foreach (TypeDefinition type in syncs)
            {
                List <FieldDefinition> fields = new List <FieldDefinition>();

                foreach (FieldDefinition field in type.Fields)
                {
                    if (field.CustomAttributes.Count > 0 && field.CustomAttributes[0].AttributeType.FullName == WeaverProgram.SyncFieldType.FullName)
                    {
                        fields.Add(field);
                    }
                }

                if (fields.Count == 0)
                {
                    return;
                }

                //Deserialize
                MethodDefinition deserialize = ResolveHelper.ResolveMethod(type, "Deserialize");

                ILProcessor processor = deserialize.Body.GetILProcessor();
                processor.Body.Instructions.Clear();

                Instruction ret = processor.Create(OpCodes.Ret);
                processor.Append(processor.Create(OpCodes.Nop));
                processor.Append(processor.Create(OpCodes.Ldarg_1));
                processor.Append(BaseTypeFactory.CreateReadInstruction(module, processor, typeof(long).ToString()));
                processor.Append(processor.Create(OpCodes.Stloc_0));
                processor.Append(processor.Create(OpCodes.Ldloc_0));
                processor.Append(processor.Create(OpCodes.Ldc_I8, 0L));
                processor.Append(processor.Create(OpCodes.Cgt));
                processor.Append(processor.Create(OpCodes.Stloc_1));
                processor.Append(processor.Create(OpCodes.Ldloc_1));
                processor.Append(processor.Create(OpCodes.Brfalse, ret));

                deserialize.Body.Variables.Add(new VariableDefinition(module.ImportReference(typeof(long))));
                deserialize.Body.Variables.Add(new VariableDefinition(module.ImportReference(typeof(bool))));

                int offset = deserialize.Body.Variables.Count;

                for (int i = 0; i < fields.Count; ++i)
                {
                    FieldDefinition field = fields[i];

                    if (!CheckHelper.CheckSyncFiled(WeaverProgram.Client, type, field.FieldType.Resolve()))
                    {
                        continue;
                    }

                    WriteDeserializeInstruction(module, deserialize, processor, field, i, offset);
                }

                processor.Append(processor.Create(OpCodes.Nop));
                processor.Append(ret);
            }
        }