public AttributeCleaner(ModuleReader moduleReader, Logger logger) { propertyAttributeNames = new List<string> {"DoNotNotifyAttribute", "NotifyPropertyAttribute", "DependsOnAttribute"}; typeAttributeNames = new List<string> { "NotifyForAllAttribute", "DoNotNotifyAttribute" }; this.moduleReader = moduleReader; this.logger = logger; }
public AssemblyLoaderImporter(ModuleReader moduleReader, AssemblyResolver assemblyResolver, EmbedTask embedTask) { instructionConstructorInfo = typeof (Instruction).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] {typeof (OpCode), typeof (object)}, null); this.moduleReader = moduleReader; this.assemblyResolver = assemblyResolver; this.embedTask = embedTask; }
public ModuleWriter(ModuleReader moduleReader, ProjectKeyReader projectKeyReader, Logger logger, WeavingTask config) { this.moduleReader = moduleReader; this.projectKeyReader = projectKeyReader; this.logger = logger; this.config = config; }
public ResourceEmbedder(DependencyFinder dependencyFinder, ModuleReader moduleReader, EmbedTask embedTask, Logger logger) { streams = new List<Stream>(); this.dependencyFinder = dependencyFinder; this.moduleReader = moduleReader; this.embedTask = embedTask; this.logger = logger; }
public TypeEqualityFinder(ModuleReader moduleReader, MsCoreReferenceFinder msCoreReferenceFinder, TypeResolver typeResolver) { methodCache = new Dictionary<string, MethodReference>(); this.moduleReader = moduleReader; this.msCoreReferenceFinder = msCoreReferenceFinder; this.typeResolver = typeResolver; }
public virtual void Read(ModuleReader reader) { reader.Read(out memberType); reader.Read(out memberName); reader.Read(out memberFlags); reader.Read(out memberSize); reader.Read(out memberAttributes); }
public MethodFinderTest() { var codeBase = typeof(MethodFinderTest).Assembly.CodeBase.Replace("file:///", string.Empty); var module = ModuleDefinition.ReadModule(codeBase); var moduleReader = new ModuleReader(null, null, Substitute.For<Logger>()) { Module = module }; methodFinder = new MethodFinder(new MethodGenerifier(moduleReader), null, null, moduleReader, Substitute.For<Logger>(), null, new EventInvokerNameResolver(null)); typeDefinition = module.Types.First(x => x.Name.EndsWith("MethodFinderTest")); }
public void Read(ModuleReader reader) { reader.Read(out functionType); reader.Read(out numargs); reader.Read(out numlocals); reader.Read(out numblocks); reader.Read(out numexceptions); reader.Read(out vslot); }
public IsChangedMethodFinder(MethodGenerifier methodGenerifier, Logger logger, MsCoreReferenceFinder msCoreReferenceFinder, TypeNodeBuilder typeNodeBuilder, ModuleReader moduleReader, TypeResolver typeResolver) { this.methodGenerifier = methodGenerifier; this.logger = logger; this.msCoreReferenceFinder = msCoreReferenceFinder; this.typeNodeBuilder = typeNodeBuilder; this.moduleReader = moduleReader; this.typeResolver = typeResolver; }
public void Read(ModuleReader reader) { reader.Read(out baseStructure); reader.Read(out numinterfaces); reader.Read(out numfields); reader.Read(out numvmethods); reader.Read(out numcontracts); reader.Read(out nummembers); }
public MethodFinder(MethodGenerifier methodGenerifier, MethodInjector methodInjector, TypeNodeBuilder typeNodeBuilder, ModuleReader moduleReader, Logger logger, TypeResolver typeResolver, EventInvokerNameResolver eventInvokerNameResolver) { this.methodGenerifier = methodGenerifier; this.methodInjector = methodInjector; this.typeNodeBuilder = typeNodeBuilder; this.moduleReader = moduleReader; this.logger = logger; this.typeResolver = typeResolver; this.eventInvokerNameResolver = eventInvokerNameResolver; }
internal static Type[] ReadMethodSpec(ModuleReader module, ByteReader br, IGenericContext context) { if (br.ReadByte() != GENERICINST) { throw new BadImageFormatException(); } Type[] args = new Type[br.ReadCompressedInt()]; for (int i = 0; i < args.Length; i++) { args[i] = ReadType(module, br, context); } return(args); }
public static ModuleDefinition ReadModule(Stream stream, ReaderParameters parameters) { CheckStream(stream); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException(); } Mixin.CheckParameters(parameters); return(ModuleReader.CreateModuleFrom( ImageReader.ReadImageFrom(stream), parameters)); }
internal static new void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal interface and register it. Interface iface = new Interface(module); module.RegisterMember(iface); // Read the name. iface.name = module.GetString(header.memberName); iface.flags = (MemberFlags)header.memberFlags; // Skip the class elements. reader.Skip(header.memberSize); }
public static SAMPLOAD SL_RegisterSample(SAMPLE s, int type, ModuleReader reader) { SAMPLOAD news; SAMPLOAD cruise = null; if (type == (int)SharpMikCommon.MDTypes.MD_MUSIC) { cruise = musiclist; } else if (type == (int)SharpMikCommon.MDTypes.MD_SNDFX) { cruise = sndfxlist; } else { return(null); } /* Allocate and add structure to the END of the list */ news = new SAMPLOAD(); if (cruise != null) { while (cruise.next != null) { cruise = cruise.next; } cruise.next = news; } else { if (type == (int)SharpMikCommon.MDTypes.MD_MUSIC) { musiclist = news; } else if (type == (int)SharpMikCommon.MDTypes.MD_SNDFX) { sndfxlist = news; } } news.infmt = (uint)(s.flags & SharpMikCommon.SF_FORMATMASK); news.outfmt = news.infmt; news.reader = reader; news.sample = s; news.length = s.length; news.loopstart = s.loopstart; news.loopend = s.loopend; return(news); }
internal static void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal field and register it. FieldVariable field = new FieldVariable(module); module.RegisterMember(field); // Read the name and flags. field.SetName(module.GetString(header.memberName)); field.flags = (MemberFlags)header.memberFlags; // Skip the structure elements. reader.Skip(header.memberSize); }
internal new static void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal interface and register it. Interface iface = new Interface(module); module.RegisterMember(iface); // Read the name. iface.name = module.GetString(header.memberName); iface.flags = (MemberFlags)header.memberFlags; // Skip the class elements. reader.Skip(header.memberSize); }
private static bool ML_LoadSamples(Module of, ModuleReader modreader) { int u; for (u = 0; u < of.numsmp; u++) { if (of.samples[u].length != 0) { SampleLoader.SL_RegisterSample(of.samples[u], (int)SharpMikCommon.MDTypes.MD_MUSIC, modreader); } } return(true); }
internal static void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal event and register it. EventVariable ev = new EventVariable(module); module.RegisterMember(ev); // Read the name and flags. ev.SetName(module.GetString(header.memberName)); ev.flags = (MemberFlags)header.memberFlags; // Skip the structure elements. reader.Skip(header.memberSize); }
internal override void Read(ModuleReader reader, MemberHeader header) { // Get the module. ChelaModule module = GetModule(); // Read the type. type = module.GetType(reader.ReadUInt()); // Read the add modifier. addModifier = (Function)module.GetMember(reader.ReadUInt()); // Read the remove modifier. removeModifier = (Function)module.GetMember(reader.ReadUInt()); }
internal static FieldSignature ReadSig(ModuleReader module, ByteReader br, IGenericContext context) { if (br.ReadByte() != FIELD) { throw new BadImageFormatException(); } Type fieldType; Type[] optionalCustomModifiers; Type[] requiredCustomModifiers; ReadCustomModifiers(module, br, context, out requiredCustomModifiers, out optionalCustomModifiers); fieldType = ReadType(module, br, context); return(new FieldSignature(fieldType, optionalCustomModifiers, requiredCustomModifiers)); }
private static Type ReadFunctionPointer(ModuleReader module, ByteReader br, IGenericContext context) { __StandAloneMethodSig sig = MethodSignature.ReadStandAloneMethodSig(module, br, context); if (module.universe.EnableFunctionPointers) { return(FunctionPointerType.Make(module.universe, sig)); } else { // by default, like .NET we return System.IntPtr here return(module.universe.System_IntPtr); } }
internal static PropertySignature ReadSig(ModuleReader module, ByteReader br, IGenericContext context) { byte flags = br.ReadByte(); if ((flags & PROPERTY) == 0) { throw new BadImageFormatException(); } CallingConventions callingConvention = CallingConventions.Standard; if ((flags & HASTHIS) != 0) { callingConvention |= CallingConventions.HasThis; } if ((flags & EXPLICITTHIS) != 0) { callingConvention |= CallingConventions.ExplicitThis; } Type returnType; Type[] returnTypeRequiredCustomModifiers; Type[] returnTypeOptionalCustomModifiers; Type[] parameterTypes; Type[][] parameterRequiredCustomModifiers; Type[][] parameterOptionalCustomModifiers; int paramCount = br.ReadCompressedInt(); ReadCustomModifiers(module, br, context, out returnTypeRequiredCustomModifiers, out returnTypeOptionalCustomModifiers); returnType = ReadRetType(module, br, context); parameterTypes = new Type[paramCount]; parameterRequiredCustomModifiers = null; parameterOptionalCustomModifiers = null; for (int i = 0; i < parameterTypes.Length; i++) { if (IsCustomModifier(br.PeekByte())) { if (parameterOptionalCustomModifiers == null) { parameterOptionalCustomModifiers = new Type[parameterTypes.Length][]; parameterRequiredCustomModifiers = new Type[parameterTypes.Length][]; } ReadCustomModifiers(module, br, context, out parameterRequiredCustomModifiers[i], out parameterOptionalCustomModifiers[i]); } parameterTypes[i] = ReadParam(module, br, context); } return(new PropertySignature(callingConvention, returnType, returnTypeOptionalCustomModifiers, returnTypeRequiredCustomModifiers, parameterTypes, parameterOptionalCustomModifiers, parameterRequiredCustomModifiers)); }
private static Type ReadTypeOrByRef(ModuleReader module, ByteReader br, IGenericContext context) { if (br.PeekByte() == ELEMENT_TYPE_BYREF) { br.ReadByte(); // LAMESPEC it is allowed (by C++/CLI, ilasm and peverify) to have custom modifiers after the BYREF // (which makes sense, as it is analogous to pointers) CustomModifiers mods = ReadCustomModifiers(module, br, context); // C++/CLI generates void& local variables, so we need to use ReadTypeOrVoid here return(ReadTypeOrVoid(module, br, context).__MakeByRefType(mods.required, mods.optional)); } else { return(ReadType(module, br, context)); } }
protected static Type ReadRetType(ModuleReader module, ByteReader br, IGenericContext context) { switch (br.PeekByte()) { case ELEMENT_TYPE_VOID: br.ReadByte(); return(module.universe.System_Void); case ELEMENT_TYPE_TYPEDBYREF: br.ReadByte(); return(module.universe.System_TypedReference); default: return(ReadTypeOrByRef(module, br, context)); } }
public CodeBlock DecompileCodeBlock(CodeBlockDefinition blockDefinition) { Position = blockDefinition.Offset; var instrBuilder = ImmutableArray.CreateBuilder <Instruction>(); var refCollector = new ReferenceCollector(Module); ImmutableArray <byte> unrecognizedBytes = ImmutableArray <byte> .Empty; do { Instruction currInstruction = null; try { currInstruction = NextInstruction(); if (currInstruction is EndOfScriptInstruction) { break; } if (instrBuilder.Count > 0) { var last = instrBuilder[instrBuilder.Count - 1]; currInstruction.Previous = last; last.Next = currInstruction; } } catch (UnrecognizedInstructionException) { unrecognizedBytes = ModuleReader.ReadBytes(blockDefinition.EndOffset - Position).ToImmutableArray(); break; } instrBuilder.Add(currInstruction); refCollector.Visit(currInstruction); } while (Position < blockDefinition.EndOffset); return(new CodeBlock(blockDefinition) { Instructions = instrBuilder.ToImmutable(), UnrecognizedBytes = unrecognizedBytes, StringReferences = refCollector.Strings, CodeBlockReferences = refCollector.CodeBlocks, ExternalCodeBlockReferences = refCollector.ExternalCodeBlocks, DataBlockReferences = refCollector.DataBlocks }); }
private static Type ReadGenericInst(ModuleReader module, ByteReader br, IGenericContext context) { Type type; switch (br.ReadByte()) { case ELEMENT_TYPE_CLASS: type = ReadTypeDefOrRefEncoded(module, br, context).MarkNotValueType(); break; case ELEMENT_TYPE_VALUETYPE: type = ReadTypeDefOrRefEncoded(module, br, context).MarkValueType(); break; default: throw new BadImageFormatException(); } if (!type.__IsMissing && !type.IsGenericTypeDefinition) { throw new BadImageFormatException(); } int genArgCount = br.ReadCompressedInt(); Type[] args = new Type[genArgCount]; Type[][] reqmod = null; Type[][] optmod = null; for (int i = 0; i < genArgCount; i++) { // LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for genericinst, but C++ uses it, the verifier allows it and ildasm also supports it CustomModifiers mods = ReadCustomModifiers(module, br, context); if (mods.required != null || mods.optional != null) { if (reqmod == null) { reqmod = new Type[genArgCount][]; optmod = new Type[genArgCount][]; } reqmod[i] = mods.required; optmod[i] = mods.optional; } args[i] = ReadType(module, br, context); } return(GenericTypeInstance.Make(type, args, reqmod, optmod)); }
private static Type ReadTypeDefOrRefEncoded(ModuleReader module, ByteReader br, IGenericContext context) { int encoded = br.ReadCompressedInt(); switch (encoded & 3) { case 0: return(module.ResolveType((TypeDefTable.Index << 24) + (encoded >> 2), null, null)); case 1: return(module.ResolveType((TypeRefTable.Index << 24) + (encoded >> 2), null, null)); case 2: return(module.ResolveType((TypeSpecTable.Index << 24) + (encoded >> 2), context)); default: throw new BadImageFormatException(); } }
private static CustomModifiers ReadCustomModifiers(ModuleReader module, ByteReader br, IGenericContext context) { CustomModifiers mods = new CustomModifiers(); byte b = br.PeekByte(); if (IsCustomModifier(b)) { List <Type> required = new List <Type>(); List <Type> optional = new List <Type>(); while (IsCustomModifier(b)) { bool req = br.ReadByte() == ELEMENT_TYPE_CMOD_REQD; Type type = ReadTypeDefOrRefEncoded(module, br, context); (req ? required : optional).Add(type); b = br.PeekByte(); } mods.required = required.ToArray(); mods.optional = optional.ToArray(); } return(mods); }
private Module LoadModule(int index, byte[] rawModule, string name) { string location = name == null ? null : Path.Combine(Path.GetDirectoryName(this.location), name); if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0) { return(externalModules[index] = new ResourceModule(manifestModule, index, location)); } else { if (rawModule == null) { try { rawModule = File.ReadAllBytes(location); } catch (FileNotFoundException) { if (resolvers != null) { ResolveEventArgs arg = new ResolveEventArgs(name, this); foreach (ModuleResolveEventHandler resolver in resolvers) { Module module = resolver(this, arg); if (module != null) { return(module); } } } if (universe.MissingMemberResolution) { return(externalModules[index] = new MissingModule(this, index)); } throw; } } return(externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location, false)); } }
internal override void Read(ModuleReader reader, MemberHeader header) { // Read the type and slot. uint typeId = reader.ReadUInt(); slot = reader.ReadInt(); // Load the field type. this.type = GetModule().GetType(typeId); uint initializerSize = header.memberSize - 8; if (!type.IsConstant() || IsExternal()) { // Skip the initializer. reader.Skip(initializerSize); } else { // Load the initializer. initializer = ConstantValue.ReadQualified(GetModule(), reader); } }
// Start is called before the first frame update void Awake() { outputStarted = false; tilemapCompleted = false; modules = modulesParent.GetComponentsInChildren <Module>().ToList(); customGrid = FindObjectOfType <CustomGrid>(); customGrid.mapObject = mapObject; inputReader = new ModuleReader(modules.ToArray()); for (int i = 0; i < mapObject.transform.childCount; ++i) { Destroy(mapObject.transform.GetChild(i).gameObject); } if (inputReader.GotInput) { InitializeGrid(); } //GetPlayerPlacedTiles(); }
public static AssemblyName GetAssemblyName(string path) { try { path = Path.GetFullPath(path); using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) { ModuleReader module = new ModuleReader(null, null, fs, path); if (module.Assembly == null) { throw new BadImageFormatException("Module does not contain a manifest"); } return(module.Assembly.GetName()); } } catch (IOException x) { throw new FileNotFoundException(x.Message, x); } catch (UnauthorizedAccessException x) { throw new FileNotFoundException(x.Message, x); } }
private void Th_Window_Init() { // icm32.dll ModuleReader.WaitForModule("mscms.dll", Process, null); Console.WriteLine($"{account.Nickname} configuring Windowsize"); Window_MoveTo_Default(); Window_ScaleTo_Default(); int i = 0; while (i < 3 && account.Settings.WinConfig.IsConfigured(Process) != true) { try { Window_MoveTo_Default(); Window_ScaleTo_Default(); } catch { } Thread.Sleep(500); i++; } }
internal static CustomModifiers Read(ModuleReader module, ByteReader br, IGenericContext context) { byte b = br.PeekByte(); if (!IsCustomModifier(b)) { return(new CustomModifiers()); } List <Type> list = new List <Type>(); Type mode = Initial; do { Type cmod = br.ReadByte() == Signature.ELEMENT_TYPE_CMOD_REQD ? MarkerType.ModReq : MarkerType.ModOpt; if (mode != cmod) { mode = cmod; list.Add(mode); } list.Add(Signature.ReadTypeDefOrRefEncoded(module, br, context)); b = br.PeekByte(); }while (IsCustomModifier(b)); return(new CustomModifiers(list.ToArray())); }
/// <summary> /// Loads a new instance of <see cref="CILModule"/> with a contents from <paramref name="stream"/>. /// Useful for multi-module assemblies when one doesn't want to load whole assembly. /// </summary> /// <param name="ctx">The current <see cref="CILReflectionContext"/>.</param> /// <param name="stream">The stream to load module from.</param> /// <param name="eArgs">The <see cref="EmittingArguments"/> during loading. After successful module load, the additional information about the module will be available in this object.</param> /// <returns>A new instance of <see cref="CILModule"/> form the contents of the <paramref name="stream"/>.</returns> /// <exception cref="ArgumentNullException">If <paramref name="ctx"/> or <paramref name="stream"/> or <paramref name="eArgs"/> is <c>null</c>.</exception> /// <exception cref="BadImageFormatException">If the headers or metadata section of the stream has invalid values, or stream contents are otherwise malformed.</exception> /// <remarks> /// If the module returned by this method is main module, that is, its <c>Assembly</c> table has exactly one row, then the <see cref="EmittingArguments.ModuleAssemblyLoader"/> callback of <paramref name="eArgs"/> will never be used. /// Therefore it is ok to pass <c>null</c> as the callback to <paramref name="eArgs"/> if the caller is certain the module will always be the main module. /// However, when the module is not the main module, the callback will be used. /// If in that situation the callback is <c>null</c>, <see cref="InvalidOperationException"/> is thrown. /// The callback may be invoked only by accessing the <see cref="CILModule.Assembly"/> property of the returned <see cref="CILModule"/>. /// </remarks> public static CILModule LoadModule(this CILReflectionContext ctx, Stream stream, EmittingArguments eArgs) { ModuleReader mr = null; MetaDataReader md = null; var ownerAssembly = eArgs.ModuleAssemblyLoader; var result = LoadModule((CILReflectionContextImpl)ctx, stream, eArgs, mod => { CILAssemblyImpl ass; if (md.assembly.Length == 1) { ass = LoadAssembly((CILReflectionContextImpl)ctx, null, eArgs, mr, md, mod); } else { if (ownerAssembly == null) { throw new InvalidOperationException("The callback to get assembly of this module was not provided."); } ass = (CILAssemblyImpl)ownerAssembly(mod); var mods = ass.InternalModules; lock (mods.Lock) { if (!mods.Value.CQ.Contains(mod)) { mods.Value.Add(mod); } } } return(ass); }, out mr, out md); if (!eArgs.LazyLoad) { ForceLoadModule(result); } return(result); }
public FileChangedChecker(Logger logger, WeavingTask config, ModuleReader moduleReader) { namespaceKey = config.GetType().Namespace.Replace(".", string.Empty); this.logger = logger; this.moduleReader = moduleReader; }
public MethodGenerifier(ModuleReader moduleReader) { this.moduleReader = moduleReader; }
public void Execute() { try { var referenceFinder = new AssemblyReferenceFinder(this, Logger); referenceFinder.Execute(); var assemblyResolver = new AssemblyResolver(referenceFinder); var reader = new ModuleReader { AssemblyResolver = assemblyResolver, InnerWeaver = this, Logger = Logger }; reader.Execute(); var weaverInitialiser = new WeaverInitialiser { ModuleDefinition = reader.ModuleDefinition, AssemblyResolver = assemblyResolver, InnerWeaver = this, Logger = Logger }; weaverInitialiser.Execute(); var weaverRunner = new ModuleWeaverRunner { Logger = Logger, }; Logger.LogInfo(""); foreach (var weaverInstance in weaverInitialiser.WeaverInstances) { var weaverName = ObjectTypeName.GetAssemblyName(weaverInstance); Logger.SetCurrentWeaverName(weaverName); try { weaverRunner.Execute(weaverInstance); } catch (Exception exception) { Logger.LogError(exception.ToFriendlyString()); return; } finally { Logger.ClearWeaverName(); } } var keyFinder = new StrongNameKeyFinder { InnerWeaver = this, Logger = Logger, ModuleDefinition = reader.ModuleDefinition }; keyFinder.Execute(); var moduleWriter = new ModuleWriter { InnerWeaver = this, Logger = Logger, ModuleDefinition = reader.ModuleDefinition, StrongNameKeyFinder = keyFinder, }; moduleWriter.Execute(); } catch (Exception exception) { Logger.LogError(exception.ToFriendlyString()); } }
public InterceptorFinder(ModuleReader moduleReader) { this.moduleReader = moduleReader; }
public FileChangedChecker(Logger logger, ModuleReader moduleReader) { this.logger = logger; this.moduleReader = moduleReader; }
// see ECMA 335 CLI spec June 2006 section 23.2.12 for this production protected static Type ReadType(ModuleReader module, ByteReader br, IGenericContext context) { CustomModifiers mods; switch (br.ReadByte()) { case ELEMENT_TYPE_CLASS: case ELEMENT_TYPE_VALUETYPE: return(ReadTypeDefOrRefEncoded(module, br, context)); case ELEMENT_TYPE_BOOLEAN: return(module.universe.System_Boolean); case ELEMENT_TYPE_CHAR: return(module.universe.System_Char); case ELEMENT_TYPE_I1: return(module.universe.System_SByte); case ELEMENT_TYPE_U1: return(module.universe.System_Byte); case ELEMENT_TYPE_I2: return(module.universe.System_Int16); case ELEMENT_TYPE_U2: return(module.universe.System_UInt16); case ELEMENT_TYPE_I4: return(module.universe.System_Int32); case ELEMENT_TYPE_U4: return(module.universe.System_UInt32); case ELEMENT_TYPE_I8: return(module.universe.System_Int64); case ELEMENT_TYPE_U8: return(module.universe.System_UInt64); case ELEMENT_TYPE_R4: return(module.universe.System_Single); case ELEMENT_TYPE_R8: return(module.universe.System_Double); case ELEMENT_TYPE_I: return(module.universe.System_IntPtr); case ELEMENT_TYPE_U: return(module.universe.System_UIntPtr); case ELEMENT_TYPE_STRING: return(module.universe.System_String); case ELEMENT_TYPE_OBJECT: return(module.universe.System_Object); case ELEMENT_TYPE_VAR: return(context.GetGenericTypeArgument(br.ReadCompressedInt())); case ELEMENT_TYPE_MVAR: return(context.GetGenericMethodArgument(br.ReadCompressedInt())); case ELEMENT_TYPE_GENERICINST: return(ReadGenericInst(module, br, context)); case ELEMENT_TYPE_SZARRAY: mods = ReadCustomModifiers(module, br, context); return(ReadType(module, br, context).__MakeArrayType(mods.required, mods.optional)); case ELEMENT_TYPE_ARRAY: mods = ReadCustomModifiers(module, br, context); return(ReadType(module, br, context).__MakeArrayType(ReadArrayShape(br), mods.required, mods.optional)); case ELEMENT_TYPE_PTR: mods = ReadCustomModifiers(module, br, context); return(ReadTypeOrVoid(module, br, context).__MakePointerType(mods.required, mods.optional)); case ELEMENT_TYPE_FNPTR: return(ReadFunctionPointer(module, br, context)); default: throw new BadImageFormatException(); } }
internal static void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal field and register it. FieldVariable field = new FieldVariable(module); module.RegisterMember(field); // Read the name and flags. field.SetName(module.GetString(header.memberName)); field.flags = (MemberFlags)header.memberFlags; // Skip the structure elements. reader.Skip(header.memberSize); }
public IsChangedMethodFinder(MethodGenerifier methodGenerifier, Logger logger, MsCoreReferenceFinder msCoreReferenceFinder, TypeNodeBuilder typeNodeBuilder, ModuleReader moduleReader, TypeResolver typeResolver) { this.methodGenerifier = methodGenerifier; this.logger = logger; this.msCoreReferenceFinder = msCoreReferenceFinder; this.typeNodeBuilder = typeNodeBuilder; this.moduleReader = moduleReader; this.typeResolver = typeResolver; }
internal override void Read(ModuleReader reader, MemberHeader header) { // Read the type and slot. uint typeId = reader.ReadUInt(); slot = reader.ReadInt(); // Load the field type. this.type = GetModule().GetType(typeId); uint initializerSize = header.memberSize - 8; if(!type.IsConstant() || IsExternal()) { // Skip the initializer. reader.Skip(initializerSize); } else { // Load the initializer. initializer = ConstantValue.ReadQualified(GetModule(), reader); } }
public ModuleLoaderImporter(ModuleReader moduleReader, AssemblyLoaderImporter assemblyLoaderImporter, MsCoreReferenceFinder coreReferenceFinder) { this.moduleReader = moduleReader; this.assemblyLoaderImporter = assemblyLoaderImporter; this.coreReferenceFinder = coreReferenceFinder; }
internal override void Read(ModuleReader reader, MemberHeader header) { // Get the module. ChelaModule module = GetModule(); // Read the type. type = module.GetType(reader.ReadUInt()); // Read the add modifier. addModifier = (Function)module.GetMember(reader.ReadUInt()); // Read the remove modifier. removeModifier = (Function)module.GetMember(reader.ReadUInt()); }
internal RawModule(ModuleReader module) { this.module = module; this.isManifestModule = module.Assembly != null; }
public ResourceCaseFixer(DependencyFinder dependencyFinder, ModuleReader moduleReader, EmbedTask embedTask, Logger logger) { this.moduleReader = moduleReader; }
public FieldToPropertyForwarder(ModuleReader moduleReader, FieldToPropertyConverter fieldToPropertyConverter, MsCoreReferenceFinder msCoreReferenceFinder) { this.moduleReader = moduleReader; this.msCoreReferenceFinder = msCoreReferenceFinder; forwardedFields = fieldToPropertyConverter.ForwardedFields; }
public FieldToPropertyForwarder(ModuleReader moduleReader, FieldToPropertyConverter fieldToPropertyConverter, MsCoreReferenceFinder msCoreReferenceFinder) { this.moduleReader = moduleReader; this.msCoreReferenceFinder = msCoreReferenceFinder; forwardedFields = fieldToPropertyConverter.ForwardedFields; }
internal ManifestResourceInfo(ModuleReader module, int index) { this.module = module; this.index = index; }
public TypeNodeBuilder(ModuleReader moduleReader, NotifyInterfaceFinder notifyInterfaceFinder, TypeResolver typeResolver) { this.moduleReader = moduleReader; this.notifyInterfaceFinder = notifyInterfaceFinder; this.typeResolver = typeResolver; }
public void Read() { var reader = new ModuleReader(Input); Program.Assert(reader.ReadHeader(), "ReadHeader"); SectionHeader sh; while (reader.ReadSectionHeader(out sh)) { if (sh.StreamPayloadEnd > reader.Reader.BaseStream.Length) { throw new Exception("Invalid header"); } SectionHeaders.Add(sh); switch (sh.id) { case SectionTypes.Type: Program.Assert(reader.ReadTypeSection(out Types)); break; case SectionTypes.Import: Program.Assert(reader.ReadImportSection(out Imports)); break; case SectionTypes.Function: Program.Assert(reader.ReadFunctionSection(out Functions)); break; case SectionTypes.Table: // FIXME: Not tested Program.Assert(reader.ReadTableSection(out Tables)); break; case SectionTypes.Global: Program.Assert(reader.ReadGlobalSection(out Globals)); break; case SectionTypes.Export: Program.Assert(reader.ReadExportSection(out Exports)); break; case SectionTypes.Element: Program.Assert(reader.ReadElementSection(out Elements)); break; case SectionTypes.Code: Program.Assert(reader.ReadCodeSection(out Code, FunctionBodyCallback)); break; case SectionTypes.Data: DataSection ds; Program.Assert(reader.ReadDataSection(out ds)); Input.BaseStream.Seek(sh.StreamPayloadEnd, SeekOrigin.Begin); break; case SectionTypes.Custom: if (sh.name == "name") { ReadNameSection(reader, Input, sh); } Input.BaseStream.Seek(sh.StreamPayloadEnd, SeekOrigin.Begin); break; default: Input.BaseStream.Seek(sh.StreamPayloadEnd, SeekOrigin.Begin); break; } } }
public ReferenceCleaner(ModuleReader moduleReader, Logger logger) { this.moduleReader = moduleReader; this.logger = logger; }
public MsCoreReferenceFinder(ModuleReader moduleReader, IAssemblyResolver assemblyResolver) { this.moduleReader = moduleReader; this.assemblyResolver = assemblyResolver; }
internal static void PreloadMember(ChelaModule module, ModuleReader reader, MemberHeader header) { // Create the temporal event and register it. EventVariable ev = new EventVariable(module); module.RegisterMember(ev); // Read the name and flags. ev.SetName(module.GetString(header.memberName)); ev.flags = (MemberFlags)header.memberFlags; // Skip the structure elements. reader.Skip(header.memberSize); }