2003-05-05 Miguel de Icaza <miguel@ximian.com>

	* codegen.cs (EmitContext.EmitArgument,
	EmitContext.EmitStoreArgument): New helper functions when the
	RemapToProxy flag is set.

	* expression.cs (ParameterReference.EmitLdarg): Expose this useful
	function.

	Add support for remapping parameters.

	* iterators.cs: Propagate parameter values;  Store parameter
	values in the proxy classes.

	* ecore.cs (FieldExpr): Fix an obvious bug.  static fields do not
	need a proxy reference;  I do not know what I was thinking

svn path=/trunk/mcs/; revision=14290

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 4af9e6383a5b9cae93404f83eb25f235379c7293..17ac1aaa55c9f80c13e85a9cf12d4d8da8877691 100755 (executable)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,5 +1,22 @@
+2003-05-05  Miguel de Icaza  <miguel@ximian.com>
+
+       * codegen.cs (EmitContext.EmitArgument,
+       EmitContext.EmitStoreArgument): New helper functions when the
+       RemapToProxy flag is set.
+
+       * expression.cs (ParameterReference.EmitLdarg): Expose this useful
+       function.
+
+       Add support for remapping parameters. 
+
+       * iterators.cs: Propagate parameter values;  Store parameter
+       values in the proxy classes.
+       
 2003-05-04  Miguel de Icaza  <miguel@ximian.com>
 
+       * ecore.cs (FieldExpr): Fix an obvious bug.  static fields do not
+       need a proxy reference;  I do not know what I was thinking
+
        * cs-parser.jay (constructor_initializer): catch another error,
        and display nice message.
        

diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs
index b10dc6be02c81b9267e52687c8eb5461763bdb49..1bc2efdf01fb05c1a203b2d610ea9a3331cd4ac8 100755 (executable)
--- a/mcs/mcs/codegen.cs
+++ b/mcs/mcs/codegen.cs
@@ -621,6 +621,22 @@ namespace Mono.CSharp {
                        }
                }
 
+               public void EmitArgument (int idx)
+               {
+                       if (InIterator)
+                               ig.Emit (OpCodes.Ldfld, IteratorHandler.Current.parameter_fields [idx]);
+                       else
+                               throw new Exception ("EmitStoreArgument for an unknown state");
+               }
+               
+               public void EmitStoreArgument (int idx)
+               {
+                       if (InIterator)
+                               ig.Emit (OpCodes.Stfld, IteratorHandler.Current.parameter_fields [idx]);
+                       else
+                               throw new Exception ("EmitStoreArgument for an unknown state");
+               }
+               
                /// <summary>
                ///   A dynamic This that is shared by all variables in a emitcontext.
                ///   Created on demand.

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index 1a589062c7d84f6e101cf3c5a11ea7a2cad047d3..dfbfa97424f3f02f32aa1e96944aa9a4176371b5 100755 (executable)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -4127,18 +4127,10 @@ namespace Mono.CSharp {
                        } 
                        
                        if (FieldInfo.IsStatic){
-                               if (ec.RemapToProxy){
-                                       ec.EmitThis ();
-                                       if (is_volatile)
-                                               ig.Emit (OpCodes.Volatile);
-                               
-                                       ig.Emit (OpCodes.Ldfld, FieldInfo);
-                               } else {
-                                       if (is_volatile)
-                                               ig.Emit (OpCodes.Volatile);
+                               if (is_volatile)
+                                       ig.Emit (OpCodes.Volatile);
                                
-                                       ig.Emit (OpCodes.Ldsfld, FieldInfo);
-                               }
+                               ig.Emit (OpCodes.Ldsfld, FieldInfo);
                                return;
                        }
                        
@@ -4215,14 +4207,10 @@ namespace Mono.CSharp {
                                f.status |= Field.Status.ASSIGNED;
                        } 
 
-                       if (ec.RemapToProxy)
+                       if (is_static)
+                               ig.Emit (OpCodes.Stsfld, FieldInfo);
+                       else 
                                ig.Emit (OpCodes.Stfld, FieldInfo);
-                       else {
-                               if (is_static)
-                                       ig.Emit (OpCodes.Stsfld, FieldInfo);
-                               else 
-                                       ig.Emit (OpCodes.Stfld, FieldInfo);
-                       }
                }
                
                public void AddressOf (EmitContext ec, AddressOp mode)

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 5410180444d644872c2569e05f6f3f0c37e9ed6a..977018e31f3756a1823b30e88d696c341d1b1260 100755 (executable)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -3504,7 +3504,7 @@ namespace Mono.CSharp {
                        return this;
                }
 
-               static void EmitLdArg (ILGenerator ig, int x)
+               static public void EmitLdArg (ILGenerator ig, int x)
                {
                        if (x <= 255){
                                switch (x){
@@ -3538,6 +3538,12 @@ namespace Mono.CSharp {
                public override void Emit (EmitContext ec)
                {
                        ILGenerator ig = ec.ig;
+                       if (ec.RemapToProxy){
+                               ig.Emit (OpCodes.Ldarg_0);
+                               ec.EmitArgument (idx);
+                               return;
+                       }
+                       
                        int arg_idx = idx;
 
                        if (!ec.IsStatic)
@@ -3558,6 +3564,14 @@ namespace Mono.CSharp {
                public void EmitAssign (EmitContext ec, Expression source)
                {
                        ILGenerator ig = ec.ig;
+                       
+                       if (ec.RemapToProxy){
+                               ig.Emit (OpCodes.Ldarg_0);
+                               source.Emit (ec);
+                               ec.EmitStoreArgument (idx);
+                               return;
+                       }
+                       
                        int arg_idx = idx;
 
                        if (!ec.IsStatic)
@@ -3580,6 +3594,11 @@ namespace Mono.CSharp {
 
                public void AddressOf (EmitContext ec, AddressOp mode)
                {
+                       if (ec.RemapToProxy){
+                               Report.Error (-1, "Report this: Taking the address of a remapped parameter not supported");
+                               return;
+                       }
+                       
                        int arg_idx = idx;
 
                        if (!ec.IsStatic)

diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs
index f2649537584724e51cef8d90043e232f11020cef..c884e7fdee2cab4735fec58d153481d04ba56019 100644 (file)
--- a/mcs/mcs/iterators.cs
+++ b/mcs/mcs/iterators.cs
@@ -154,6 +154,13 @@ namespace Mono.CSharp {
                public FieldBuilder this_field;
                public FieldBuilder enumerable_this_field;
 
+               //
+               // References the parameters
+               //
+
+               public FieldBuilder [] parameter_fields;
+               FieldBuilder [] enumerable_parameter_fields;
+               
                //
                // The state as we generate the iterator
                //
@@ -325,14 +332,22 @@ namespace Mono.CSharp {
                                ig.Emit (OpCodes.Ldarg_0);
                                ig.Emit (OpCodes.Ldfld, enumerable_this_field);
                        }
+                       for (int i = 0; i < parameters.Count; i++){
+                               ig.Emit (OpCodes.Ldarg_0);
+                               ig.Emit (OpCodes.Ldfld, enumerable_parameter_fields [i]);
+                       }
                        ig.Emit (OpCodes.Newobj, (ConstructorInfo) enumerator_proxy_constructor);
                        ig.Emit (OpCodes.Ret);
                }
 
                void LoadArgs (ILGenerator ig)
                {
-                       if (this_field != null)
-                               ig.Emit (OpCodes.Ldarg_0);
+                       count = parameters.Count;
+                       if ((modifiers & Modifiers.STATIC) == 0)
+                               count++;
+
+                       for (int i = 0; i < count; i++)
+                               ParameterReference.EmitLdArg (ig, i);
                }
                
                //
@@ -361,6 +376,41 @@ namespace Mono.CSharp {
                        ig.MarkLabel (resume_point);
                        resume_labels.Add (resume_point);
                }
+
+               void ComputeConstructorTypes (out Type [] constructor_types, out Parameters constructor_parameters)
+               {
+                       bool is_static =  (modifiers & Modifiers.STATIC) != 0;
+                       
+                       if (is_static && parameters.Count == 0){
+                               constructor_types = TypeManager.NoTypes;
+                               constructor_parameters = Parameters.EmptyReadOnlyParameters;
+                               return;
+                       }
+
+                       int count = (is_static ? 0 : 1) + parameters.Count;
+                       constructor_types = new Type [count];
+                       Parameter [] pars = new Parameter [count];
+                       constructor_parameters = new Parameters (pars, null, loc);
+                       
+                       int i = 0;
+                       if (!is_static){
+                               constructor_types [0] = container.TypeBuilder;
+
+                               Parameter THIS = new Parameter (
+                                       new TypeExpr (container.TypeBuilder, loc), "this", Parameter.Modifier.NONE, null);
+                               pars [0] = THIS;
+                               i++;
+                       }
+
+                       for (int j = 0; j < parameters.Count; j++, i++){
+                               Type partype = parameters.ParameterType (j);
+                               
+                               pars [i] = new Parameter (new TypeExpr (partype, loc),
+                                                         parameters.ParameterName (j),
+                                                         Parameter.Modifier.NONE, null);
+                               constructor_types [i] = partype;
+                       }
+               }
                
                //
                // Creates the IEnumerator Proxy class
@@ -389,25 +439,21 @@ namespace Mono.CSharp {
                        if ((modifiers & Modifiers.STATIC) == 0)
                                this_field = enumerator_proxy_class.DefineField ("THIS", container.TypeBuilder, FieldAttributes.Private);
 
+                       parameter_fields = new FieldBuilder [parameters.Count];
+                       for (int i = 0; i < parameters.Count; i++){
+                               parameter_fields [i] = enumerator_proxy_class.DefineField (
+                                       String.Format ("p{0}_{1}", i, parameters.ParameterName (i)),
+                                       parameters.ParameterType (i), FieldAttributes.Private);
+                       }
+                       
                        //
                        // Define a constructor 
                        //
                        // FIXME: currently its parameterless
                        Type [] constructor_types;
                        Parameters constructor_parameters;
-                       
-                       if (this_field == null){
-                               constructor_types = TypeManager.NoTypes;
-                               constructor_parameters = Parameters.EmptyReadOnlyParameters;
-                       } else {
-                               constructor_types = new Type [1];
-                               constructor_types [0] = container.TypeBuilder;
 
-                               Parameter THIS = new Parameter (new TypeExpr (container.TypeBuilder, loc), "this", Parameter.Modifier.NONE, null);
-                               Parameter [] pars = new Parameter [1];
-                               pars [0] = THIS;
-                               constructor_parameters = new Parameters (pars, null, loc);
-                       }
+                       ComputeConstructorTypes (out constructor_types, out constructor_parameters);
                        
                        enumerator_proxy_constructor = enumerator_proxy_class.DefineConstructor (
                                MethodAttributes.Public | MethodAttributes.HideBySig |
@@ -423,10 +469,19 @@ namespace Mono.CSharp {
                        ig.Emit (OpCodes.Ldarg_0);
                        ig.Emit (OpCodes.Call, TypeManager.object_ctor);
 
+                       int arg_start;
                        if (this_field != null){
+                               arg_start = 2;
                                ig.Emit (OpCodes.Ldarg_0);
                                ig.Emit (OpCodes.Ldarg_1);
                                ig.Emit (OpCodes.Stfld, this_field);
+                       } else {
+                               arg_start = 1;
+                       }
+                       for (int i = 0; i < parameters.Count; i++){
+                               ig.Emit (OpCodes.Ldarg_0);
+                               ParameterReference.EmitLdArg (ig, i + arg_start);
+                               ig.Emit (OpCodes.Stfld, parameter_fields [i]);
                        }
                        ig.Emit (OpCodes.Ret);
                }
@@ -452,21 +507,17 @@ namespace Mono.CSharp {
                        //
                        Type [] constructor_types;
                        Parameters constructor_parameters;
-                               
-                       if ((modifiers & Modifiers.STATIC) != 0){
-                               constructor_types = TypeManager.NoTypes;
-                               constructor_parameters = Parameters.EmptyReadOnlyParameters;
-                       } else {
+
+                       ComputeConstructorTypes (out constructor_types, out constructor_parameters);
+                       if ((modifiers & Modifiers.STATIC) == 0){
                                enumerable_this_field = enumerable_proxy_class.DefineField (
                                        "THIS", container.TypeBuilder, FieldAttributes.Private);
-                               
-                               constructor_types = new Type [1];
-                               constructor_types [0] = container.TypeBuilder;
-
-                               Parameter THIS = new Parameter (new TypeExpr (container.TypeBuilder, loc), "this", Parameter.Modifier.NONE, null);
-                               Parameter [] pars = new Parameter [1];
-                               pars [0] = THIS;
-                               constructor_parameters = new Parameters (pars, null, loc);
+                       }
+                       enumerable_parameter_fields = new FieldBuilder [parameters.Count];
+                       for (int i = 0; i < parameters.Count; i++){
+                               enumerable_parameter_fields [i] = enumerable_proxy_class.DefineField (
+                                       String.Format ("p{0}_{1}", i, parameters.ParameterName (i)),
+                                       parameters.ParameterType (i), FieldAttributes.Private);
                        }
                        
                        enumerable_proxy_constructor = enumerable_proxy_class.DefineConstructor (
@@ -479,10 +530,20 @@ namespace Mono.CSharp {
                        ILGenerator ig = enumerable_proxy_constructor.GetILGenerator ();
                        ig.Emit (OpCodes.Ldarg_0);
                        ig.Emit (OpCodes.Call, TypeManager.object_ctor);
+
+                       int first_arg;
                        if (enumerable_this_field != null){
                                ig.Emit (OpCodes.Ldarg_0);
                                ig.Emit (OpCodes.Ldarg_1);
                                ig.Emit (OpCodes.Stfld, enumerable_this_field);
+                               first_arg = 2;
+                       } else
+                               first_arg = 1;
+                       
+                       for (int i = 0; i < parameters.Count; i++){
+                               ig.Emit (OpCodes.Ldarg_0);
+                               ParameterReference.EmitLdArg (ig, i + first_arg);
+                               ig.Emit (OpCodes.Stfld, enumerable_parameter_fields [i]);
                        }
                        ig.Emit (OpCodes.Ret);
                }