Author: jbevain
Date: 2007-07-19 12:14:28 -0400 (Thu, 19 Jul 2007)
New Revision: 82297

Modified:
   trunk/mcs/class/Mono.Cecil/Mono.Cecil.Cil/CodeReader.cs
   trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs
   trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureWriter.cs
   trunk/mcs/class/Mono.Cecil/Mono.Cecil/MethodReference.cs
   trunk/mcs/class/Mono.Cecil/Mono.Cecil/ReflectionReader.cs
   trunk/mcs/class/Mono.Cecil/Mono.Cecil/SentinelType.cs
Log:
actually fix the varargs handling

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil/MethodReference.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil/MethodReference.cs    2007-07-19 
16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil/MethodReference.cs    2007-07-19 
16:14:28 UTC (rev 82297)
@@ -110,13 +110,19 @@
 
                public override string ToString ()
                {
+                       int sentinel = GetSentinel ();
+
                        StringBuilder sb = new StringBuilder ();
                        sb.Append (m_returnType.ReturnType.FullName);
                        sb.Append (" ");
                        sb.Append (base.ToString ());
                        sb.Append ("(");
                        for (int i = 0; i < this.Parameters.Count; i++) {
+                               if (i == sentinel)
+                                       sb.Append ("...,");
+
                                sb.Append (this.Parameters 
[i].ParameterType.FullName);
+
                                if (i < this.Parameters.Count - 1)
                                        sb.Append (",");
                        }

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil/ReflectionReader.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil/ReflectionReader.cs   2007-07-19 
16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil/ReflectionReader.cs   2007-07-19 
16:14:28 UTC (rev 82297)
@@ -210,45 +210,14 @@
                                        string name = 
m_root.Streams.StringsHeap [mrefRow.Name];
                                        MethodSig ms = (MethodSig) sig;
 
-                                       MethodReference methref = new 
MethodReference (
-                                               name, ms.HasThis, 
ms.ExplicitThis, ms.MethCallConv);
-                                       methref.DeclaringType = declaringType;
-
-                                       if (sig is MethodDefSig) {
-                                               int arity = (sig as 
MethodDefSig).GenericParameterCount;
-                                               for (int i = 0; i < arity; i++)
-                                                       
methref.GenericParameters.Add (new GenericParameter (i, methref));
-                                       }
-
-                                       if (methref.GenericParameters.Count > 0)
-                                               nc.Method = methref;
-
-                                       methref.ReturnType = 
GetMethodReturnType (ms, nc);
-
-                                       methref.ReturnType.Method = methref;
-                                       for (int j = 0; j < ms.ParamCount; j++) 
{
-                                               Param p = ms.Parameters [j];
-                                               ParameterDefinition pdef = 
BuildParameterDefinition (
-                                                       string.Concat ("A_", 
j), j, new ParameterAttributes (), p, nc);
-                                               pdef.Method = methref;
-                                               methref.Parameters.Add (pdef);
-                                       }
-
-                                       member = methref;
+                                       member = CreateMethodReferenceFromSig 
(ms, name, declaringType, nc);
                                }
                                break;
                        case TokenType.Method :
                                // really not sure about this
                                MethodDefinition methdef = GetMethodDefAt 
(mrefRow.Class.RID);
-                               MethodReference methRef = new MethodReference (
-                                       methdef.Name, methdef.HasThis,
-                                       methdef.ExplicitThis, 
methdef.CallingConvention);
 
-                               methRef.DeclaringType = methdef.DeclaringType;
-                               methRef.ReturnType = methdef.ReturnType;
-                               foreach (ParameterDefinition param in 
methdef.Parameters)
-                                       methRef.Parameters.Add (param);
-                               member = methRef;
+                               member = CreateMethodReferenceFromSig 
((MethodSig) sig, methdef.Name, methdef.DeclaringType, new GenericContext ());
                                break;
                        case TokenType.ModuleRef :
                                break; // TODO, implement that, or not
@@ -261,6 +230,51 @@
                        return member;
                }
 
+               MethodReference CreateMethodReferenceFromSig (MethodSig ms, 
string name, TypeReference declaringType, GenericContext context)
+               {
+                       MethodReference methref = new MethodReference (
+                               name, ms.HasThis, ms.ExplicitThis, 
ms.MethCallConv);
+                       methref.DeclaringType = declaringType;
+
+                       if (ms is MethodDefSig) {
+                               int arity = (ms as 
MethodDefSig).GenericParameterCount;
+                               for (int i = 0; i < arity; i++)
+                                       methref.GenericParameters.Add (new 
GenericParameter (i, methref));
+                       }
+
+                       if (methref.GenericParameters.Count > 0)
+                               context.Method = methref;
+
+                       methref.ReturnType = GetMethodReturnType (ms, context);
+
+                       methref.ReturnType.Method = methref;
+                       for (int j = 0; j < ms.ParamCount; j++) {
+                               Param p = ms.Parameters [j];
+                               ParameterDefinition pdef = 
BuildParameterDefinition (j, p, context);
+                               pdef.Method = methref;
+                               methref.Parameters.Add (pdef);
+                       }
+
+                       CreateSentinelIfNeeded (methref, ms);
+
+                       return methref;
+               }
+
+               public static void CreateSentinelIfNeeded (IMethodSignature 
meth, MethodSig signature)
+               {
+                       MethodDefSig sig = signature as MethodDefSig;
+                       if (sig == null)
+                               return;
+
+                       int sentinel = sig.Sentinel;
+
+                       if (sig.Sentinel < 0 || sig.Sentinel >= 
meth.Parameters.Count)
+                               return;
+
+                       ParameterDefinition param = meth.Parameters [sentinel];
+                       param.ParameterType = new SentinelType 
(param.ParameterType);
+               }
+
                public PropertyDefinition GetPropertyDefAt (uint rid)
                {
                        return m_properties [rid - 1];
@@ -711,9 +725,7 @@
                                                        pdef.MetadataToken = 
MetadataToken.FromMetadataRow (TokenType.Param, pointer);
                                                        m_parameters [pointer] 
= pdef;
                                                } else
-                                                       pdef = 
BuildParameterDefinition (
-                                                               string.Concat 
("A_", mdef.IsStatic ? k : k + 1),
-                                                               k + 1, 
(ParameterAttributes) 0, psig, context);
+                                                       pdef = 
BuildParameterDefinition (k + 1, psig, context);
 
                                                pdef.Method = mdef;
                                                mdef.Parameters.Add (pdef);
@@ -835,27 +847,42 @@
                        return cattr;
                }
 
-               public ParameterDefinition BuildParameterDefinition (string 
name, int sequence,
-                       ParameterAttributes attrs, Param psig, GenericContext 
context)
+               void CompleteParameter (ParameterDefinition parameter, Param 
signature, GenericContext context)
                {
-                       ParameterDefinition ret = new ParameterDefinition 
(name, sequence, attrs, null);
                        TypeReference paramType;
 
-                       if (psig.ByRef)
-                               paramType = new ReferenceType 
(GetTypeRefFromSig (psig.Type, context));
-                       else if (psig.TypedByRef)
+                       if (signature.ByRef)
+                               paramType = new ReferenceType 
(GetTypeRefFromSig (signature.Type, context));
+                       else if (signature.TypedByRef)
                                paramType = SearchCoreType 
(Constants.TypedReference);
                        else
-                               paramType = GetTypeRefFromSig (psig.Type, 
context);
+                               paramType = GetTypeRefFromSig (signature.Type, 
context);
 
-                       if (psig.CustomMods.Length > 0)
-                               paramType = GetModifierType (psig.CustomMods, 
paramType);
+                       if (signature.CustomMods.Length > 0)
+                               paramType = GetModifierType 
(signature.CustomMods, paramType);
 
-                       ret.ParameterType = paramType;
+                       parameter.ParameterType = paramType;
+               }
 
-                       return ret;
+               public ParameterDefinition BuildParameterDefinition (int 
sequence, Param psig, GenericContext context)
+               {
+                       ParameterDefinition parameter = new ParameterDefinition 
(null);
+                       parameter.Sequence = sequence;
+
+                       CompleteParameter (parameter, psig, context);
+
+                       return parameter;
                }
 
+               public ParameterDefinition BuildParameterDefinition (string 
name, int sequence, ParameterAttributes attrs, Param psig, GenericContext 
context)
+               {
+                       ParameterDefinition parameter = new ParameterDefinition 
(name, sequence, attrs, null);
+
+                       CompleteParameter (parameter, psig, context);
+
+                       return parameter;
+               }
+
                protected SecurityDeclaration BuildSecurityDeclaration 
(DeclSecurityRow dsRow)
                {
                        return BuildSecurityDeclaration (dsRow.Action, 
m_root.Streams.BlobHeap.Read (dsRow.PermissionSet));
@@ -1010,12 +1037,11 @@
 
                                for (int i = 0; i < funcptr.Method.ParamCount; 
i++) {
                                        Param p = funcptr.Method.Parameters [i];
-                                       fnptr.Parameters.Add 
(BuildParameterDefinition (
-                                                       string.Concat ("A_", i),
-                                                       i, 
(ParameterAttributes) 0,
-                                                       p, context));
+                                       fnptr.Parameters.Add 
(BuildParameterDefinition (i, p, context));
                                }
 
+                               CreateSentinelIfNeeded (fnptr, funcptr.Method);
+
                                return fnptr;
                        case ElementType.Var:
                                VAR var = t as VAR;
@@ -1042,8 +1068,6 @@
                                                ginst.Signature.Types [i], 
context));
 
                                return instance;
-                       case ElementType.Sentinel:
-                               return new SentinelType ();
                        default:
                                break;
                        }

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil/SentinelType.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil/SentinelType.cs       2007-07-19 
16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil/SentinelType.cs       2007-07-19 
16:14:28 UTC (rev 82297)
@@ -28,9 +28,9 @@
 
 namespace Mono.Cecil {
 
-       public sealed class SentinelType : TypeReference {
+       public sealed class SentinelType : TypeSpecification {
 
-               public SentinelType () : base ("...", null)
+               public SentinelType (TypeReference elementType) : base 
(elementType)
                {
                }
        }

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil.Cil/CodeReader.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil.Cil/CodeReader.cs     2007-07-19 
16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil.Cil/CodeReader.cs     2007-07-19 
16:14:28 UTC (rev 82297)
@@ -325,12 +325,11 @@
 
                        for (int i = 0; i < ms.ParamCount; i++) {
                                Param p = ms.Parameters [i];
-                               cs.Parameters.Add 
(m_reflectReader.BuildParameterDefinition (
-                                               string.Concat ("A_", i),
-                                               i, (ParameterAttributes) 0,
-                                               p, context));
+                               cs.Parameters.Add 
(m_reflectReader.BuildParameterDefinition (i, p, context));
                        }
 
+                       ReflectionReader.CreateSentinelIfNeeded (cs, ms);
+
                        return cs;
                }
 

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs 
2007-07-19 16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureReader.cs 
2007-07-19 16:14:28 UTC (rev 82297)
@@ -401,8 +401,10 @@
                                int curs = start;
                                int flag = Utilities.ReadCompressedInteger 
(data, start, out start);
 
-                               if (flag == (int) ElementType.Sentinel)
+                               if (flag == (int) ElementType.Sentinel) {
                                        sentinelpos = i;
+                                       curs = start;
+                               }
 
                                ret [i] = ReadParameter (data, curs, out start);
                        }

Modified: trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureWriter.cs
===================================================================
--- trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureWriter.cs 
2007-07-19 16:05:15 UTC (rev 82296)
+++ trunk/mcs/class/Mono.Cecil/Mono.Cecil.Signatures/SignatureWriter.cs 
2007-07-19 16:14:28 UTC (rev 82297)
@@ -137,7 +137,7 @@
                                Write (methodDef.GenericParameterCount);
                        Write (methodDef.ParamCount);
                        Write (methodDef.RetType);
-                       Write (methodDef.Parameters);
+                       Write (methodDef.Parameters, methodDef.Sentinel);
                }
 
                public override void VisitMethodRefSig (MethodRefSig methodRef)
@@ -145,7 +145,7 @@
                        m_sigWriter.Write (methodRef.CallingConvention);
                        Write (methodRef.ParamCount);
                        Write (methodRef.RetType);
-                       Write (methodRef.Parameters);
+                       Write (methodRef.Parameters, methodRef.Sentinel);
                }
 
                public override void VisitFieldSig (FieldSig field)
@@ -201,6 +201,16 @@
                                Write (retType.Type);
                }
 
+               void Write (Param [] parameters, int sentinel)
+               {
+                       for (int i = 0; i < parameters.Length; i++) {
+                               if (i == sentinel)
+                                       Write (ElementType.Sentinel);
+
+                               Write (parameters [i]);
+                       }
+               }
+
                void Write (Param [] parameters)
                {
                        foreach (Param p in parameters)

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to