public FieldAssignmentReplacementBuilder(FieldReference field, IMetadataHost host, ExpressionStatement assignment, ReplacementRegistry registry)
{
this.field = field;
this.host = host;
this.assignment = assignment;
this.registry = registry;
}
public override void HandleEvent(object sender, EventArgs e)
{
TerminologyLogger.GetLogger().Info("Handling add instance event!");
var result = new FieldReference<string>(string.Empty);
var confim =
this.Engine.UiControl.MainWindow.PopupSingleLineInputDialog(TranslationManager.GetManager.Localize("Title", "Add a Instance"),
TranslationManager.GetManager.Localize("InstanceUrl", "Instance URL:"), result);
if (confim == null || confim.Value == false)
{
TerminologyLogger.GetLogger().Info("Empty input or user canceled. Ignore!");
return;
}
try
{
var message = this.Engine.InstanceManager.AddInstance(result.Value);
this.Engine.UiControl.MainWindow.InstanceList =
new ObservableCollection<InstanceEntity>(this.Engine.InstanceManager.InstancesWithLocalImageSource);
this.Engine.UiControl.MainWindow.PopupNotifyDialog("Successful", message);
}
catch (WebException ex)
{
TerminologyLogger.GetLogger()
.ErrorFormat($"Network is not accessable! Detail: {ex.Message}");
this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("NetworkNotAccessable", "Network is not accessable! Detail: {0}", 1), ex.Message));
}
catch (JsonReaderException ex)
{
TerminologyLogger.GetLogger()
.ErrorFormat($"Wrong instance json format! {ex.Message}");
this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("WrongJsonFormat", "Wrong instance json format! {0}", 1), ex.Message));
}
catch (MissingFieldException ex)
{
TerminologyLogger.GetLogger()
.ErrorFormat($"Critical field is missing! {ex.Message}");
this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("MissCriticalField", "Some critical field is missing. Unable to add this instance! Detail:{0}", 1), ex.Message));
}
catch (Exception ex)
{
TerminologyLogger.GetLogger()
.ErrorFormat($"Cannot add this instance because {ex}");
this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("UnknownError", "Caused by an error, we cannot add this instance right now. Detail: {0}", 1), ex.Message));
}
}
internal SingleSelectWindow(Window owner, string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection)
{
this.SelectItemValue = selection;
this.SelectItems = new ObservableCollection<string>();
this.InitializeComponent();
if (owner != null)
{
this.Owner = owner;
this.WindowStartupLocation = WindowStartupLocation.CenterOwner;
}
else
{
this.WindowStartupLocation = WindowStartupLocation.CenterScreen;
}
this.Title = title;
this.FieldName = fieldName;
this.SelectItems = new ObservableCollection<string>(options);
this.OnPropertyChanged();
}
public bool? PopupSingleLineInputDialog(string title, string fieldName, FieldReference<string> content)
{
throw new NotImplementedException();
}
/// <summary>
/// 为类型注入InitHotFix函数
/// </summary>
/// <param name="typeDefinition"></param>
private static void InjectInitHotFixFunc(TypeDefinition typeDefinition, FieldReference hotfixState, List <FieldDefinition> bridgeLuaFuncs)
{
string funcName = "InitHotFix";
foreach (var method in typeDefinition.Methods)
{
if (method.Name == funcName)
{
typeDefinition.Methods.Remove(method);
break;
}
}
MethodDefinition initHotFixMethod = new MethodDefinition(funcName, MethodAttributes.Static | MethodAttributes.Private, typeRef_bool);
initHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(initHotFixMethod);
initHotFixMethod.Parameters.Add(new ParameterDefinition("luaModule", ParameterAttributes.None, typeRef_LuaTable));
initHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(initHotFixMethod);
initHotFixMethod.Body.MaxStackSize = 4;
initHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool));
initHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool));
// 开始注入IL代码
var ilProcessor = initHotFixMethod.Body.GetILProcessor();
initHotFixMethod.Body.Instructions.Add(ilProcessor.Create(OpCodes.Ret));
var insertPoint = initHotFixMethod.Body.Instructions[0];
// 设置一些标签用于语句跳转
var label1 = ilProcessor.Create(OpCodes.Nop);
var label2 = ilProcessor.Create(OpCodes.Ldloc_0);
var label3 = ilProcessor.Create(OpCodes.Ldloc_1);
// if (luaModule == null)
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldnull));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_LuaVar_op_Equality));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label1));
//result = false; 将0压入局部变量索引零处
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label2));
//luaModule != null
ilProcessor.InsertBefore(insertPoint, label1); //OpCodes.Nop
//初始化方法对应的luaFunction变量
Type type = FindType(typeDefinition.FullName);
bool isUnityComponent = type.IsAssignableFrom(typeof(UnityEngine.Component));
foreach (var methodDef in typeDefinition.Methods)
{
//for example:
//m_Add_ThisInt32Int32_fix = (luaModule.get("Add_ThisInt32Int32", rawget: true) as LuaFunction);
if (!LuaInjectUtil.IsMethodNeedHotFix(methodDef, isUnityComponent))
{
continue;
}
var bridgeLuaFunc = bridgeLuaFuncs.Find((field) =>
{
return(field.Name == LuaInjectUtil.GetHotFixFunctionNameInCS(methodDef));
});
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldstr, LuaInjectUtil.GetHotFixFunctionNameInLua(methodDef)));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_1));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Callvirt, methodRef_LuaTable_get));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Isinst, typeRef_LuaFunction));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stsfld, bridgeLuaFunc));
}
////result = true; 将1压入局部变量索引零处
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_1));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, label2);//OpCodes.Ldloc_0
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_1));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label3));
ilProcessor.InsertBefore(insertPoint, label3);//OpCodes.Ldloc_1
typeDefinition.Methods.Add(initHotFixMethod);
}
public FieldReference Import(FieldReference field)
{
return m_helper == null ? field : m_helper.ImportFieldReference (field, this);
}
internal FieldSignatureConverter GetFieldRefSignature(
FieldReference moduleFieldReference
) {
uint signatureBlobOffset = this.PEFileReader.MemberRefTable.GetSignature(moduleFieldReference.MemberRefRowId);
// TODO: error checking offset in range
MemoryBlock signatureMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(signatureBlobOffset);
// TODO: Error checking enough space in signature memoryBlock.
MemoryReader memoryReader = new MemoryReader(signatureMemoryBlock);
// TODO: Check if this is really field signature there.
FieldSignatureConverter fieldSigConv = new FieldSignatureConverter(this, moduleFieldReference, memoryReader);
return fieldSigConv;
}
private void CompileFieldReference(Parser parser, ByteBuffer buffer, FieldReference fieldRef, bool outputUsed)
{
EnsureUsed(fieldRef.FirstToken, outputUsed);
if (fieldRef.Field.IsStaticField)
{
buffer.Add(
fieldRef.FirstToken,
OpCode.DEREF_STATIC_FIELD,
((ClassDefinition)fieldRef.Field.FunctionOrClassOwner).ClassID,
fieldRef.Field.StaticMemberID);
}
else
{
buffer.Add(
fieldRef.FirstToken,
OpCode.DEREF_INSTANCE_FIELD,
fieldRef.Field.MemberID);
}
}
private void ReadFieldReferences(BinaryReader reader)
{
reader.PreserveCurrentPosition(header.FieldReferencesOffset, () =>
{
for (int i = 0; i < header.FieldReferencesSize; i++)
{
int classIndex = reader.ReadUInt16();
int typeIndex = reader.ReadUInt16();
int nameIndex = reader.ReadInt32();
var fref = new FieldReference();
fref.Owner = (ClassReference) typeReferences[classIndex];
fref.Type = typeReferences[typeIndex];
fref.Name = strings[nameIndex];
fieldReferences.Add(fref);
}
});
}
static bool NonGenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition)
{
return(fieldDefinition == fieldReference);
}
public FluentEmitter Emit(OpCode opcode, FieldReference arg)
{
return Emit(Instruction.Create(opcode, Module.SafeImport(arg)));
}
private static void GenerateStaticProxy(AssemblyRewriteContext assemblyContext, TypeRewriteContext typeContext)
{
var oldType = typeContext.OriginalType;
var newType = typeContext.NewType;
var staticCtorMethod = new MethodDefinition(".cctor",
MethodAttributes.Static | MethodAttributes.Private | MethodAttributes.SpecialName |
MethodAttributes.HideBySig | MethodAttributes.RTSpecialName, assemblyContext.Imports.Void);
newType.Methods.Add(staticCtorMethod);
var ctorBuilder = staticCtorMethod.Body.GetILProcessor();
if (newType.IsNested)
{
ctorBuilder.Emit(OpCodes.Ldsfld, assemblyContext.GlobalContext.GetNewTypeForOriginal(oldType.DeclaringType).ClassPointerFieldRef);
ctorBuilder.Emit(OpCodes.Ldstr, oldType.Name);
ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppNestedClass);
}
else
{
ctorBuilder.Emit(OpCodes.Ldstr, oldType.Module.Name);
ctorBuilder.Emit(OpCodes.Ldstr, oldType.Namespace);
ctorBuilder.Emit(OpCodes.Ldstr, oldType.Name);
ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppGlobalClass);
}
if (oldType.HasGenericParameters)
{
var il2CppTypeTypeRewriteContext = assemblyContext.GlobalContext.GetAssemblyByName("mscorlib").GetTypeByName("System.Type");
var il2CppSystemTypeRef = newType.Module.ImportReference(il2CppTypeTypeRewriteContext.NewType);
var il2CppTypeHandleTypeRewriteContext = assemblyContext.GlobalContext.GetAssemblyByName("mscorlib").GetTypeByName("System.RuntimeTypeHandle");
var il2CppSystemTypeHandleRef = newType.Module.ImportReference(il2CppTypeHandleTypeRewriteContext.NewType);
ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppTypeFromClass);
ctorBuilder.Emit(OpCodes.Call, new MethodReference("internal_from_handle", il2CppSystemTypeRef, il2CppSystemTypeRef)
{
Parameters = { new ParameterDefinition(assemblyContext.Imports.IntPtr) }
});
ctorBuilder.EmitLdcI4(oldType.GenericParameters.Count);
ctorBuilder.Emit(OpCodes.Newarr, il2CppSystemTypeRef);
for (var i = 0; i < oldType.GenericParameters.Count; i++)
{
ctorBuilder.Emit(OpCodes.Dup);
ctorBuilder.EmitLdcI4(i);
var param = oldType.GenericParameters[i];
var storeRef = new GenericInstanceType(assemblyContext.Imports.Il2CppClassPointerStore)
{
GenericArguments = { param }
};
var fieldRef = new FieldReference(nameof(Il2CppClassPointerStore <object> .NativeClassPtr), assemblyContext.Imports.IntPtr, storeRef);
ctorBuilder.Emit(OpCodes.Ldsfld, fieldRef);
ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppTypeFromClass);
ctorBuilder.Emit(OpCodes.Call, new MethodReference("internal_from_handle", il2CppSystemTypeRef, il2CppSystemTypeRef)
{
Parameters = { new ParameterDefinition(assemblyContext.Imports.IntPtr) }
});
ctorBuilder.Emit(OpCodes.Stelem_Ref);
}
var il2CppTypeArray = new GenericInstanceType(assemblyContext.Imports.Il2CppReferenceArray)
{
GenericArguments = { il2CppSystemTypeRef }
};
ctorBuilder.Emit(OpCodes.Newobj, new MethodReference(".ctor", assemblyContext.Imports.Void, il2CppTypeArray)
{
HasThis = true, Parameters = { new ParameterDefinition(new ArrayType(assemblyContext.Imports.Il2CppReferenceArray.GenericParameters[0])) }
});
ctorBuilder.Emit(OpCodes.Call, new MethodReference(nameof(Type.MakeGenericType), il2CppSystemTypeRef, il2CppSystemTypeRef)
{
HasThis = true, Parameters = { new ParameterDefinition(il2CppTypeArray) }
});
ctorBuilder.Emit(OpCodes.Call, new MethodReference(typeof(Type).GetProperty(nameof(Type.TypeHandle)) !.GetMethod !.Name, il2CppSystemTypeHandleRef, il2CppSystemTypeRef)
{
HasThis = true
});
static bool GenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition)
{
return(fieldDefinition == fieldReference.Resolve());
}
/// <summary>Try rewriting the field into a matching property.</summary>
/// <param name="module">The assembly module containing the instruction.</param>
/// <param name="instruction">The CIL instruction to rewrite.</param>
/// <param name="fieldRef">The field reference.</param>
/// <param name="declaringType">The type on which the field was defined.</param>
/// <param name="isRead">Whether the field is being read; else it's being written to.</param>
private bool TryRewriteToProperty(ModuleDefinition module, Instruction instruction, FieldReference fieldRef, TypeDefinition declaringType, bool isRead)
{
// get equivalent property
PropertyDefinition property = declaringType.Properties.FirstOrDefault(p => p.Name == fieldRef.Name);
MethodDefinition method = isRead ? property?.GetMethod : property?.SetMethod;
if (method == null)
{
return(false);
}
// rewrite field to property
instruction.OpCode = OpCodes.Call;
instruction.Operand = module.ImportReference(method);
this.Phrases.Add($"{fieldRef.DeclaringType.Name}.{fieldRef.Name} (field => property)");
return(this.MarkRewritten());
}
public bool? PopupSingleSelectDialog(string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection)
{
throw new NotImplementedException();
}
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 key in methods.Keys)
{
MethodDefinition method = methods[key];
if (!CheckHelper.CheckMethodFirstParams(WeaverProgram.Server, method))
{
continue;
}
MethodDefinition protoMethodImpl = MethodFactory.CreateMethod(module, protocol, "OnProtocol_" + key, 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)
{
if (i > 0)
{
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)));
}
}
}
processor.Append(processor.Create(OpCodes.Ldarg_0));
processor.Append(processor.Create(OpCodes.Ldfld, connectionField));
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, key));
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 (short 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));
}
}
public Instruction Create(OpCode opcode, FieldReference field)
{
return(Instruction.Create(opcode, field));
}
public FieldDefinition Resolve(FieldReference field)
{
TypeDefinition type = Resolve(field.DeclaringType);
return(GetField(type.Fields, field));
}
/// <summary>
/// Creates a new <see cref="IsNullClause"/> instance.
/// </summary>
/// <param name="field">A reference to the field that should be null.</param>
public IsNullClause(FieldReference field)
{
_field = field;
}
/// <summary>
/// Creates a property getter method implementation with the
/// <paramref name="propertyType" /> as the return type.
/// </summary>
/// <param name="propertyType">Represents the <see cref="TypeReference">return type</see> for the getter method.</param>
/// <param name="getterName">The getter method name.</param>
/// <param name="attributes">The method attributes associated with the getter method.</param>
/// <param name="backingField">The field that will store the instance that the getter method will retrieve.</param>
/// <returns>A <see cref="MethodDefinition" /> representing the getter method itself.</returns>
private static MethodDefinition AddPropertyGetter(TypeReference propertyType,
string getterName, MethodAttributes attributes, FieldReference backingField)
{
var getter = new MethodDefinition(getterName, attributes, propertyType)
{
IsPublic = true,
ImplAttributes = MethodImplAttributes.Managed | MethodImplAttributes.IL
};
var IL = getter.Body.GetILProcessor();
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldfld, backingField);
IL.Emit(OpCodes.Ret);
return(getter);
}
public FieldAccessorReplacementFactory(FieldReference field, ReturnStatement firstStatement, ReplacementRegistry registry)
{
this.field = field;
this.firstStatement = firstStatement;
this.registry = registry;
}
public static bool RequiresReflectionMethodBodyScannerForAccess(LinkContext context, FieldReference field)
{
FieldDefinition?fieldDefinition = context.TryResolve(field);
if (fieldDefinition == null)
{
return(false);
}
return(context.Annotations.FlowAnnotations.RequiresDataFlowAnalysis(fieldDefinition));
}
protected override void RewriteLoadField(IOperation op) {
var fieldReference = op.Value as IFieldReference;
Contract.Assert(fieldReference != null);
if (fieldReference.ContainingType.IsEnum == false) {
var loadFieldCounterReference = new FieldReference() {
Name = base.host.NameTable.GetNameFor(MemberHelper.GetMemberSignature(fieldReference, NameFormattingOptions.None) + "$$loadCount"),
Type = base.host.PlatformType.SystemInt64,
InternFactory = base.host.InternFactory,
ContainingType = fieldReference.ContainingType,
IsStatic = false
};
base.generator.Emit(OperationCode.Dup); // load "this" onto stack
base.generator.Emit(OperationCode.Dup); // load "this" onto stack
base.generator.Emit(OperationCode.Ldfld, loadFieldCounterReference); // load field$$loadCount onto stack
base.generator.Emit(OperationCode.Ldc_I4_1); // load 1 onto stack
base.generator.Emit(OperationCode.Conv_I8); // convert to int64
base.generator.Emit(OperationCode.Add); // add field$loadCount + 1
base.generator.Emit(OperationCode.Stfld, loadFieldCounterReference); // store result of add to field$$loadCount
}
// now do the actual ldfld
base.RewriteLoadField(op);
}
public FieldReference GetBindablePropertyFieldReference(string value, ModuleDefinition module, BaseNode node)
{
FieldReference bpRef = null;
string typeName = null, propertyName = null;
var parts = value.Split('.');
if (parts.Length == 1)
{
var parent = node.Parent?.Parent as IElementNode;
if ((node.Parent as ElementNode)?.XmlType.NamespaceUri == XamlParser.XFUri &&
((node.Parent as ElementNode)?.XmlType.Name == "Setter" || (node.Parent as ElementNode)?.XmlType.Name == "PropertyCondition"))
{
if (parent.XmlType.NamespaceUri == XamlParser.XFUri &&
(parent.XmlType.Name == "Trigger" || parent.XmlType.Name == "DataTrigger" || parent.XmlType.Name == "MultiTrigger" || parent.XmlType.Name == "Style"))
{
var ttnode = (parent as ElementNode).Properties [new XmlName("", "TargetType")];
if (ttnode is ValueNode)
{
typeName = (ttnode as ValueNode).Value as string;
}
else if (ttnode is IElementNode)
{
typeName = ((ttnode as IElementNode).CollectionItems.FirstOrDefault() as ValueNode)?.Value as string ?? ((ttnode as IElementNode).Properties [new XmlName("", "TypeName")] as ValueNode)?.Value as string;
}
}
}
else if ((node.Parent as ElementNode)?.XmlType.NamespaceUri == XamlParser.XFUri && (node.Parent as ElementNode)?.XmlType.Name == "Trigger")
{
typeName = ((node.Parent as ElementNode).Properties [new XmlName("", "TargetType")] as ValueNode).Value as string;
}
propertyName = parts [0];
}
else if (parts.Length == 2)
{
typeName = parts [0];
propertyName = parts [1];
}
else
{
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(BindableProperty)}", node);
}
if (typeName == null || propertyName == null)
{
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(BindableProperty)}", node);
}
var typeRef = XmlTypeExtensions.GetTypeReference(typeName, module, node);
if (typeRef == null)
{
throw new XamlParseException($"Can't resolve {typeName}", node);
}
bpRef = GetBindablePropertyFieldReference(typeRef, propertyName, module);
if (bpRef == null)
{
throw new XamlParseException($"Can't resolve {propertyName} on {typeRef.Name}", node);
}
return(bpRef);
}
public IFieldReference Map(Microsoft.CodeAnalysis.CSharp.Symbols.FieldSymbol fieldSymbol) {
IFieldReference fr = null;
if (!fieldSymbolCache.TryGetValue(fieldSymbol, out fr)) {
fr = new FieldReference() {
ContainingType = Map(fieldSymbol.ContainingType),
InternFactory = this.host.InternFactory,
Name = this.nameTable.GetNameFor(fieldSymbol.Name),
Type = Map(fieldSymbol.Type),
};
this.fieldSymbolCache[fieldSymbol] = fr;
}
return fr;
}
static LambdaJobDescriptionConstruction AnalyzeLambdaJobStatement(MethodDefinition method, Instruction getEntitiesOrJobInstruction, int lambdaNumber)
{
List <InvokedConstructionMethod> modifiers = new List <InvokedConstructionMethod>();
Instruction cursor = getEntitiesOrJobInstruction;
var expectedPreviousMethodPushingDescription = getEntitiesOrJobInstruction;
while (true)
{
cursor = FindNextConstructionMethod(method, cursor);
var mr = cursor?.Operand as MethodReference;
if (mr.Name == nameof(LambdaJobDescriptionExecutionMethods.Schedule) ||
mr.Name == nameof(LambdaJobDescriptionExecutionMethods.ScheduleParallel) ||
mr.Name == nameof(LambdaJobDescriptionExecutionMethods.Run))
{
var withNameModifier = modifiers.FirstOrDefault(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithName));
var givenName = withNameModifier?.Arguments.OfType <string>().Single();
var lambdaJobName = givenName ?? $"{method.Name}_LambdaJob{lambdaNumber}";
if (givenName != null && !VerifyLambdaName(givenName))
{
UserError.DC0043(method, givenName, getEntitiesOrJobInstruction).Throw();
}
var hasWithStructuralChangesModifier
= modifiers.Any(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithStructuralChanges));
if (hasWithStructuralChangesModifier && mr.Name != nameof(LambdaJobDescriptionExecutionMethods.Run))
{
UserError.DC0028(method, getEntitiesOrJobInstruction).Throw();
}
FieldReference storeQueryInField = null;
foreach (var modifier in modifiers)
{
if (modifier.MethodName == nameof(LambdaJobQueryConstructionMethods.WithStoreEntityQueryInField))
{
var instructionThatPushedField = CecilHelpers.FindInstructionThatPushedArg(method, 1, modifier.InstructionInvokingMethod);
storeQueryInField = instructionThatPushedField.Operand as FieldReference;
if (instructionThatPushedField.OpCode != OpCodes.Ldflda || storeQueryInField == null ||
instructionThatPushedField.Previous.OpCode != OpCodes.Ldarg_0)
{
UserError.DC0031(method, getEntitiesOrJobInstruction).Throw();
}
}
}
LambdaJobDescriptionKind FindLambdaDescriptionKind()
{
switch (((MethodReference)getEntitiesOrJobInstruction.Operand).Name)
{
case EntitiesGetterName:
return(LambdaJobDescriptionKind.Entities);
case JobGetterName:
return(LambdaJobDescriptionKind.Job);
#if ENABLE_DOTS_COMPILER_CHUNKS
case "get_" + nameof(JobComponentSystem.Chunks):
return(LambdaJobDescriptionKind.Chunk);
#endif
default:
throw new ArgumentOutOfRangeException();
}
}
if (modifiers.All(m => m.MethodName != nameof(LambdaForEachDescriptionConstructionMethods.ForEach) &&
m.MethodName != nameof(LambdaSingleJobDescriptionConstructionMethods.WithCode)))
{
DiagnosticMessage MakeDiagnosticMessage()
{
switch (FindLambdaDescriptionKind())
{
case LambdaJobDescriptionKind.Entities:
return(UserError.DC0006(method, getEntitiesOrJobInstruction));
case LambdaJobDescriptionKind.Job:
return(UserError.DC0017(method, getEntitiesOrJobInstruction));
case LambdaJobDescriptionKind.Chunk:
return(UserError.DC0018(method, getEntitiesOrJobInstruction));
default:
throw new ArgumentOutOfRangeException();
}
}
MakeDiagnosticMessage().Throw();
}
if (method.DeclaringType.HasGenericParameters)
{
UserError.DC0025($"Entities.ForEach cannot be used in system {method.DeclaringType.Name} as Entities.ForEach in generic system types are not supported.", method, getEntitiesOrJobInstruction).Throw();
}
var withCodeInvocationInstruction = modifiers
.Single(m => m.MethodName == nameof(LambdaForEachDescriptionConstructionMethods.ForEach) || m.MethodName == nameof(LambdaSingleJobDescriptionConstructionMethods.WithCode))
.InstructionInvokingMethod;
return(new LambdaJobDescriptionConstruction()
{
Kind = FindLambdaDescriptionKind(),
InvokedConstructionMethods = modifiers,
WithCodeInvocationInstruction = withCodeInvocationInstruction,
ScheduleOrRunInvocationInstruction = cursor,
LambdaJobName = lambdaJobName,
ChainInitiatingInstruction = getEntitiesOrJobInstruction,
ContainingMethod = method,
DelegateProducingSequence = AnalyzeForEachInvocationInstruction(method, withCodeInvocationInstruction),
WithStructuralChanges = hasWithStructuralChangesModifier,
StoreQueryInField = (storeQueryInField != null) ? storeQueryInField.Resolve() : null
});
}
var instructions = mr.Parameters.Skip(1)
.Select(p => OperandObjectFor(CecilHelpers.FindInstructionThatPushedArg(method, p.Index, cursor))).ToArray();
var invokedConstructionMethod = new InvokedConstructionMethod(mr.Name,
(mr as GenericInstanceMethod)?.GenericArguments.ToArray() ?? Array.Empty <TypeReference>(),
instructions, cursor);
var allowDynamicValue = method.Module.ImportReference(typeof(AllowDynamicValueAttribute));
for (int i = 0; i != invokedConstructionMethod.Arguments.Length; i++)
{
if (invokedConstructionMethod.Arguments[i] != null)
{
continue;
}
var inbovokedForEachMethod = mr.Resolve();
var methodDefinitionParameter = inbovokedForEachMethod.Parameters[i + 1];
if (!methodDefinitionParameter.CustomAttributes.Any(c => c.AttributeType.TypeReferenceEquals(allowDynamicValue)))
{
UserError.DC0008(method, cursor, mr).Throw();
}
}
if (modifiers.Any(m => m.MethodName == mr.Name) && !HasAllowMultipleAttribute(mr.Resolve()))
{
UserError.DC0009(method, cursor, mr).Throw();
}
var findInstructionThatPushedArg = CecilHelpers.FindInstructionThatPushedArg(method, 0, cursor);
if (cursor == null || findInstructionThatPushedArg != expectedPreviousMethodPushingDescription)
{
UserError.DC0007(method, cursor).Throw();
}
expectedPreviousMethodPushingDescription = cursor;
modifiers.Add(invokedConstructionMethod);
}
}
/// <summary>
/// Creates a new <see cref="SortExpression"/> instance.
/// </summary>
/// <param name="field">
/// Value for the <see cref="SortExpression.Field"/> property.
/// </param>
public SortExpression(FieldReference field)
{
_field = field;
}
public static void WriteOperand(ITextOutput writer, object operand)
{
if (operand == null)
{
throw new ArgumentNullException("operand");
}
Instruction targetInstruction = operand as Instruction;
if (targetInstruction != null)
{
WriteOffsetReference(writer, targetInstruction);
return;
}
Instruction[] targetInstructions = operand as Instruction[];
if (targetInstructions != null)
{
WriteLabelList(writer, targetInstructions);
return;
}
VariableReference variableRef = operand as VariableReference;
if (variableRef != null)
{
if (string.IsNullOrEmpty(variableRef.Name))
{
writer.WriteReference(variableRef.Index.ToString(), variableRef);
}
else
{
writer.WriteReference(Escape(variableRef.Name), variableRef);
}
return;
}
ParameterReference paramRef = operand as ParameterReference;
if (paramRef != null)
{
if (string.IsNullOrEmpty(paramRef.Name))
{
writer.WriteReference(paramRef.Index.ToString(), paramRef);
}
else
{
writer.WriteReference(Escape(paramRef.Name), paramRef);
}
return;
}
MethodReference methodRef = operand as MethodReference;
if (methodRef != null)
{
methodRef.WriteTo(writer);
return;
}
TypeReference typeRef = operand as TypeReference;
if (typeRef != null)
{
typeRef.WriteTo(writer, ILNameSyntax.TypeName);
return;
}
FieldReference fieldRef = operand as FieldReference;
if (fieldRef != null)
{
fieldRef.WriteTo(writer);
return;
}
string s = operand as string;
if (s != null)
{
writer.Write("\"" + NRefactory.CSharp.OutputVisitor.ConvertString(s) + "\"");
}
else if (operand is char)
{
writer.Write(((int)(char)operand).ToString());
}
else if (operand is float)
{
float val = (float)operand;
if (val == 0)
{
writer.Write("0.0");
}
else if (float.IsInfinity(val) || float.IsNaN(val))
{
byte[] data = BitConverter.GetBytes(val);
writer.Write('(');
for (int i = 0; i < data.Length; i++)
{
if (i > 0)
{
writer.Write(' ');
}
writer.Write(data[i].ToString("X2"));
}
writer.Write(')');
}
else
{
writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture));
}
}
else if (operand is double)
{
double val = (double)operand;
if (val == 0)
{
writer.Write("0.0");
}
else if (double.IsInfinity(val) || double.IsNaN(val))
{
byte[] data = BitConverter.GetBytes(val);
writer.Write('(');
for (int i = 0; i < data.Length; i++)
{
if (i > 0)
{
writer.Write(' ');
}
writer.Write(data[i].ToString("X2"));
}
writer.Write(')');
}
else
{
writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture));
}
}
else if (operand is bool)
{
writer.Write((bool)operand ? "true" : "false");
}
else
{
s = ToInvariantCultureString(operand);
writer.Write(s);
}
}
public Instruction Create(OpCode opcode, FieldReference field)
{
return Instruction.Create (opcode, field);
}
static string FormatInstruction(Instruction instr)
{
switch (instr.OpCode.FlowControl)
{
case FlowControl.Branch:
case FlowControl.Cond_Branch:
if (instr.Operand is Instruction target)
{
return($"{instr.OpCode.ToString ()} il_{target.Offset.ToString ("x")}");
}
break;
}
switch (instr.OpCode.Code)
{
case Code.Ldc_I4:
if (instr.Operand is int ivalue)
{
return($"{instr.OpCode.ToString ()} 0x{ivalue.ToString ("x")}");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
case Code.Ldc_I4_S:
if (instr.Operand is sbyte bvalue)
{
return($"{instr.OpCode.ToString ()} 0x{bvalue.ToString ("x")}");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
case Code.Ldc_I8:
if (instr.Operand is long lvalue)
{
return($"{instr.OpCode.ToString ()} 0x{lvalue.ToString ("x")}");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
case Code.Ldc_R4:
if (instr.Operand is float fvalue)
{
return($"{instr.OpCode.ToString ()} {fvalue.ToString ()}");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
case Code.Ldc_R8:
if (instr.Operand is double dvalue)
{
return($"{instr.OpCode.ToString ()} {dvalue.ToString ()}");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
case Code.Ldstr:
if (instr.Operand is string svalue)
{
return($"{instr.OpCode.ToString ()} '{svalue}'");
}
throw new NotImplementedException(instr.Operand.GetType().ToString());
default: {
string operandString = null;
switch (instr.OpCode.OperandType)
{
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineType:
case OperandType.InlineTok:
operandString = instr.Operand switch {
FieldReference fieldRef => fieldRef.FullName,
MethodReference methodRef => methodRef.FullName,
TypeReference typeRef => typeRef.FullName,
_ => null
};
break;
}
if (operandString != null)
{
return($"{instr.OpCode.ToString ()} {operandString}");
}
else
{
return(instr.OpCode.ToString());
}
}
}
}
/// <summary>
/// 为类型注入TryInitHotFix函数
/// </summary>
/// <param name="typeDefinition"></param>
private static MethodDefinition InjectTryInitHotFixFunc(TypeDefinition typeDefinition, FieldReference hotfixStateField)
{
string funcName = "TryInitHotFix";
foreach (var method in typeDefinition.Methods)
{
if (method.Name == funcName)
{
typeDefinition.Methods.Remove(method);
break;
}
}
MethodDefinition tryInitHotFixMethod = new MethodDefinition(funcName, MethodAttributes.Static | MethodAttributes.Private, typeRef_bool);
tryInitHotFixMethod.Parameters.Add(new ParameterDefinition("luaModuleName", ParameterAttributes.None, typeRef_string));
tryInitHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(tryInitHotFixMethod);
tryInitHotFixMethod.Body.MaxStackSize = 2;
tryInitHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool));
tryInitHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool));
// 开始注入IL代码
var ilProcessor = tryInitHotFixMethod.Body.GetILProcessor();
tryInitHotFixMethod.Body.Instructions.Add(ilProcessor.Create(OpCodes.Ret));
var insertPoint = tryInitHotFixMethod.Body.Instructions[0];
// 设置一些标签用于语句跳转
var label1 = ilProcessor.Create(OpCodes.Nop);
var label2 = ilProcessor.Create(OpCodes.Ldloc_0);
var label3 = ilProcessor.Create(OpCodes.Ldc_I4_1);
var label4 = ilProcessor.Create(OpCodes.Stsfld, hotfixStateField);
var label5 = ilProcessor.Create(OpCodes.Ldloc_1);
//if (m_hotFixState == 0)
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldsfld, hotfixStateField));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label1));
//flag = (HotFixTestScript.m_hotfixState == ObjectLuaHotFixState.InitAvialable);
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldsfld, hotfixStateField));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_2));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ceq));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label2));
//flag = LuaManager.TryInitHotfixForObj(typeof(HotFixTestScript), luaModuleName);
ilProcessor.InsertBefore(insertPoint, label1);//OpCodes.Nop
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldtoken, typeDefinition));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_Type_GetTypeFromHandle));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_LuaManager_TryInitHotFix));
//HotFixTestScript.m_hotfixState = ((!flag) ? ObjectLuaHotFixState.InitUnavialable : ObjectLuaHotFixState.InitAvialable);
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldloc_0));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label3));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_2));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label4));
ilProcessor.InsertBefore(insertPoint, label3); //OpCodes.Ldc_I4_1
ilProcessor.InsertBefore(insertPoint, label4); //OpCodes.Stsfld, hotfixState
//return flag
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop));
ilProcessor.InsertBefore(insertPoint, label2); //OpCodes.Ldloc_0
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_1));
ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label5));
ilProcessor.InsertBefore(insertPoint, label5);//OpCodes.Ldloc_1
typeDefinition.Methods.Add(tryInitHotFixMethod);
return(tryInitHotFixMethod);
}
public MethodReference GetOrCreateGetPropertyChangedMethod(AssemblyDefinition assembly, TypeDefinition typeDefinition, FieldReference propertyChangedField)
{
var methodReference = GetGetPropertyChangedMethod(assembly, typeDefinition);
if (methodReference != null)
{
return(methodReference);
}
var method = new MethodDefinition("GetPropertyChanged", MethodAttributes.Family, propertyChangedField.FieldType);
var bodyInstructions = method.Body.Instructions;
// return PropertyChanged
bodyInstructions.Add(Instruction.Create(OpCodes.Ldarg_0));
bodyInstructions.Add(Instruction.Create(OpCodes.Ldfld, propertyChangedField));
bodyInstructions.Add(Instruction.Create(OpCodes.Ret));
typeDefinition.Methods.Add(method);
return(method);
}
public void Emit(OpCode opcode, FieldReference field)
{
Append(Create(opcode, field));
}
public MethodEmitter(InstrumentationContext context, FieldReference field)
{
_context = context;
_activatorField = FieldReferenceFor(field);
}
public static void Compile(ByteCodeCompiler bcc, ParserContext parser, ByteBuffer buffer, Increment increment, bool outputUsed)
{
if (!outputUsed)
{
throw new Exception("This should have been optimized into a += or -=");
}
if (increment.Root is Variable)
{
// OpCode re-use be damned. This should be not one, but two top-level op codes.
// INCREMENT_INLINE and INCREMENT_POP (depending on whether outputUsed is true)
// In fact, the code here in its current form is actually WRONG because someString++ will have
// a '1' appended to it when it really should be an error if the variable is not an integer.
// Same for the others below. Ideally the DUPLICATE_STACK_TOP op should be removed.
Variable variable = (Variable)increment.Root;
VariableId varId = variable.VarId;
bool isClosureVar = varId.UsedByClosure;
int scopeId = isClosureVar ? varId.ClosureID : varId.ID;
bcc.CompileExpression(parser, buffer, increment.Root, true);
if (increment.IsPrefix)
{
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1);
buffer.Add(variable.FirstToken, isClosureVar ? OpCode.ASSIGN_CLOSURE : OpCode.ASSIGN_LOCAL, scopeId);
}
else
{
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1);
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(variable.FirstToken, isClosureVar ? OpCode.ASSIGN_CLOSURE : OpCode.ASSIGN_LOCAL, scopeId);
}
}
else if (increment.Root is BracketIndex)
{
BracketIndex bracketIndex = (BracketIndex)increment.Root;
bcc.CompileExpression(parser, buffer, bracketIndex.Root, true);
bcc.CompileExpression(parser, buffer, bracketIndex.Index, true);
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 2);
buffer.Add(bracketIndex.BracketToken, OpCode.INDEX);
if (increment.IsPrefix)
{
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.ASSIGN_INDEX, 1);
}
else
{
buffer.Add(increment.IncrementToken, OpCode.STACK_INSERTION_FOR_INCREMENT);
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.ASSIGN_INDEX, 0);
}
}
else if (increment.Root is DotField)
{
DotField dotStep = (DotField)increment.Root;
bcc.CompileExpression(parser, buffer, dotStep.Root, true);
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1);
int nameId = parser.GetId(dotStep.FieldToken.Value);
int localeScopedNameId = nameId * parser.GetLocaleCount() + parser.GetLocaleId(dotStep.Owner.FileScope.CompilationScope.Locale);
int originClassId = increment.ClassOwner == null ? -1 : increment.ClassOwner.ClassID;
int originAssemblyId = increment.CompilationScope.ScopeNumId;
buffer.Add(
dotStep.DotToken,
OpCode.DEREF_DOT,
nameId,
localeScopedNameId,
originClassId,
increment.CompilationScope.ScopeNumId,
-1, 0);
if (increment.IsPrefix)
{
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.ASSIGN_FIELD, nameId, 1, localeScopedNameId, originClassId, originAssemblyId, -1, 0);
}
else
{
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 2);
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.ASSIGN_FIELD, nameId, 0, localeScopedNameId, originClassId, originAssemblyId, -1, 0);
buffer.Add(increment.IncrementToken, OpCode.STACK_SWAP_POP);
}
}
else if (increment.Root is FieldReference)
{
FieldReference fr = (FieldReference)increment.Root;
bool isStatic = fr.Field.Modifiers.HasStatic;
ClassDefinition cd = (ClassDefinition)fr.Field.Owner;
int memberId = isStatic ? fr.Field.StaticMemberID : fr.Field.MemberID;
bcc.CompileExpression(parser, buffer, fr, true);
if (increment.IsPrefix)
{
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1);
}
else
{
buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1);
buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1));
buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION);
}
Token token = increment.IsPrefix ? increment.FirstToken : fr.FirstToken;
if (isStatic)
{
buffer.Add(token, OpCode.ASSIGN_STATIC_FIELD, ((ClassDefinition)fr.Field.Owner).ClassID, memberId);
}
else
{
buffer.Add(token, OpCode.ASSIGN_THIS_FIELD, memberId);
}
}
else
{
throw new ParserException(increment.IncrementToken, "Cannot apply " + (increment.IsIncrement ? "++" : "--") + " to this sort of expression.");
}
}
MethodDefinition CreateEventMethod(string methodName, MethodReference delegateMethodReference, FieldReference propertyChangedField)
{
const MethodAttributes Attributes = MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.Final |
MethodAttributes.SpecialName |
MethodAttributes.NewSlot |
MethodAttributes.Virtual;
var method = new MethodDefinition(methodName, Attributes, ModuleDefinition.TypeSystem.Void);
method.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, PropChangedHandlerReference));
var handlerVariable0 = new VariableDefinition(PropChangedHandlerReference);
method.Body.Variables.Add(handlerVariable0);
var handlerVariable1 = new VariableDefinition(PropChangedHandlerReference);
method.Body.Variables.Add(handlerVariable1);
var handlerVariable2 = new VariableDefinition(PropChangedHandlerReference);
method.Body.Variables.Add(handlerVariable2);
var loopBegin = Instruction.Create(OpCodes.Ldloc, handlerVariable0);
method.Body.Instructions.Append(
Instruction.Create(OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Ldfld, propertyChangedField),
Instruction.Create(OpCodes.Stloc, handlerVariable0),
loopBegin,
Instruction.Create(OpCodes.Stloc, handlerVariable1),
Instruction.Create(OpCodes.Ldloc, handlerVariable1),
Instruction.Create(OpCodes.Ldarg_1),
Instruction.Create(OpCodes.Call, delegateMethodReference),
Instruction.Create(OpCodes.Castclass, PropChangedHandlerReference),
Instruction.Create(OpCodes.Stloc, handlerVariable2),
Instruction.Create(OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Ldflda, propertyChangedField),
Instruction.Create(OpCodes.Ldloc, handlerVariable2),
Instruction.Create(OpCodes.Ldloc, handlerVariable1),
Instruction.Create(OpCodes.Call, InterlockedCompareExchangeForPropChangedHandler),
Instruction.Create(OpCodes.Stloc, handlerVariable0),
Instruction.Create(OpCodes.Ldloc, handlerVariable0),
Instruction.Create(OpCodes.Ldloc, handlerVariable1),
Instruction.Create(OpCodes.Bne_Un_S, loopBegin), // go to begin of loop
Instruction.Create(OpCodes.Ret));
method.Body.InitLocals = true;
method.Body.OptimizeMacros();
return(method);
}
private bool CheckJavaPath()
{
//Check config
if (this.Engine.JreManager.JavaRuntime != null)
{
return true;
}
var javaRuntimeEntitiesKP = new Dictionary<string, JavaRuntimeEntity>();
foreach (var availableJre in this.Engine.JreManager.AvailableJavaRuntimes)
{
javaRuntimeEntitiesKP.Add(availableJre.Key, availableJre.Value);
}
if (javaRuntimeEntitiesKP.Keys.Count != 0)
{
var field = new FieldReference<string>(javaRuntimeEntitiesKP.Keys.First());
var result = this.Engine.UiControl.PopupSingleSelectDialog(TranslationManager.GetManager.Localize("JavaSelectWindowTitle", "Select a Java"), TranslationManager.GetManager.Localize("JavaSelectField", "Available Java exe:"), javaRuntimeEntitiesKP.Keys, field);
if (result == null || result.Value == false)
{
return false;
}
else
{
this.Engine.JreManager.JavaRuntime = javaRuntimeEntitiesKP[field.Value];
return true;
}
}
while (this.Engine.JreManager.JavaRuntime == null)
{
TerminologyLogger.GetLogger().Warn("Java path is empty. Try to receive from user..");
var field = new FieldReference<string>(string.Empty);
var result = this.Engine.UiControl.PopupSingleLineInputDialog(TranslationManager.GetManager.Localize("JavaInputWindowTitle", "Input a Java exe"), TranslationManager.GetManager.Localize("JavaInputField", "Java(not javaw) exe path:"), field);
if (result == null || result.Value == false)
{
{
try
{
var javaBinFolder = new DirectoryInfo(field.Value);
var jre = new JavaRuntimeEntity
{
JavaDetails =
JavaUtils.GetJavaDetails(Path.Combine(javaBinFolder.FullName, "java.exe")),
JavaPath = Path.Combine(javaBinFolder.FullName, "java.exe"),
JavaWPath = Path.Combine(javaBinFolder.FullName, "javaw.exe")
};
if (JavaUtils.IsJavaRuntimeValid(jre))
{
this.Engine.JreManager.JavaRuntime = jre;
}
else
{
continue;
}
}
catch (Exception ex)
{
TerminologyLogger.GetLogger()
.ErrorFormat($"cannot resolve java exe path through user input. Caused by:{ex.Message}");
continue;
}
break;
}
}
else
{
return false;
}
}
return true;
}
public FieldAssignmentReplacementRegistrar(FieldReference field, ReplacementRegistry registry)
{
this.field = field;
this.registry = registry;
}
public FieldReference Import(FieldReference field)
{
return m_importer.ImportFieldReference (field, this);
}
public bool? PopupSingleLineInputDialog(string title, string fieldName, FieldReference<string> content)
{
bool? result = null;
this.Dispatcher.Invoke(() =>
{
var inputWindow = new SingleLineInputWindow(null, title, fieldName, content);
result = inputWindow.ShowDialog();
});
return result;
}
private void Emit(OpCode opCode, FieldReference fieldReference)
{
Labelize(body.Create(opCode, fieldReference));
}
public Instruction Create(OpCode opcode, FieldReference field)
{
if (opcode.OperandType != OperandType.InlineField &&
opcode.OperandType != OperandType.InlineTok)
throw new ArgumentException ("opcode");
return FinalCreate (opcode, field);
}
public FieldReference ImportFieldReference(FieldReference field, ImportContext context)
{
return field;
}
public FieldDefinition TryResolve(FieldReference fieldReference)
{
throw null;
}
public bool? PopupSingleSelectDialog(string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection)
{
bool? result = false;
this.Dispatcher.Invoke(() =>
{
var selectWindow = new SingleSelectWindow(null, title, fieldName, options, selection);
result = selectWindow.ShowDialog();
});
return result;
}
private void InitializeInStaticConstructor(ICommonAssembly assembly, ICommonType frameworkElementType, ICommonProperty property, FieldReference field)
{
var staticConstructor = frameworkElementType.MonoCecil.GetStaticConstructor();
if (staticConstructor == null)
{
staticConstructor = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Static, assembly.MonoCecil.MainModule.TypeSystem.Void);
staticConstructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
frameworkElementType.MonoCecil.Methods.Add(staticConstructor);
}
staticConstructor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, property.Name));
staticConstructor.Body.Instructions.Insert(1, Instruction.Create(OpCodes.Ldtoken, property.MonoCecil.PropertyType));
staticConstructor.Body.Instructions.Insert(2, Instruction.Create(OpCodes.Call, getTypeFromHandleMethod.GetValue(assembly)));
staticConstructor.Body.Instructions.Insert(3, Instruction.Create(OpCodes.Ldtoken, frameworkElementType.MonoCecil));
staticConstructor.Body.Instructions.Insert(4, Instruction.Create(OpCodes.Call, getTypeFromHandleMethod.GetValue(assembly)));
staticConstructor.Body.Instructions.Insert(5, Instruction.Create(OpCodes.Call, registerMethod.GetValue(assembly)));
staticConstructor.Body.Instructions.Insert(6, Instruction.Create(OpCodes.Stsfld, field));
}
protected override void RewriteStoreField(IOperation op) {
var fieldReference = op.Value as IFieldReference;
Contract.Assert(fieldReference != null);
if (fieldReference.ContainingType.IsEnum == false) {
var storeFieldCounter = new FieldReference() {
Name = base.host.NameTable.GetNameFor(MemberHelper.GetMemberSignature(fieldReference, NameFormattingOptions.None) + "$$storeCount"),
Type = base.host.PlatformType.SystemInt64,
InternFactory = base.host.InternFactory,
ContainingType = fieldReference.ContainingType,
IsStatic = false
};
// save the variable that is on the top of stack
var name = "XXX_" + fieldReference.Name.ToString();
var def = new LocalDefinition {
Name = base.host.NameTable.GetNameFor(name),
Type = fieldReference.Type
};
if (base.methodBody.LocalVariables == null) base.methodBody.LocalVariables = new List<ILocalDefinition>(1);
base.methodBody.LocalVariables.Add(def);
// store top-of-stack into a local. This is the value the stfld uses
generator.Emit(OperationCode.Stloc, def);
base.generator.Emit(OperationCode.Dup); // load "this" onto stack
base.generator.Emit(OperationCode.Dup); // load "this" onto stack
base.generator.Emit(OperationCode.Ldfld, storeFieldCounter); // load field$$storeCount onto stack
base.generator.Emit(OperationCode.Ldc_I4_1); // load 1 onto stack
base.generator.Emit(OperationCode.Conv_I8); // convert to int64
base.generator.Emit(OperationCode.Add); // add field$storeCount + 1
base.generator.Emit(OperationCode.Stfld, storeFieldCounter); // store result of add to field$$storeCount
// restore the var we saved from the local
generator.Emit(OperationCode.Ldloc, def);
}
// now do the original stfld
base.RewriteStoreField(op);
}
private void GenerateGetMethodBody(ICommonAssembly assembly, ICommonType frameworkElementType, PropertyDefinition property, FieldReference field)
{
log.Info("Generate get method body...");
if (property.GetMethod == null)
{
log.Debug($"Create get accessor method for property '{property.Name}'");
var getMethod = new MethodDefinition($"get_{property.Name}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, property.PropertyType);
property.GetMethod = getMethod;
frameworkElementType.MonoCecil.Methods.Add(getMethod);
}
property.GetMethod.Body.Variables.Clear();
property.GetMethod.Body.Instructions.Clear();
property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldsfld, field));
property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Call, getValueMethod.GetValue(assembly)));
property.GetMethod.Body.Instructions.Add(Instruction.Create(property.PropertyType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, property.PropertyType));
property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
property.GetMethod.RemoveAttributes <CompilerGeneratedAttribute>();
log.Info("Get method body was generated");
}
public Instruction Emit (OpCode opcode, FieldReference field)
{
Instruction instr = Create (opcode, field);
Append (instr);
return instr;
}
private void GenerateSetMethodBody(ICommonAssembly assembly, ICommonType frameworkElementType, PropertyDefinition property, FieldReference field)
{
log.Info("Generate set method body...");
if (property.SetMethod == null)
{
log.Debug($"Create set accessor method for property '{property.Name}'");
var setMethod = new MethodDefinition($"set_{property.Name}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, assembly.MonoCecil.MainModule.TypeSystem.Void);
setMethod.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, property.PropertyType));
property.SetMethod = setMethod;
frameworkElementType.MonoCecil.Methods.Add(setMethod);
}
property.GetMethod.Body.Variables.Clear();
property.SetMethod.Body.Instructions.Clear();
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldsfld, field));
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
if (property.PropertyType.IsValueType)
{
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
}
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Call, setValueMethod.GetValue(assembly)));
property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
property.SetMethod.RemoveAttributes <CompilerGeneratedAttribute>();
log.Info("Set method body was generated");
}
public static FieldReference ChangeDeclaringType(
this FieldReference fieldDef, TypeReference typeRef)
{
return(new FieldReference(
fieldDef.Name, fieldDef.FieldType, typeRef));
}
public static void EmitPointerToObject(this ILProcessor body, TypeReference originalReturnType, TypeReference convertedReturnType, TypeRewriteContext enclosingType, Instruction loadPointer, bool extraDerefForNonValueTypes, bool unboxValueType)
{
// input stack: not used
// output stack: converted result
if (originalReturnType is GenericParameter)
{
EmitPointerToObjectGeneric(body, originalReturnType, convertedReturnType, enclosingType, loadPointer, extraDerefForNonValueTypes, unboxValueType);
return;
}
var imports = enclosingType.AssemblyContext.Imports;
if (originalReturnType.FullName == "System.Void")
{
// do nothing
}
else if (originalReturnType.IsValueType)
{
if (convertedReturnType.IsValueType)
{
body.Append(loadPointer);
if (unboxValueType)
{
body.Emit(OpCodes.Call, imports.ObjectUnbox);
}
body.Emit(OpCodes.Ldobj, convertedReturnType);
}
else
{
if (!unboxValueType)
{
var classPointerTypeRef = new GenericInstanceType(imports.Il2CppClassPointerStore)
{
GenericArguments = { convertedReturnType }
};
var classPointerFieldRef =
new FieldReference(nameof(Il2CppClassPointerStore <int> .NativeClassPtr), imports.IntPtr,
classPointerTypeRef);
body.Emit(OpCodes.Ldsfld, enclosingType.NewType.Module.ImportReference(classPointerFieldRef));
body.Append(loadPointer);
body.Emit(OpCodes.Call, imports.ObjectBox);
}
else // already boxed
{
body.Append(loadPointer);
}
body.Emit(OpCodes.Newobj,
new MethodReference(".ctor", imports.Void, convertedReturnType)
{
Parameters = { new ParameterDefinition(imports.IntPtr) }, HasThis = true
});
}
}
else if (originalReturnType.FullName == "System.String")
{
body.Append(loadPointer);
if (extraDerefForNonValueTypes)
{
body.Emit(OpCodes.Ldind_I);
}
body.Emit(OpCodes.Call, imports.StringFromNative);
}
else if (originalReturnType.IsArray && originalReturnType.GetElementType().IsGenericParameter)
{
body.Append(loadPointer);
var actualReturnType = imports.Il2CppArrayBaseSelfSubst;
var methodRef = new MethodReference(nameof(Il2CppArrayBase <int> .WrapNativeGenericArrayPointer),
actualReturnType,
convertedReturnType)
{
HasThis = false, Parameters = { new ParameterDefinition(imports.IntPtr) }
};
body.Emit(OpCodes.Call, methodRef);
}
else
{
var createRealObject = body.Create(OpCodes.Newobj,
new MethodReference(".ctor", imports.Void, convertedReturnType)
{
Parameters = { new ParameterDefinition(imports.IntPtr) }, HasThis = true
});
var endNop = body.Create(OpCodes.Nop);
body.Append(loadPointer);
if (extraDerefForNonValueTypes)
{
body.Emit(OpCodes.Ldind_I);
}
body.Emit(OpCodes.Dup);
body.Emit(OpCodes.Brtrue_S, createRealObject);
body.Emit(OpCodes.Pop);
body.Emit(OpCodes.Ldnull);
body.Emit(OpCodes.Br, endNop);
body.Append(createRealObject);
body.Append(endNop);
}
}
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null;
internal MemberReference/*?*/ GetModuleMemberReferenceAtRowWorker(
MetadataObject owningObject,
uint memberRefRowId
) {
if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
return null;
}
if (this.ModuleMemberReferenceArray[memberRefRowId] == null) {
MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId];
uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask;
uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask;
IModuleTypeReference/*?*/ parentTypeReference = null;
switch (classTokenType) {
case TokenTypeIds.TypeDef:
parentTypeReference = this.GetTypeDefinitionAtRowWorker(classRowId);
break;
case TokenTypeIds.TypeRef:
parentTypeReference = this.GetTypeRefReferenceAtRowWorker(classRowId);
break;
case TokenTypeIds.TypeSpec:
parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference;
break;
case TokenTypeIds.MethodDef: {
MethodDefinition/*?*/ methodDef = this.GetMethodDefAtRow(classRowId);
if (methodDef == null) {
// Error...
return null;
}
parentTypeReference = methodDef.OwningModuleType;
break;
}
case TokenTypeIds.ModuleRef: {
ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId);
if (modRef == null) {
// MDError
return null;
}
Module/*?*/ module = this.ResolveModuleRefReference(modRef);
if (module == null) {
//TODO: MDError...
return null;
}
PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel;
parentTypeReference = modulePEFileToObjectModel._Module_;
break;
}
default: {
// MDError...
return null;
}
}
if (parentTypeReference == null) {
// Error...
return null;
}
MemberReference retModuleMemberReference;
IName name = this.GetNameFromOffset(memberRefRow.Name);
byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0);
IModuleGenericTypeInstance/*?*/ genericTypeInstance = parentTypeReference as IModuleGenericTypeInstance;
IModuleSpecializedNestedTypeReference/*?*/ specializedNestedTypeReference = parentTypeReference as IModuleSpecializedNestedTypeReference;
if (SignatureHeader.IsFieldSignature(firstByte)) {
if (genericTypeInstance != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new GenericInstanceFieldReference(this, memberRefRowId, genericTypeInstance, name);
} else if (specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new SpecializedNestedTypeFieldReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name);
} else {
retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name);
}
} else if (SignatureHeader.IsMethodSignature(firstByte)) {
if (genericTypeInstance != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new GenericInstanceMethodReference(this, memberRefRowId, genericTypeInstance, name, firstByte);
} else if (specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new SpecializedNestedTypeMethodReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name, firstByte);
} else {
retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte);
}
} else {
// MD Error
return null;
}
this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference;
}
MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId];
return ret;
}
void ProcessInvocationExpression(InvocationExpression invocationExpression)
{
var method = invocationExpression.GetSymbol() as IMethod;
if (method == null)
{
return;
}
var arguments = invocationExpression.Arguments.ToArray();
// Reduce "String.Concat(a, b)" to "a + b"
if (method.Name == "Concat" && method.DeclaringType.FullName == "System.String" && CheckArgumentsForStringConcat(arguments))
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
Expression expr = arguments[0];
for (int i = 1; i < arguments.Length; i++)
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.Add, arguments[i]);
}
invocationExpression.ReplaceWith(expr);
return;
}
switch (method.FullName)
{
case "System.Type.GetTypeFromHandle":
if (arguments.Length == 1)
{
if (typeHandleOnTypeOfPattern.IsMatch(arguments[0]))
{
invocationExpression.ReplaceWith(((MemberReferenceExpression)arguments[0]).Target);
return;
}
}
break;
case "System.Reflection.FieldInfo.GetFieldFromHandle":
if (arguments.Length == 1)
{
MemberReferenceExpression mre = arguments[0] as MemberReferenceExpression;
if (mre != null && mre.MemberName == "FieldHandle" && mre.Target.Annotation <LdTokenAnnotation>() != null)
{
invocationExpression.ReplaceWith(mre.Target);
return;
}
}
else if (arguments.Length == 2)
{
MemberReferenceExpression mre1 = arguments[0] as MemberReferenceExpression;
MemberReferenceExpression mre2 = arguments[1] as MemberReferenceExpression;
if (mre1 != null && mre1.MemberName == "FieldHandle" && mre1.Target.Annotation <LdTokenAnnotation>() != null)
{
if (mre2 != null && mre2.MemberName == "TypeHandle" && mre2.Target is TypeOfExpression)
{
Expression oldArg = ((InvocationExpression)mre1.Target).Arguments.Single();
FieldReference field = oldArg.Annotation <FieldReference>();
if (field != null)
{
AstType declaringType = ((TypeOfExpression)mre2.Target).Type.Detach();
oldArg.ReplaceWith(new MemberReferenceExpression(new TypeReferenceExpression(declaringType), field.Name).CopyAnnotationsFrom(oldArg));
invocationExpression.ReplaceWith(mre1.Target);
return;
}
}
}
}
break;
case "System.Activator.CreateInstance":
if (method.TypeArguments.Count == 1 && arguments.Length == 0 && method.TypeArguments[0].Kind == TypeKind.TypeParameter)
{
invocationExpression.ReplaceWith(new ObjectCreateExpression(context.TypeSystemAstBuilder.ConvertType(method.TypeArguments.First())));
}
break;
}
BinaryOperatorType?bop = GetBinaryOperatorTypeFromMetadataName(method.Name);
if (bop != null && arguments.Length == 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
invocationExpression.ReplaceWith(
new BinaryOperatorExpression(arguments[0], bop.Value, arguments[1]).CopyAnnotationsFrom(invocationExpression)
);
return;
}
UnaryOperatorType?uop = GetUnaryOperatorTypeFromMetadataName(method.Name);
if (uop != null && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
new UnaryOperatorExpression(uop.Value, arguments[0]).CopyAnnotationsFrom(invocationExpression)
);
return;
}
if (method.Name == "op_Explicit" && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
new CastExpression(context.TypeSystemAstBuilder.ConvertType(method.ReturnType), arguments[0])
.CopyAnnotationsFrom(invocationExpression)
);
return;
}
if (method.Name == "op_Implicit" && arguments.Length == 1)
{
invocationExpression.ReplaceWith(arguments[0]);
return;
}
if (method.Name == "op_True" && arguments.Length == 1 && invocationExpression.Role == Roles.Condition)
{
invocationExpression.ReplaceWith(arguments[0]);
return;
}
return;
}
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null;
internal ITypeMemberReference/*?*/ GetModuleMemberReferenceAtRowWorker(
MetadataObject owningObject,
uint memberRefRowId
) {
if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
return null;
}
if (this.ModuleMemberReferenceArray[memberRefRowId] == null) {
MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId];
uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask;
uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask;
ITypeReference/*?*/ parentTypeReference = null;
switch (classTokenType) {
case TokenTypeIds.TypeDef:
parentTypeReference = this.GetTypeDefinitionAtRow(classRowId);
break;
case TokenTypeIds.TypeRef:
parentTypeReference = this.GetTypeRefReferenceAtRow(classRowId);
break;
case TokenTypeIds.TypeSpec:
parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference;
break;
case TokenTypeIds.MethodDef: {
var/*?*/ methodDef = this.GetMethodDefAtRow(classRowId);
if (methodDef == null) {
// Error...
return null;
}
parentTypeReference = methodDef.ContainingType;
break;
}
case TokenTypeIds.ModuleRef: {
ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId);
if (modRef == null) {
// MDError
return null;
}
var module = this.ResolveModuleRefReference(modRef) as Module;
if (module == null) {
//TODO: MDError...
return null;
}
PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel;
parentTypeReference = modulePEFileToObjectModel._Module_;
break;
}
default: {
// MDError...
return null;
}
}
if (parentTypeReference == null) {
// Error...
return null;
}
MemberReference retModuleMemberReference;
IName name = this.GetNameFromOffset(memberRefRow.Name);
byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0);
var genericTypeInstance = parentTypeReference as IGenericTypeInstanceReference;
var specializedNestedTypeReference = parentTypeReference as ISpecializedNestedTypeReference;
if (SignatureHeader.IsFieldSignature(firstByte)) {
if (genericTypeInstance != null || specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore special caching is required
FieldReference unspecializedFieldReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as FieldReference;
if (unspecializedFieldReference == null) {
unspecializedFieldReference = new FieldReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name);
this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedFieldReference;
}
uint key1 = parentTypeReference.InternedKey;
uint key2 = unspecializedFieldReference.InternedKey;
var specializedField = this.SpecializedFieldHashtable.Find(key1, key2);
if (specializedField == null) {
specializedField = new SpecializedFieldReference(parentTypeReference, unspecializedFieldReference, this.InternFactory);
this.SpecializedFieldHashtable.Add(key1, key2, specializedField);
}
return specializedField;
} else {
retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name);
}
} else if (SignatureHeader.IsMethodSignature(firstByte)) {
if (genericTypeInstance != null || specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore special caching is required
MethodReference unspecializedMethodReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as MethodReference;
if (unspecializedMethodReference == null) {
unspecializedMethodReference = new MethodReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name, firstByte);
this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedMethodReference;
}
uint key1 = parentTypeReference.InternedKey;
uint key2 = unspecializedMethodReference.InternedKey;
var specializedMethod = this.SpecializedMethodHashtable.Find(key1, key2);
if (specializedMethod == null) {
specializedMethod = new SpecializedMethodReference(parentTypeReference, unspecializedMethodReference, this.InternFactory);
this.SpecializedMethodHashtable.Add(key1, key2, specializedMethod);
}
return specializedMethod;
} else {
retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte);
}
} else {
// MD Error
return null;
}
this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference;
}
MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId];
return ret;
}
static void AddICollectionTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType collectionT, ReferenceFinder referenceFinder)
{
var itemType = collectionT.GenericArguments[0];
var itemArray = itemType.MakeArrayType();
var proxyType = CreateProxy(moduleDefinition, type, referenceFinder);
TypeReference proxyTypeRef = proxyType;
if (type.HasGenericParameters)
{
proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(CloneGenericParameter).ToArray());
}
var field = proxyType.Fields[0];
var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);
var countProperty = type.Properties.First(p => p.Name == "Count" || p.Name == "System.Collections.ICollection.Count");
MethodReference countMethod = countProperty.GetMethod;
MethodReference copyToMethod = type.Methods.First(p => p.Name == "CopyTo" || p.Name == "System.Collections.ICollection.CopyTo");
if (type.HasGenericParameters)
{
countMethod = countMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray());
copyToMethod = copyToMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray());
}
var getMethod = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray);
var getMethodBody = getMethod.Body;
var localItems = new VariableDefinition(itemArray);
getMethodBody.Variables.Add(localItems);
getMethodBody.SimplifyMacros();
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, countMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Newarr, itemType));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Stloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldlen));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Conv_I4));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, copyToMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
getMethodBody.InitLocals = true;
getMethodBody.OptimizeMacros();
proxyType.Methods.Add(getMethod);
var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray)
{
GetMethod = getMethod
};
var debuggerBrowsableAttribute = new CustomAttribute(referenceFinder.DebuggerBrowsableAttributeCtor);
debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(referenceFinder.DebuggerBrowsableStateType, (int)DebuggerBrowsableState.RootHidden));
property.CustomAttributes.Add(debuggerBrowsableAttribute);
proxyType.Properties.Add(property);
AddDebuggerTypeProxyAttribute(type, proxyType, referenceFinder);
}
public void Emit(OpCode opcode, FieldReference field)
{
Append (Create (opcode, field));
}
public static void DoObfuscate(string[] assemblyPath, string uselessCodeLibAssemblyPath, int randomSeed, bool enableNameObfuscate, bool enableCodeInject,
ObfuscateType nameObfuscateType, ObfuscateType codeInjectObfuscateType, ObfuscateNameType obfuscateNameType, int garbageMethodMultiplePerClass, int insertMethodCountPerMethod)
{
if (Application.isPlaying || EditorApplication.isCompiling)
{
Debug.Log("You need stop play mode or wait compiling finished");
return;
}
if (assemblyPath.Length <= 0)
{
Debug.LogError("Obfuscate dll paths length: 0");
}
Debug.Log("Code Obfuscate Start");
var resolver = new DefaultAssemblyResolver();
foreach (var item in Const.ResolverSearchDirs)
{
resolver.AddSearchDirectory(item);
}
var readerParameters = new ReaderParameters {
AssemblyResolver = resolver, ReadSymbols = true
};
AssemblyDefinition[] assemblies = new AssemblyDefinition[assemblyPath.Length];
for (int i = 0; i < assemblyPath.Length; i++)
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyPath[i], readerParameters);
if (assembly == null)
{
Debug.LogError(string.Format("Code Obfuscate Load assembly failed: {0}", assemblyPath[i]));
return;
}
assemblies[i] = assembly;
}
AssemblyDefinition garbageCodeAssmbly = null;
if (enableCodeInject)
{
garbageCodeAssmbly = AssemblyDefinition.ReadAssembly(uselessCodeLibAssemblyPath, readerParameters);
if (garbageCodeAssmbly == null)
{
Debug.LogError(string.Format("Code Obfuscate Load assembly failed: {0}", uselessCodeLibAssemblyPath));
return;
}
}
try
{
//初始化组件
ObfuscatorHelper.Init(randomSeed);
NameObfuscate.Instance.Init(nameObfuscateType);
CodeInject.Instance.Init(codeInjectObfuscateType, garbageMethodMultiplePerClass, insertMethodCountPerMethod);
NameFactory.Instance.Load(obfuscateNameType);
//混淆并注入垃圾代码
for (int i = 0; i < assemblies.Length; i++)
{
var module = assemblies[i].MainModule;
if (enableCodeInject)
{
CodeInject.Instance.DoObfuscate(assemblies[i], garbageCodeAssmbly);
}
if (enableNameObfuscate)
{
NameObfuscate.Instance.DoObfuscate(assemblies[i]);
}
}
//把每个dll对其他被混淆的dll的引用名字修改为混淆后的名字
if (enableNameObfuscate)
{
foreach (var assembly in assemblies)
{
foreach (var item in assembly.MainModule.GetMemberReferences())
{
try
{
if (item is FieldReference)
{
FieldReference fieldReference = item as FieldReference;
Dictionary <BaseObfuscateItem, string> dic = NameFactory.Instance.GetOld_New_NameDic(NameType.Filed);
FieldObfuscateItem fieldObfuscateItem = new FieldObfuscateItem(fieldReference.DeclaringType.Namespace, fieldReference.DeclaringType.Name, fieldReference.Name);
if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Filed, fieldObfuscateItem))
{
item.Name = NameFactory.Instance.GetRandomName(NameType.Filed, fieldObfuscateItem);
}
}
else if (item is PropertyReference)
{
PropertyReference propertyReference = item as PropertyReference;
PropertyObfuscateItem propertyObfuscateItem = new PropertyObfuscateItem(propertyReference.DeclaringType.Namespace, propertyReference.DeclaringType.Name, propertyReference.Name);
if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Property, propertyObfuscateItem))
{
item.Name = NameFactory.Instance.GetRandomName(NameType.Property, propertyObfuscateItem);
}
}
else if (item is MethodReference)
{
MethodReference methodReference = item as MethodReference;
MethodObfuscateItem methodObfuscateItem = new MethodObfuscateItem(methodReference.DeclaringType.Namespace, methodReference.DeclaringType.Name, methodReference.Name);
if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Method, methodObfuscateItem))
{
item.Name = NameFactory.Instance.GetRandomName(NameType.Method, methodObfuscateItem);
}
}
}
catch
{
continue;
}
}
foreach (var item in assembly.MainModule.GetTypeReferences())
{
try
{
TypeDefinition typeDefinition = item.Resolve();
TypeObfuscateItem typeObfuscateItem = ObfuscateItemFactory.Create(typeDefinition);
NamespaceObfuscateItem namespaceObfuscateItem = ObfuscateItemFactory.Create(typeDefinition.Namespace, typeDefinition.Module);
if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Class, typeObfuscateItem))
{
item.Name = NameFactory.Instance.GetRandomName(NameType.Class, typeObfuscateItem);
}
if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Namespace, namespaceObfuscateItem))
{
item.Namespace = NameFactory.Instance.GetRandomName(NameType.Namespace, namespaceObfuscateItem);
}
}
catch
{
continue;
}
}
}
}
for (int i = 0; i < assemblies.Length; i++)
{
assemblies[i].Write(assemblyPath[i], new WriterParameters {
WriteSymbols = true
});
}
Debug.Log("Code Obfuscate Completed!");
}
catch (Exception ex)
{
Debug.LogError(string.Format("Code Obfuscate failed: {0}", ex));
}
finally
{
for (int i = 0; i < assemblies.Length; i++)
{
assemblies[i].MainModule.SymbolReader.Dispose();
}
if (garbageCodeAssmbly != null && garbageCodeAssmbly.MainModule.SymbolReader != null)
{
garbageCodeAssmbly.MainModule.SymbolReader.Dispose();
}
//输出 名字-混淆后名字 的map
NameFactory.Instance.OutputNameMap(Const.NameMapPath);
}
}
public static Instruction Create (OpCode opcode, FieldReference field)
{
if (field == null)
throw new ArgumentNullException ("field");
if (opcode.OperandType != OperandType.InlineField &&
opcode.OperandType != OperandType.InlineTok)
throw new ArgumentException ("opcode");
return new Instruction (opcode, field);
}
public static string IdentifyRegex = "^[A-z,0-9]+$", SplitRegex = null; //example : "FeatureName"
public override IEvalResult[] Eval(IEvalResult[] parameters)
{
//Get parameters
List<BLL.BusinessObjects.Feature> featureReferences = new List<BusinessObjects.Feature>();
foreach (IEvalResult parameter in parameters)
{
try
{
ObjectReference objRef = (ObjectReference)parameter;
featureReferences.Add((BusinessObjects.Feature)objRef.GetReference());
}
catch (Exception ex)
{
throw new SyntaxIncorrectException();
}
}
//Get the Attributes and AttributeValues
List<BLL.BusinessObjects.AttributeValue> attributeValues = new List<BusinessObjects.AttributeValue>();
foreach (BLL.BusinessObjects.Feature featureRef in featureReferences)
{
//Get the Attribute
string attributeIdentifier = _syntaxString;
BusinessObjects.Attribute attribute = _configSession.Model.GetAttributeByIdentifier(featureRef, attributeIdentifier);
if (attribute != null) //if the feature doesn't have the Attribute, it is ignored
{
//Get the AttributeValue
BusinessObjects.AttributeValue attributeValue = _configSession.Configuration.GetAttributeValueByAttributeID(attribute.ID);
attributeValues.Add(attributeValue);
}
}
//Return a list of references pointing to the each of the childFeatures
List<IEvalResult> returnRef = new List<IEvalResult>();
foreach (BLL.BusinessObjects.AttributeValue attrValue in attributeValues)
{
object target = (object)attrValue;
FieldReference objRef = new FieldReference(target, "Value");
returnRef.Add(objRef);
}
return returnRef.ToArray();
}
