public override bool Equals(object obj) { if ((obj == null) || !(obj is __ExceptionInstance)) { return(false); } __ExceptionInstance instance = (__ExceptionInstance)obj; return(((((instance.m_exceptionClass == this.m_exceptionClass) && (instance.m_startAddress == this.m_startAddress)) && ((instance.m_endAddress == this.m_endAddress) && (instance.m_filterAddress == this.m_filterAddress))) && (instance.m_handleAddress == this.m_handleAddress)) && (instance.m_handleEndAddress == this.m_handleEndAddress)); }
// Satisfy JVC's value class requirements public override bool Equals(Object obj) { if (obj != null && (obj is __ExceptionInstance)) { __ExceptionInstance that = (__ExceptionInstance)obj; return(that.m_exceptionClass == m_exceptionClass && that.m_startAddress == m_startAddress && that.m_endAddress == m_endAddress && that.m_filterAddress == m_filterAddress && that.m_handleAddress == m_handleAddress && that.m_handleEndAddress == m_handleEndAddress); } else { return(false); } }
/********************************************** * Sets the IL of the method. An ILGenerator is passed as an argument and the method * queries this instance to get all of the information which it needs. * @param il An ILGenerator with some il defined. * @exception ArgumentException if <EM>il</EM> is null. **********************************************/ internal void CreateMethodBodyHelper(ILGenerator il) { __ExceptionInfo[] excp; int counter = 0; int[] filterAddrs; int[] catchAddrs; int[] catchEndAddrs; Type[] catchClass; int[] type; int numCatch; int start, end; ModuleBuilder dynMod = (ModuleBuilder)m_module; m_containingType.ThrowIfCreated(); if (m_bIsBaked) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodHasBody")); } if (il == null) { throw new ArgumentNullException("il"); } if (il.m_methodBuilder != this && il.m_methodBuilder != null) { // you don't need to call CreateMethodBody when you get your ILGenerator // through MethodBuilder::GetILGenerator. // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadILGeneratorUsage")); } if ((m_dwMethodImplFlags & MethodImplAttributes.PreserveSig) != 0 || (m_dwMethodImplFlags & MethodImplAttributes.CodeTypeMask) != MethodImplAttributes.IL || (m_dwMethodImplFlags & MethodImplAttributes.Unmanaged) != 0 || (m_iAttributes & MethodAttributes.PinvokeImpl) != 0) { // cannot attach method body if methodimpl is marked not marked as managed IL // @todo: what error should we throw here? // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ShouldNotHaveMethodBody")); } if (il.m_ScopeTree.m_iOpenScopeCount != 0) { // There are still unclosed local scope throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_OpenLocalVariableScope")); } m_ubBody = il.BakeByteArray(); m_RVAFixups = il.GetRVAFixups(); mm_mdMethodFixups = il.GetTokenFixups(); //Okay, now the fun part. Calculate all of the exceptions. excp = il.GetExceptions(); m_numExceptions = CalculateNumberOfExceptions(excp); if (m_numExceptions > 0) { m_exceptions = new __ExceptionInstance[m_numExceptions]; for (int i = 0; i < excp.Length; i++) { filterAddrs = excp[i].GetFilterAddresses(); catchAddrs = excp[i].GetCatchAddresses(); catchEndAddrs = excp[i].GetCatchEndAddresses(); catchClass = excp[i].GetCatchClass(); // track the reference of the catch class for (int j = 0; j < catchClass.Length; j++) { if (catchClass[j] != null) { dynMod.GetTypeToken(catchClass[j]); } } numCatch = excp[i].GetNumberOfCatches(); start = excp[i].GetStartAddress(); end = excp[i].GetEndAddress(); type = excp[i].GetExceptionTypes(); for (int j = 0; j < numCatch; j++) { int tkExceptionClass = 0; if (catchClass[j] != null) { tkExceptionClass = dynMod.GetTypeToken(catchClass[j]).Token; } switch (type[j]) { case __ExceptionInfo.None: case __ExceptionInfo.Fault: case __ExceptionInfo.Filter: m_exceptions[counter++] = new __ExceptionInstance(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; case __ExceptionInfo.Finally: m_exceptions[counter++] = new __ExceptionInstance(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; } } } } m_bIsBaked = true; if (dynMod.GetSymWriter() != null) { // set the debugging information such as scope and line number // if it is in a debug module // SymbolToken tk = new SymbolToken(m_mdMethod.Token); ISymbolWriter symWriter = dynMod.GetSymWriter(); // call OpenMethod to make this method the current method symWriter.OpenMethod(tk); // call OpenScope because OpenMethod no longer implicitly creating // the top-levelsmethod scope // symWriter.OpenScope(0); if (m_localSymInfo != null) { m_localSymInfo.EmitLocalSymInfo(symWriter); } il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.m_length); symWriter.CloseMethod(); } }
internal void CreateMethodBodyHelper(ILGenerator il) { // Sets the IL of the method. An ILGenerator is passed as an argument and the method // queries this instance to get all of the information which it needs. __ExceptionInfo[] excp; int counter=0; int[] filterAddrs; int[] catchAddrs; int[] catchEndAddrs; Type[] catchClass; int[] type; int numCatch; int start, end; ModuleBuilder dynMod = (ModuleBuilder) m_module; m_containingType.ThrowIfCreated(); if (m_bIsBaked) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodHasBody")); } if (il==null) { throw new ArgumentNullException("il"); } if (il.m_methodBuilder != this && il.m_methodBuilder != null) { // you don't need to call CreateMethodBody when you get your ILGenerator // through MethodBuilder::GetILGenerator. // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadILGeneratorUsage")); } ThrowIfShouldNotHaveBody(); if (il.m_ScopeTree.m_iOpenScopeCount != 0) { // There are still unclosed local scope throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_OpenLocalVariableScope")); } m_ubBody = il.BakeByteArray(); m_RVAFixups = il.GetRVAFixups(); m_mdMethodFixups = il.GetTokenFixups(); //Okay, now the fun part. Calculate all of the exceptions. excp = il.GetExceptions(); m_numExceptions = CalculateNumberOfExceptions(excp); if (m_numExceptions>0) { m_exceptions = new __ExceptionInstance[m_numExceptions]; for (int i=0; i<excp.Length; i++) { filterAddrs = excp[i].GetFilterAddresses(); catchAddrs = excp[i].GetCatchAddresses(); catchEndAddrs = excp[i].GetCatchEndAddresses(); catchClass = excp[i].GetCatchClass(); // track the reference of the catch class for (int j=0; j < catchClass.Length; j++) { if (catchClass[j] != null) dynMod.GetTypeToken(catchClass[j]); } numCatch = excp[i].GetNumberOfCatches(); start = excp[i].GetStartAddress(); end = excp[i].GetEndAddress(); type = excp[i].GetExceptionTypes(); for (int j=0; j<numCatch; j++) { int tkExceptionClass = 0; if (catchClass[j] != null) tkExceptionClass = dynMod.GetTypeToken(catchClass[j]).Token; switch (type[j]) { case __ExceptionInfo.None: case __ExceptionInfo.Fault: case __ExceptionInfo.Filter: m_exceptions[counter++]=new __ExceptionInstance(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; case __ExceptionInfo.Finally: m_exceptions[counter++]=new __ExceptionInstance(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; } } } } m_bIsBaked=true; if (dynMod.GetSymWriter() != null) { // set the debugging information such as scope and line number // if it is in a debug module // SymbolToken tk = new SymbolToken(MetadataTokenInternal); ISymbolWriter symWriter = dynMod.GetSymWriter(); // call OpenMethod to make this method the current method symWriter.OpenMethod(tk); // call OpenScope because OpenMethod no longer implicitly creating // the top-levelsmethod scope // symWriter.OpenScope(0); if (m_symCustomAttrs != null) { foreach(SymCustomAttr symCustomAttr in m_symCustomAttrs) dynMod.GetSymWriter().SetSymAttribute( new SymbolToken (MetadataTokenInternal), symCustomAttr.m_name, symCustomAttr.m_data); } if (m_localSymInfo != null) m_localSymInfo.EmitLocalSymInfo(symWriter); il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.m_length); symWriter.CloseMethod(); } }
private static extern void SetMethodIL(RuntimeModule module, int tk, bool isInitLocals, byte[] body, int bodyLength, byte[] LocalSig, int sigLength, int maxStackSize, __ExceptionInstance[] exceptions, int numExceptions, int[] tokenFixups, int numTokenFixups, int[] rvaFixups, int numRvaFixups);
private Type CreateTypeNoLock() { if (IsCreated()) return m_runtimeType; ThrowIfGeneric(); ThrowIfCreated(); if (m_typeInterfaces == null) m_typeInterfaces = new Type[0]; int[] interfaceTokens = new int[m_typeInterfaces.Length]; for(int i = 0; i < m_typeInterfaces.Length; i++) { interfaceTokens[i] = m_module.GetTypeToken(m_typeInterfaces[i]).Token; } int tkParent = 0; if (m_typeParent != null) tkParent = m_module.GetTypeToken(m_typeParent).Token; if (IsGenericParameter) { int[] constraints = new int[m_typeInterfaces.Length]; if (m_typeParent != null) { constraints = new int[m_typeInterfaces.Length + 1]; constraints[constraints.Length - 1] = tkParent; } for(int i = 0; i < m_typeInterfaces.Length; i++) { constraints[i] = m_module.GetTypeToken(m_typeInterfaces[i]).Token; } int declMember = m_declMeth == null ? m_DeclaringType.m_tdType.Token : m_declMeth.GetToken().Token; m_tdType = new TypeToken(InternalDefineGenParam( m_strName, declMember, m_genParamPos, (int)m_genParamAttributes, constraints, m_module, 0)); if (m_ca != null) { foreach (CustAttr ca in m_ca) ca.Bake(m_module, MetadataTokenInternal); } m_hasBeenCreated = true; return this; } else { // Check for global typebuilder if (((m_tdType.Token & 0x00FFFFFF) != 0) && ((tkParent & 0x00FFFFFF) != 0)) InternalSetParentType(m_tdType.Token, tkParent, m_module); if (m_inst != null) foreach (Type tb in m_inst) if (tb is GenericTypeParameterBuilder) ((GenericTypeParameterBuilder)tb).m_type.CreateType(); } byte [] body; MethodAttributes methodAttrs; int maxstack; if (!m_isHiddenGlobalType) { // create a public default constructor if this class has no constructor. // except if the type is Interface, ValueType, Enum, or a static class. if (m_constructorCount == 0 && ((m_iAttr & TypeAttributes.Interface) == 0) && !IsValueType && ((m_iAttr & (TypeAttributes.Abstract | TypeAttributes.Sealed)) != (TypeAttributes.Abstract | TypeAttributes.Sealed))) { DefineDefaultConstructor(MethodAttributes.Public); } } int size = m_listMethods.Count; for(int i = 0; i < size; i++) { MethodBuilder meth =(MethodBuilder)m_listMethods[i]; if (meth.IsGenericMethodDefinition) meth.GetToken(); // Doubles as "CreateMethod" for MethodBuilder -- analagous to CreateType() methodAttrs = meth.Attributes; // Any of these flags in the implemenation flags is set, we will not attach the IL method body if (((meth.GetMethodImplementationFlags() &(MethodImplAttributes.CodeTypeMask|MethodImplAttributes.PreserveSig|MethodImplAttributes.Unmanaged)) != MethodImplAttributes.IL) || ((methodAttrs & MethodAttributes.PinvokeImpl) !=(MethodAttributes) 0)) { continue; } int sigLength; byte[] LocalSig= meth.GetLocalsSignature().InternalGetSignature(out sigLength); // Check that they haven't declared an abstract method on a non-abstract class if (((methodAttrs & MethodAttributes.Abstract) != 0) &&((m_iAttr & TypeAttributes.Abstract) == 0)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadTypeAttributesNotAbstract")); } body = meth.GetBody(); // If this is an abstract method or an interface, we don't need to set the IL. if ((methodAttrs & MethodAttributes.Abstract) != 0) { // We won't check on Interface because we can have class static initializer on interface. // We will just let EE or validator to catch the problem. //((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface)) if (body != null) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadMethodBody")); } else if (body == null || body.Length == 0) { // If it's not an abstract or an interface, set the IL. if (meth.m_ilGenerator != null) { // we need to bake the method here. meth.CreateMethodBodyHelper(meth.GetILGenerator()); } body = meth.GetBody(); if ((body == null || body.Length == 0) && !meth.m_canBeRuntimeImpl) throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidOperation_BadEmptyMethodBody"), meth.Name) ); } if (meth.m_ilGenerator != null) { maxstack = meth.m_ilGenerator.GetMaxStackSize(); } else { // this is the case when client provide an array of IL byte stream rather than going through ILGenerator. maxstack = 16; } __ExceptionInstance[] Exceptions = meth.GetExceptionInstances(); int[] TokenFixups = meth.GetTokenFixups(); int[] RVAFixups = meth.GetRVAFixups(); __ExceptionInstance[] localExceptions = null; int[] localTokenFixups = null; int[] localRVAFixups = null; if (Exceptions != null) { localExceptions = new __ExceptionInstance[Exceptions.Length]; Array.Copy(Exceptions, localExceptions, Exceptions.Length); } if (TokenFixups != null) { localTokenFixups = new int[TokenFixups.Length]; Array.Copy(TokenFixups, localTokenFixups, TokenFixups.Length); } if (RVAFixups != null) { localRVAFixups = new int[RVAFixups.Length]; Array.Copy(RVAFixups, localRVAFixups, RVAFixups.Length); } InternalSetMethodIL(meth.GetToken().Token, meth.InitLocals, body, LocalSig, sigLength, maxstack, meth.GetNumberOfExceptions(), localExceptions, localTokenFixups, localRVAFixups, m_module); } m_hasBeenCreated = true; // Terminate the process. Type cls = TermCreateClass(m_tdType.Token, m_module); if (!m_isHiddenGlobalType) { m_runtimeType =(RuntimeType) cls; // if this type is a nested type, we need to invalidate the cached nested runtime type on the nesting type if (m_DeclaringType != null &&(RuntimeType)m_DeclaringType.m_runtimeType != null) { ((RuntimeType)m_DeclaringType.m_runtimeType).InvalidateCachedNestedType(); } return cls; } else { return null; } }
internal static extern void InternalSetMethodIL(int methodHandle, bool isInitLocals, byte[] body, byte[] LocalSig, int sigLength, int maxStackSize, int numExceptions, __ExceptionInstance[] exceptions, int []tokenFixups, int []rvaFixups, Module module);