X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FSystem.Reflection.Emit%2FMethodBuilder.cs;h=87c7965060e508144f74c03d7ad367b8494f9868;hb=4db2302d083f3798bafe52fefe2577bd2f82e4e7;hp=428ae4ae479877052751354de3ec357cb8925eec;hpb=de14fed65ed6a1010075d930df3a40b9796053af;p=mono.git diff --git a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs index 428ae4ae479..87c7965060e 100755 --- a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs @@ -1,4 +1,3 @@ - // // System.Reflection.Emit/MethodBuilder.cs // @@ -8,14 +7,40 @@ // (C) 2001 Ximian, Inc. http://www.ximian.com // +// +// Copyright (C) 2004 Novell, Inc (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + using System; using System.Reflection; using System.Reflection.Emit; using System.Globalization; +using System.Security; +using System.Security.Permissions; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; namespace System.Reflection.Emit { + public sealed class MethodBuilder : MethodInfo { private RuntimeMethodHandle mhandle; private Type rtype; @@ -36,12 +61,27 @@ namespace System.Reflection.Emit { private CallingConvention native_cc; private CallingConventions call_conv; private bool init_locals = true; + private IntPtr generic_container; +#if NET_2_0 || BOOTSTRAP_NET_2_0 + private GenericTypeParameterBuilder[] generic_params; +#else + private Object generic_params; /* so offsets are the same */ +#endif + private Type[] returnModReq; + private Type[] returnModOpt; + private Type[][] paramModReq; + private Type[][] paramModOpt; + private RefEmitPermissionSet[] permissions; - internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) { + internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnModReq, Type[] returnModOpt, Type[] parameterTypes, Type[][] paramModReq, Type[][] paramModOpt) { this.name = name; this.attrs = attributes; this.call_conv = callingConvention; this.rtype = returnType; + this.returnModReq = returnModReq; + this.returnModOpt = returnModOpt; + this.paramModReq = paramModReq; + this.paramModOpt = paramModOpt; // The MSDN docs does not specify this, but the MS MethodBuilder // appends a HasThis flag if the method is not static if ((attributes & MethodAttributes.Static) == 0) @@ -56,9 +96,9 @@ namespace System.Reflection.Emit { } internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, - CallingConventions callingConvention, Type returnType, Type[] parameterTypes, + CallingConventions callingConvention, Type returnType, Type[] returnModReq, Type[] returnModOpt, Type[] parameterTypes, Type[][] paramModReq, Type[][] paramModOpt, String dllName, String entryName, CallingConvention nativeCConv, CharSet nativeCharset) - : this (tb, name, attributes, callingConvention, returnType, parameterTypes) { + : this (tb, name, attributes, callingConvention, returnType, returnModReq, returnModOpt, parameterTypes, paramModReq, paramModOpt) { pi_dll = dllName; pi_entry = entryName; native_cc = nativeCConv; @@ -93,6 +133,13 @@ namespace System.Reflection.Emit { get { return call_conv; } } + [MonoTODO] + public string Signature { + get { + throw new NotImplementedException (); + } + } + public MethodToken GetToken() { return new MethodToken(0x06000000 | table_idx); } @@ -104,6 +151,8 @@ namespace System.Reflection.Emit { return iattrs; } public override ParameterInfo[] GetParameters() { + if (!type.is_created) + throw NotSupported (); if (parameters == null) return null; @@ -113,13 +162,21 @@ namespace System.Reflection.Emit { } return retval; } + + internal override int GetParameterCount () + { + if (parameters == null) + return 0; + + return parameters.Length; + } public Module GetModule () { return type.Module; } public void CreateMethodBody( byte[] il, int count) { - if ((il != null) && ((count < 0) || (count >= il.Length))) + if ((il != null) && ((count < 0) || (count > il.Length))) throw new ArgumentException ("Index was out of range. Must be non-negative and less than the size of the collection."); if ((code != null) || type.is_created) @@ -157,20 +214,21 @@ namespace System.Reflection.Emit { throw new InvalidOperationException ("Method body should not exist."); if (ilgen != null) return ilgen; - ilgen = new ILGenerator (this, size); + ilgen = new ILGenerator (type.Module, ((ModuleBuilder)type.Module).GetTokenGenerator (), size); return ilgen; } - [MonoTODO] public ParameterBuilder DefineParameter (int position, ParameterAttributes attributes, string strParamName) { - if ((position < 1) || (position > parameters.Length)) - throw new ArgumentOutOfRangeException ("position"); - RejectIfCreated (); + + // + // Extension: Mono allows position == 0 for the return attribute + // + if ((position < 0) || (position > parameters.Length)) + throw new ArgumentOutOfRangeException ("position"); ParameterBuilder pb = new ParameterBuilder (this, position, attributes, strParamName); - // check position if (pinfo == null) pinfo = new ParameterBuilder [parameters.Length + 1]; pinfo [position] = pb; @@ -215,6 +273,64 @@ namespace System.Reflection.Emit { RejectIfCreated (); iattrs = attributes; } + + public void AddDeclarativeSecurity( SecurityAction action, PermissionSet pset) { + if (pset == null) + throw new ArgumentNullException ("pset"); + if ((action == SecurityAction.RequestMinimum) || + (action == SecurityAction.RequestOptional) || + (action == SecurityAction.RequestRefuse)) + throw new ArgumentException ("Request* values are not permitted", "action"); + + RejectIfCreated (); + + if (permissions != null) { + /* Check duplicate actions */ + foreach (RefEmitPermissionSet set in permissions) + if (set.action == action) + throw new InvalidOperationException ("Multiple permission sets specified with the same SecurityAction."); + + RefEmitPermissionSet[] new_array = new RefEmitPermissionSet [permissions.Length + 1]; + permissions.CopyTo (new_array, 0); + permissions = new_array; + } + else + permissions = new RefEmitPermissionSet [1]; + + permissions [permissions.Length - 1] = new RefEmitPermissionSet (action, pset.ToXml ().ToString ()); + attrs |= MethodAttributes.HasSecurity; + } + + [MonoTODO] + public void SetMarshal (UnmanagedMarshal unmanagedMarshal) + { + RejectIfCreated (); + throw new NotImplementedException (); + } + + [MonoTODO] + public void SetSymCustomAttribute (string name, byte[] data) + { + RejectIfCreated (); + throw new NotImplementedException (); + } + + public override string ToString() + { + return "MethodBuilder [" + type.Name + "::" + name + "]"; + } + + [MonoTODO] + public override bool Equals (object obj) + { + return base.Equals (obj); + } + + public override int GetHashCode () + { + return name.GetHashCode (); + } + internal override int get_next_table_index (object obj, int table, bool inc) { return type.get_next_table_index (obj, table, inc); } @@ -231,6 +347,59 @@ namespace System.Reflection.Emit { private Exception NotSupported () { return new NotSupportedException ("The invoked member is not supported in a dynamic module."); } + +#if NET_2_0 || BOOTSTRAP_NET_2_0 + [MethodImplAttribute(MethodImplOptions.InternalCall)] + public override extern MethodInfo BindGenericParameters (Type [] types); + + public override bool Mono_IsInflatedMethod { + get { + return false; + } + } + + public override bool HasGenericParameters { + get { + return generic_params != null; + } + } + + public override Type[] GetGenericArguments () + { + if (generic_params == null) + return new Type [0]; + + Type[] result = new Type [generic_params.Length]; + for (int i = 0; i < generic_params.Length; i++) + result [i] = generic_params [i]; + + return result; + } + + public GenericTypeParameterBuilder[] DefineGenericParameters (string[] names) + { + generic_params = new GenericTypeParameterBuilder [names.Length]; + for (int i = 0; i < names.Length; i++) + generic_params [i] = new GenericTypeParameterBuilder ( + type, this, names [i], i); + + return generic_params; + } + + public void SetGenericMethodSignature (MethodAttributes attributes, CallingConventions callingConvention, Type return_type, Type[] parameter_types) + { + RejectIfCreated (); + + this.attrs = attributes; + this.call_conv = callingConvention; + if ((attributes & MethodAttributes.Static) == 0) + this.call_conv |= CallingConventions.HasThis; + + this.rtype = return_type; + this.parameters = new Type [parameter_types.Length]; + System.Array.Copy (parameter_types, this.parameters, parameter_types.Length); + } +#endif } }