/// <summary> /// Allocates memory for the static field and initializes it. /// </summary> /// <param name="field">The field.</param> private void CreateStaticField(RuntimeField field) { Debug.Assert(field != null, @"No field given."); // Determine the size of the type & alignment requirements int size, alignment; architecture.GetTypeRequirements(field.SignatureType, out size, out alignment); size = (int)typeLayout.GetFieldSize(field); // The linker section to move this field into SectionKind section; // Does this field have an RVA? if (field.RVA != 0) { // FIXME: Move a static field into ROData, if it is read-only and can be initialized // using static analysis section = SectionKind.Data; } else { section = SectionKind.BSS; } this.AllocateSpace(field, section, size, alignment); }
/// <summary> /// Allocates memory for the static field and initializes it. /// </summary> /// <param name="field">The field.</param> private void CreateStaticField(RuntimeField field) { Debug.Assert(field != null, "No field given."); // Determine the size of the type & alignment requirements int size, alignment; _architecture.GetTypeRequirements(field.Type, out size, out alignment); // Retrieve the linker IAssemblyLinker linker = _compiler.Pipeline.Find <IAssemblyLinker> (); // The linker section to move this field into SectionKind section; // Does this field have an RVA? if (IntPtr.Zero != field.RVA) { // FIXME: Move a static field into ROData, if it is read-only and can be initialized // using static analysis section = SectionKind.Data; } else { section = SectionKind.BSS; } AllocateSpace(linker, field, section, size, alignment); }
/// <summary> /// Initializes a new instance of <see cref="MemberOperand"/>. /// </summary> /// <param name="field">The runtime field to reference.</param> /// <exception cref="System.ArgumentNullException"><paramref name="field"/> is null.</exception> public MemberOperand(RuntimeField field) : base(field.Type, null, IntPtr.Zero) { if (field == null) throw new ArgumentNullException(@"field"); this.member = field; }
/// <summary> /// Create a new field. /// </summary> /// <param name="name">The name of the field to create.</param> /// <returns>The field that was created.</returns> RuntimeField CreateField(string name) { var field = new RuntimeField(_contract, name); _fields.Add(field); return(field); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> public override bool Equals(RuntimeField other) { CilRuntimeField crf = other as CilRuntimeField; return (crf != null && this.nameIdx == crf.nameIdx && this.signatureBlobIdx == crf.signatureBlobIdx && base.Equals(other) == true); }
private void InitializeStaticValueFromRVA(Stream stream, int size, RuntimeField field) { using (Stream source = field.Module.MetadataModule.GetDataSection((long)field.RVA)) { byte[] data = new byte[size]; source.Read(data, 0, size); stream.Write(data, 0, size); } }
private void InitializeStaticValueFromRVA(Stream stream, int size, RuntimeField field) { using (Stream source = _compiler.Assembly.GetDataSection(field.RVA.ToInt64())) { byte[] data = new byte[size]; source.Read(data, 0, size); stream.Write(data, 0, size); } }
/// <summary> /// Constructor. /// </summary> /// <param name="builder">The parent builder.</param> /// <param name="field">The field to build on.</param> internal FieldBuilder(IContractBuilder <T> builder, RuntimeField field) : base(builder) { Instance = field; if (Instance.Accessor == null) { Instance.Accessor = RuntimeFieldAccessor.From <T>(Instance.Name); } }
public CilRuntimeField(RuntimeField genericField, IMetadataModule module, FieldSignature signature) : base(module, genericField.DeclaringType) { this.Name = genericField.Name; this.Attributes = genericField.Attributes; this.RVA = genericField.RVA; this.Signature = signature; this.SetAttributes(genericField.CustomAttributes); }
/// <summary> /// Initializes a new instance of the <see cref="CilGenericField"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="genericField">The generic field.</param> /// <param name="signature">The signature.</param> /// <param name="declaringType">Type of the declaring.</param> public CilGenericField(ITypeModule module, RuntimeField genericField, FieldSignature signature, CilGenericType declaringType) : base(module, declaringType) { this.Signature = signature; this.Attributes = genericField.Attributes; //TODO //this.SetAttributes(genericField.CustomAttributes); base.Name = genericField.Name; }
/// <summary> /// Discover the property from the given type. /// </summary> /// <typeparam name="TEntity">The entity type.</typeparam> /// <param name="builder">The parent builder to add to.</param> /// <param name="type">The type to discover the properties from.</param> void Discover <TEntity>(ContractBuilder <TEntity> builder, TypeInfo type) { foreach (var property in _fieldDiscovery.Discover(type)) { builder .Field(property.Name) .Accessor(new RuntimeFieldAccessor(property)) .Options(RuntimeField.CreateDefaultOptions(property)); } }
public CilGenericField(IModuleTypeSystem moduleTypeSystem, RuntimeField genericField, FieldSignature signature, CilGenericType declaringType) : base(moduleTypeSystem, declaringType) { this.Signature = signature; this.genericField = genericField; this.Attributes = genericField.Attributes; this.SetAttributes(genericField.CustomAttributes); return; }
/// <summary> /// Initializes a new instance of <see cref="MemberOperand"/>. /// </summary> /// <param name="field">The runtime field to reference.</param> /// <exception cref="System.ArgumentNullException"><paramref name="field"/> is null.</exception> public MemberOperand(RuntimeField field) : base(field.Type, null, IntPtr.Zero) { if (field == null) { throw new ArgumentNullException(@"field"); } this.member = field; }
public CilRuntimeField(IModuleTypeSystem moduleTypeSystem, RuntimeField genericField, FieldSignature signature) : base(moduleTypeSystem, genericField.DeclaringType) { this.Name = genericField.Name; this.Attributes = genericField.Attributes; this.RVA = genericField.RVA; this.Signature = signature; this.SetAttributes(genericField.CustomAttributes); }
/// <summary> /// Initializes a new instance of the <see cref="CilGenericField"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="genericField">The generic field.</param> /// <param name="signature">The signature.</param> /// <param name="declaringType">Type of the declaring.</param> public CilGenericField(ITypeModule module, RuntimeField genericField, FieldSignature signature, CilGenericType declaringType) : base(module, declaringType) { this.Signature = signature; this.Attributes = genericField.Attributes; //TODO //this.SetAttributes(genericField.CustomAttributes); base.Name = genericField.Name; }
public CilGenericField(RuntimeType declaringType, RuntimeField genericField, FieldSignature signature) : base(declaringType.Module, declaringType) { this.genericField = genericField; this.Signature = signature; // FIXME: RVA, Address of these? this.Attributes = genericField.Attributes; this.SetAttributes(genericField.CustomAttributes); }
private void AllocateSpace(IAssemblyLinker linker, RuntimeField field, SectionKind section, int size, int alignment) { using (Stream stream = linker.Allocate(field, section, size, alignment)) { if (IntPtr.Zero != field.RVA) { InitializeStaticValueFromRVA(stream, size, field); } else { WriteDummyBytes(stream, size); } } }
private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment) { using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment)) { if (field.RVA != 0) { InitializeStaticValueFromRVA(stream, size, field); } else { WriteDummyBytes(stream, size); } } }
/// <summary> /// Discover the property from the given type. /// </summary> /// <typeparam name="TEntity">The entity type.</typeparam> /// <param name="builder">The parent builder to add to.</param> /// <param name="type">The type to discover the properties from.</param> static void Discover <TEntity>(ContractBuilder <TEntity> builder, TypeInfo type) { foreach (var property in type.DeclaredProperties) { builder .Field(property.Name) .Accessor(new RuntimeFieldAccessor(property)) .Options(RuntimeField.CreateDefaultOptions(property)); } if (type.BaseType != null && type.BaseType != typeof(object)) { Discover(builder, type.BaseType.GetTypeInfo()); } }
/// <summary> /// Allocates memory for the static field and initializes it. /// </summary> /// <param name="field">The field.</param> private void CreateStaticField(RuntimeField field) { Debug.Assert (field != null, "No field given."); // Determine the size of the type & alignment requirements int size, alignment; _architecture.GetTypeRequirements (field.Type, out size, out alignment); // Retrieve the linker IAssemblyLinker linker = _compiler.Pipeline.Find<IAssemblyLinker> (); // The linker section to move this field into SectionKind section; // Does this field have an RVA? if (IntPtr.Zero != field.RVA) { // FIXME: Move a static field into ROData, if it is read-only and can be initialized // using static analysis section = SectionKind.Data; } else { section = SectionKind.BSS; } AllocateSpace (linker, field, section, size, alignment); }
private void InitializeStaticValueFromRVA(Stream stream, int size, RuntimeField field) { using (Stream source = _compiler.Assembly.GetDataSection (field.RVA.ToInt64 ())) { byte[] data = new byte[size]; source.Read (data, 0, size); stream.Write (data, 0, size); } }
/// <summary> /// Initializes a new instance of the <see cref="ObjectFieldOperand"/> class. /// </summary> /// <param name="objectInstance">The operand, representing the object instance.</param> /// <param name="field">The referenced field.</param> public ObjectFieldOperand(Operand objectInstance, RuntimeField field) : base(field.Type, null, field.Address) { }
private void AllocateSpace(IAssemblyLinker linker, RuntimeField field, SectionKind section, int size, int alignment) { using (Stream stream = linker.Allocate (field, section, size, alignment)) { if (IntPtr.Zero != field.RVA) InitializeStaticValueFromRVA (stream, size, field); else WriteDummyBytes (stream, size); } }
/// <summary> /// Initializes a new instance of the <see cref="StaticFieldOperand"/> class. /// </summary> /// <param name="field">The field.</param> public StaticFieldOperand(RuntimeField field, IntPtr offset) : base(field.SignatureType, null, offset) /* field.Address */ { }
/// <summary> /// Initializes a new instance of the <see cref="ObjectFieldOperand"/> class. /// </summary> /// <param name="objectInstance">The operand, representing the object instance.</param> /// <param name="field">The referenced field.</param> public ObjectFieldOperand(Operand objectInstance, RuntimeField field) : base(field.SignatureType, null, field.Address) { }
/// <summary> /// Allocates memory for the static field and initializes it. /// </summary> /// <param name="field">The field.</param> private void CreateStaticField(RuntimeField field) { Debug.Assert(field != null, @"No field given."); // Determine the size of the type & alignment requirements int size, alignment; _architecture.GetTypeRequirements(field.Type, out size, out alignment); if (field.Type.Type == CilElementType.ValueType) { size = ObjectModelUtility.ComputeTypeSize((field.Type as Metadata.Signatures.ValueTypeSigType).Token, _compiler.Metadata, _architecture); } // Retrieve the linker IAssemblyLinker linker = _compiler.Pipeline.FindFirst<IAssemblyLinker>(); // The linker section to move this field into SectionKind section; // Does this field have an RVA? if (IntPtr.Zero != field.RVA) { // FIXME: Move a static field into ROData, if it is read-only and can be initialized // using static analysis section = SectionKind.Data; } else { section = SectionKind.BSS; } AllocateSpace(linker, field, section, size, alignment); }
int ITypeLayout.GetFieldSize(RuntimeField field) { // If the field is another struct, we have to dig down and compute its size too. if (field.SignatureType.Type == CilElementType.ValueType) { return ((ITypeLayout)this).GetTypeSize(field.DeclaringType); } int size, alignment; architecture.GetTypeRequirements(field.SignatureType, out size, out alignment); return size; }
private void InitializeStaticValueFromRVA(Stream stream, int size, RuntimeField field) { using (Stream source = field.MetadataModule.GetDataSection((long)field.RVA)) { byte[] data = new byte[size]; source.Read(data, 0, size); stream.Write(data, 0, size); } }
/// <summary> /// Creates a new SymbolOperand for the given runtime field. /// </summary> /// <param name="runtimeField">The field to create a symbol operand for.</param> /// <returns>The created symbol operand.</returns> public static SymbolOperand FromField(RuntimeField runtimeField) { return(new SymbolOperand(runtimeField.SignatureType, runtimeField.ToString())); }
/// <summary> /// Initializes a new instance of the <see cref="ObjectFieldOperand"/> class. /// </summary> /// <param name="objectInstance">The operand, representing the object instance.</param> /// <param name="field">The referenced field.</param> public ObjectFieldOperand(Operand objectInstance, RuntimeField field, IntPtr offset) : base(field.SignatureType, null, offset) /* field.Address */ { }
public static void RefactorVariable(VariableData variable, string name, UnityEngine.Object owner) { bool isLocal = false; uNodeRoot graph = owner as uNodeRoot; if (graph == null) { INode <uNodeRoot> node = owner as INode <uNodeRoot>; if (node != null) { graph = node.GetOwner(); isLocal = true; } } if (graph != null) { HashSet <GameObject> referencedGraphs = new HashSet <GameObject>(); if (!isLocal) { RuntimeField field = null; if (graph is IIndependentGraph) { if (GraphUtility.IsTempGraphObject(graph.gameObject)) { var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null); if (prefab != null) { var oriGraph = prefab.GetComponent <uNodeRoot>(); if (oriGraph != null) { field = ReflectionUtils.GetRuntimeType(oriGraph).GetField(variable.Name) as RuntimeField; } } } else { field = ReflectionUtils.GetRuntimeType(graph).GetField(variable.Name) as RuntimeField; } } FieldInfo nativeMember = null; if (graph.GeneratedTypeName.ToType(false) != null) { var type = graph.GeneratedTypeName.ToType(false); nativeMember = type.GetField(variable.Name, MemberData.flags); } var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>(); foreach (var prefab in graphPrefabs) { var gameObject = prefab; GameObject prefabContent = null; if (GraphUtility.HasTempGraphObject(prefab)) { gameObject = GraphUtility.GetTempGraphObject(prefab); } else if (uNodeEditorUtility.IsPrefab(prefab)) { prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(prefab)); gameObject = prefabContent; } var scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true); bool hasUndo = false; Func <object, bool> scriptValidation = (obj) => { MemberData member = obj as MemberData; if (member != null) { var members = member.GetMembers(false); if (members != null) { for (int i = 0; i < members.Length; i++) { var m = members[i]; if (member.namePath.Length > i + 1) { if (m == field || m == nativeMember) { if (!hasUndo && prefabContent == null) { uNodeEditorUtility.RegisterFullHierarchyUndo(gameObject, "Rename Variable: " + variable.Name); hasUndo = true; } var path = member.namePath; path[i + 1] = name; member.name = string.Join(".", path); if (m == nativeMember) { referencedGraphs.Add(prefab); } return(true); } } } } } return(false); }; if (field != null || nativeMember != null) { bool hasChanged = false; Array.ForEach(scripts, script => { bool flag = AnalizerUtility.AnalizeObject(script, scriptValidation); if (flag) { hasChanged = true; hasUndo = false; uNodeGUIUtility.GUIChanged(script); uNodeEditorUtility.MarkDirty(script); } }); if (hasChanged) { if (gameObject != prefab) { uNodeEditorUtility.RegisterFullHierarchyUndo(prefab, "Rename Variable: " + variable.Name); if (prefabContent == null) { //Save the temporary graph GraphUtility.AutoSaveGraph(gameObject); } else { //Save the prefab contents uNodeEditorUtility.SavePrefabAsset(gameObject, prefab); } } uNodeEditorUtility.MarkDirty(prefab); } } if (prefabContent != null) { PrefabUtility.UnloadPrefabContents(prefabContent); } } } string oldVarName = variable.Name; variable.Name = name; Func <object, bool> validation = delegate(object OBJ) { return(CallbackRenameVariable(OBJ, owner, variable.Name, oldVarName)); }; graph.Refresh(); Array.ForEach(graph.nodes, item => AnalizerUtility.AnalizeObject(item, validation)); if (GraphUtility.IsTempGraphObject(graph.gameObject)) { var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null); uNodeEditorUtility.RegisterFullHierarchyUndo(prefab, "Rename Variable: " + oldVarName); GraphUtility.AutoSaveGraph(graph.gameObject); } uNodeEditor.ClearGraphCache(); uNodeEditor.window?.Refresh(true); DoCompileReferences(graph, referencedGraphs); } }
/// <summary> /// Initializes a new instance of the <see cref="StaticFieldOperand"/> class. /// </summary> /// <param name="field">The field.</param> public StaticFieldOperand(RuntimeField field) : base(field.SignatureType, null, field.Address) { }
private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment) { using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment)) { if (field.RVA != 0) { InitializeStaticValueFromRVA(stream, size, field); } else { WriteDummyBytes(stream, size); } } }
/// <summary> /// Constructor. /// </summary> /// <param name="builder">The parent builder.</param> /// <param name="field">The field to build on.</param> internal FieldDeserializationBuilder(FieldBuilder <T> builder, RuntimeField field) : base(builder, field) { }
/// <summary> /// Attempt to find the field with the given name. /// </summary> /// <param name="name">The name of the field to find.</param> /// <param name="field">The field that was found with the given name, or null if not field could be found.</param> /// <returns>true if a field with the given name was found, false if not.</returns> bool TryFindField(string name, out RuntimeField field) { field = _fields.SingleOrDefault(f => String.Equals(f.Name, name, StringComparison.OrdinalIgnoreCase)); return(field != null); }
/// <summary> /// Creates a new SymbolOperand for the given runtime field. /// </summary> /// <param name="runtimeField">The field to create a symbol operand for.</param> /// <returns>The created symbol operand.</returns> public static SymbolOperand FromField(RuntimeField runtimeField) { return new SymbolOperand(runtimeField.SignatureType, runtimeField.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="StaticFieldOperand"/> class. /// </summary> /// <param name="field">The field.</param> public StaticFieldOperand(RuntimeField field) : base(field.Type, null, field.Address) { }
/// <summary> /// Allocates memory for the static field and initializes it. /// </summary> /// <param name="field">The field.</param> private void CreateStaticField(RuntimeField field) { Debug.Assert(field != null, @"No field given."); // Determine the size of the type & alignment requirements int size, alignment; architecture.GetTypeRequirements(field.SignatureType, out size, out alignment); size = (int)((ITypeLayout)this).GetFieldSize(field); // The linker section to move this field into SectionKind section; // Does this field have an RVA? if (field.RVA != 0) { // FIXME: Move a static field into ROData, if it is read-only and can be initialized // using static analysis section = SectionKind.Data; } else { section = SectionKind.BSS; } this.AllocateSpace(field, section, size, alignment); }
/// <summary> /// Parses an elementary field, parameter or property definition. /// </summary> /// <param name="module">The metadata module, which contains the attribute blob.</param> /// <param name="reader">The binary reader to read data From.</param> /// <param name="sigType">The signature type of the field, parameter or property to read.</param> /// <returns>An object, which represents the value read From the attribute blob.</returns> /// <exception cref="System.NotSupportedException"><paramref name="sigType"/> is not yet supported.</exception> private static object ParseElem(IMetadataModule module, BinaryReader reader, SigType sigType) { object result; switch (sigType.Type) { case CilElementType.Boolean: result = (1 == reader.ReadByte()); break; case CilElementType.Char: result = (char)reader.ReadUInt16(); break; case CilElementType.I1: result = reader.ReadSByte(); break; case CilElementType.I2: result = reader.ReadInt16(); break; case CilElementType.I4: result = reader.ReadInt32(); break; case CilElementType.I8: result = reader.ReadInt64(); break; case CilElementType.U1: result = reader.ReadByte(); break; case CilElementType.U2: result = reader.ReadUInt16(); break; case CilElementType.U4: result = reader.ReadUInt32(); break; case CilElementType.U8: result = reader.ReadUInt64(); break; case CilElementType.R4: result = reader.ReadSingle(); break; case CilElementType.R8: result = reader.ReadDouble(); break; case CilElementType.String: result = ParseSerString(reader); break; case CilElementType.Type: { string typeName = ParseSerString(reader); result = Type.GetType(typeName); } break; case CilElementType.Class: { string typeName = ParseSerString(reader); string[] type = typeName.Split(','); if (type.Length > 1) { result = Type.GetType(typeName); } else { result = Type.GetType(typeName + ", " + module.Name); } } break; case CilElementType.ValueType: { ValueTypeSigType vtSigType = sigType as ValueTypeSigType; ITypeSystem ts = RuntimeBase.Instance.TypeLoader; RuntimeType type = ts.GetType(module, vtSigType.Token); RuntimeType baseType = type.BaseType; if ("System" == baseType.Namespace && "Enum" == baseType.Name) { // Retrieve the value__ field to get the enums integer type Debug.Assert(type.Fields.Count == 1, "More than one field in the enum."); RuntimeField value = type.Fields[0]; Debug.Assert(value.Name == "value__", "First field of enum not named value__"); result = ParseElem(module, reader, value.Type); Type enumType = Type.GetType(type.Namespace + "." + type.Name); result = Enum.ToObject(enumType, result); } else { throw new NotSupportedException(); } } break; case CilElementType.Object: throw new NotSupportedException(); default: throw new NotSupportedException(); } return(result); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> public override bool Equals(RuntimeField other) { CilRuntimeField crf = other as CilRuntimeField; return(crf != null && this.nameIdx == crf.nameIdx && this.signature == crf.signature && base.Equals(other) == true); }