X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fassign.cs;h=dabe1c75d39e01ae4589ed17ebf5baefcec49d9c;hb=c7fe6cd0226fa8063813d82218c10a9d5b052f34;hp=94467b2cabb8bf597960fa95f9342ce7a047021f;hpb=7f449e7aff8f374d13db7023c7b326dde01b763d;p=mono.git diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs old mode 100755 new mode 100644 index 94467b2cabb..dabe1c75d39 --- a/mcs/mcs/assign.cs +++ b/mcs/mcs/assign.cs @@ -3,9 +3,10 @@ // // Author: // Miguel de Icaza (miguel@ximian.com) -// Martin Baulig (martin@gnome.org) +// Martin Baulig (martin@ximian.com) // // (C) 2001, 2002, 2003 Ximian, Inc. +// (C) 2004 Novell, Inc // using System; using System.Reflection; @@ -29,19 +30,125 @@ namespace Mono.CSharp { /// public interface IAssignMethod { // - // This method will emit the code for the actual assignment + // This is an extra version of Emit. If leave_copy is `true' + // A copy of the expression will be left on the stack at the + // end of the code generated for EmitAssign // - void EmitAssign (EmitContext ec, Expression source); + void Emit (EmitContext ec, bool leave_copy); // - // This method is invoked before any code generation takes - // place, and it is a mechanism to inform that the expression - // will be invoked more than once, and that the method should - // use temporary values to avoid having side effects + // This method does the assignment + // `source' will be stored into the location specified by `this' + // if `leave_copy' is true, a copy of `source' will be left on the stack + // if `prepare_for_load' is true, when `source' is emitted, there will + // be data on the stack that it can use to compuatate its value. This is + // for expressions like a [f ()] ++, where you can't call `f ()' twice. // - // Example: a [ g () ] ++ - // - void CacheTemporaries (EmitContext ec); + void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load); + + /* + For simple assignments, this interface is very simple, EmitAssign is called with source + as the source expression and leave_copy and prepare_for_load false. + + For compound assignments it gets complicated. + + EmitAssign will be called as before, however, prepare_for_load will be + true. The @source expression will contain an expression + which calls Emit. So, the calls look like: + + this.EmitAssign (ec, source, false, true) -> + source.Emit (ec); -> + [...] -> + this.Emit (ec, false); -> + end this.Emit (ec, false); -> + end [...] + end source.Emit (ec); + end this.EmitAssign (ec, source, false, true) + + + When prepare_for_load is true, EmitAssign emits a `token' on the stack that + Emit will use for its state. + + Let's take FieldExpr as an example. assume we are emitting f ().y += 1; + + Here is the call tree again. This time, each call is annotated with the IL + it produces: + + this.EmitAssign (ec, source, false, true) + call f + dup + + Binary.Emit () + this.Emit (ec, false); + ldfld y + end this.Emit (ec, false); + + IntConstant.Emit () + ldc.i4.1 + end IntConstant.Emit + + add + end Binary.Emit () + + stfld + end this.EmitAssign (ec, source, false, true) + + Observe two things: + 1) EmitAssign left a token on the stack. It was the result of f (). + 2) This token was used by Emit + + leave_copy (in both EmitAssign and Emit) tells the compiler to leave a copy + of the expression at that point in evaluation. This is used for pre/post inc/dec + and for a = x += y. Let's do the above example with leave_copy true in EmitAssign + + this.EmitAssign (ec, source, true, true) + call f + dup + + Binary.Emit () + this.Emit (ec, false); + ldfld y + end this.Emit (ec, false); + + IntConstant.Emit () + ldc.i4.1 + end IntConstant.Emit + + add + end Binary.Emit () + + dup + stloc temp + stfld + ldloc temp + end this.EmitAssign (ec, source, true, true) + + And with it true in Emit + + this.EmitAssign (ec, source, false, true) + call f + dup + + Binary.Emit () + this.Emit (ec, true); + ldfld y + dup + stloc temp + end this.Emit (ec, true); + + IntConstant.Emit () + ldc.i4.1 + end IntConstant.Emit + + add + end Binary.Emit () + + stfld + ldloc temp + end this.EmitAssign (ec, source, false, true) + + Note that these two examples are what happens for ++x and x++, respectively. + */ } /// @@ -57,7 +164,7 @@ namespace Mono.CSharp { /// code to access this value, return its address or save its value. /// /// If `is_address' is true, then the value that we store is the address to the - /// real value, and not the value itself. + /// real value, and not the value itself. /// /// This is needed for a value type, because otherwise you just end up making a /// copy of the value on the stack and modifying it. You really need a pointer @@ -71,15 +178,13 @@ namespace Mono.CSharp { public class LocalTemporary : Expression, IMemoryLocation { LocalBuilder builder; bool is_address; - - public LocalTemporary (EmitContext ec, Type t) : this (ec, t, false) {} - - public LocalTemporary (EmitContext ec, Type t, bool is_address) + + public LocalTemporary (Type t) : this (t, false) {} + + public LocalTemporary (Type t, bool is_address) { type = t; eclass = ExprClass.Value; - loc = Location.Null; - builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (t): t); this.is_address = is_address; } @@ -96,7 +201,7 @@ namespace Mono.CSharp { ec.FreeTemporaryLocal (builder, type); builder = null; } - + public override Expression DoResolve (EmitContext ec) { return this; @@ -105,7 +210,7 @@ namespace Mono.CSharp { public override void Emit (EmitContext ec) { ILGenerator ig = ec.ig; - + ig.Emit (OpCodes.Ldloc, builder); // we need to copy from the pointer if (is_address) @@ -118,15 +223,21 @@ namespace Mono.CSharp { public void Store (EmitContext ec) { ILGenerator ig = ec.ig; + if (builder == null) + builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type); + ig.Emit (OpCodes.Stloc, builder); } public void AddressOf (EmitContext ec, AddressOp mode) { + if (builder == null) + builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type); + // if is_address, than this is just the address anyways, // so we just return this. ILGenerator ig = ec.ig; - + if (is_address) ig.Emit (OpCodes.Ldloc, builder); else @@ -142,7 +253,7 @@ namespace Mono.CSharp { /// /// The Assign node takes care of assigning the value of source into - /// the expression represented by target. + /// the expression represented by target. /// public class Assign : ExpressionStatement { protected Expression target, source, real_source; @@ -151,6 +262,11 @@ namespace Mono.CSharp { protected bool is_embedded = false; protected bool must_free_temp = false; + public Assign (Expression target, Expression source) + : this (target, source, target.Location) + { + } + public Assign (Expression target, Expression source, Location l) { this.target = target; @@ -191,9 +307,9 @@ namespace Mono.CSharp { public static void error70 (EventInfo ei, Location l) { - Report.Error (70, l, "The event '" + ei.Name + - "' can only appear on the left-side of a += or -= (except when" + - " used from within the type '" + ei.DeclaringType + "')"); + Report.Error (70, l, "The event `" + TypeManager.CSharpSignature (ei) + + "' can only appear on the left hand side of += or -= (except when" + + " used from within the type `" + ei.DeclaringType + "')"); } // @@ -206,8 +322,11 @@ namespace Mono.CSharp { source = embedded = ((Assign) source).GetEmbeddedAssign (loc); real_source = source = source.Resolve (ec); - if (source == null) + if (source == null) { + // Ensure that we don't propagate the error as spurious "uninitialized variable" errors. + target = target.ResolveLValue (ec, EmptyExpression.Null, Location); return null; + } // // This is used in an embedded assignment. @@ -221,9 +340,9 @@ namespace Mono.CSharp { if (embedded == null) { if (this is CompoundAssign) - real_temp = temp = new LocalTemporary (ec, target.Type); + real_temp = temp = new LocalTemporary (target.Type); else - real_temp = temp = new LocalTemporary (ec, source.Type); + real_temp = temp = new LocalTemporary (source.Type); } else temp = embedded.temp; @@ -238,11 +357,16 @@ namespace Mono.CSharp { if (embedded != null) source = (embedded.temp != null) ? embedded.temp : embedded.source; - target = target.ResolveLValue (ec, source); + target = target.ResolveLValue (ec, source, Location); if (target == null) return null; + bool same_assignment = (embedded != null) ? embedded.Target.Equals(target) : source.Equals (target); + if (same_assignment) { + Report.Warning (1717, 3, loc, "Assignment made to same variable; did you mean to assign something else?"); + } + Type target_type = target.Type; Type source_type = real_source.Type; @@ -258,12 +382,12 @@ namespace Mono.CSharp { EventInfo ei = ((EventExpr) target).EventInfo; Expression ml = MemberLookup ( - ec, ec.ContainerType, ei.Name, + ec.ContainerType, ec.ContainerType, ei.Name, MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc); if (ml == null) { - // - // If this is the case, then the Event does not belong + // + // If this is the case, then the Event does not belong // to this Type and so, according to the spec // is allowed to only appear on the left hand of // the += and -= operators @@ -272,23 +396,13 @@ namespace Mono.CSharp { // in the case it is being referenced within the same type container; // it will appear as a FieldExpr in that case. // - + if (!(source is BinaryDelegate)) { error70 (ei, loc); return null; - } + } } } - - if (source is New && target_type.IsValueType && - (target.eclass != ExprClass.IndexerAccess) && (target.eclass != ExprClass.PropertyAccess)){ - New n = (New) source; - - if (n.SetValueTypeVariable (target)) - return n; - else - return null; - } if (!(target is IAssignMethod) && (target.eclass != ExprClass.EventAccess)) { Report.Error (131, loc, @@ -298,39 +412,51 @@ namespace Mono.CSharp { } if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) { - source.Error_UnexpectedKind ("variable or value"); + source.Error_UnexpectedKind (ec.DeclContainer, "variable or value", loc); return null; - } else if (!RootContext.V2 && (source is MethodGroupExpr)){ + } else if ((RootContext.Version == LanguageVersion.ISO_1) && + (source is MethodGroupExpr)){ ((MethodGroupExpr) source).ReportUsageError (); return null; } - - if (target_type == source_type) + + if (target_type == source_type){ + if (source is New && target_type.IsValueType && + (target.eclass != ExprClass.IndexerAccess) && (target.eclass != ExprClass.PropertyAccess)){ + New n = (New) source; + + if (n.SetValueTypeVariable (target)) + return n; + else + return null; + } + return this; - + } + // - // If this assignemnt/operator was part of a compound binary + // If this assignment/operator was part of a compound binary // operator, then we allow an explicit conversion, as detailed - // in the spec. + // in the spec. // if (this is CompoundAssign){ CompoundAssign a = (CompoundAssign) this; - + Binary b = source as Binary; if (b != null){ // // 1. if the source is explicitly convertible to the // target_type // - + source = Convert.ExplicitConversion (ec, source, target_type, loc); if (source == null){ - Convert.Error_CannotImplicitConversion (loc, source_type, target_type); + a.original_source.Error_ValueCannotBeConverted (loc, target_type, true); return null; } - + // // 2. and the original right side is implicitly convertible to // the type of target @@ -346,11 +472,17 @@ namespace Mono.CSharp { (b.Oper == Binary.Operator.LeftShift || b.Oper == Binary.Operator.RightShift)) return this; - Convert.Error_CannotImplicitConversion (loc, a.original_source.Type, target_type); + a.original_source.Error_ValueCannotBeConverted (loc, target_type, false); return null; } } + if (source.eclass == ExprClass.MethodGroup && !TypeManager.IsDelegateType (target_type)) { + Report.Error (428, source.Location, "Cannot convert method group `{0}' to non-delegate type `{1}'. Did you intend to invoke the method?", + ((MethodGroupExpr)source).Name, target.GetSignatureForError ()); + return null; + } + source = Convert.ImplicitConversionRequired (ec, source, target_type, loc); if (source == null) return null; @@ -362,10 +494,10 @@ namespace Mono.CSharp { // type and store it in a new temporary local. if (is_embedded || embedded != null) { type = target_type; - temp = new LocalTemporary (ec, type); + temp = new LocalTemporary (type); must_free_temp = true; } - + return this; } @@ -394,7 +526,7 @@ namespace Mono.CSharp { } Expression temp_source = (temp != null) ? temp : source; - ((IAssignMethod) target).EmitAssign (ec, temp_source); + ((IAssignMethod) target).EmitAssign (ec, temp_source, false, false); return temp_source; } @@ -417,20 +549,8 @@ namespace Mono.CSharp { return; } - bool use_temporaries = false; - - // - // FIXME! We need a way to "probe" if the process can - // just use `dup' to propagate the result - // IAssignMethod am = (IAssignMethod) target; - if (this is CompoundAssign) - am.CacheTemporaries (ec); - - if (!is_statement) - use_temporaries = true; - Expression temp_source; if (embedded != null) { temp_source = embedded.EmitEmbedded (ec); @@ -443,34 +563,15 @@ namespace Mono.CSharp { } else temp_source = source; - if (use_temporaries){ - // - // Doing this for every path is too expensive - // I wonder if we can work around this and have a less - // expensive path - // - LocalTemporary tempo; - - tempo = new LocalTemporary (ec, source.Type); - - temp_source.Emit (ec); - tempo.Store (ec); - am.EmitAssign (ec, tempo); - if (!is_statement) - tempo.Emit (ec); - - tempo.Release (ec); - } else { - am.EmitAssign (ec, temp_source); - } - + am.EmitAssign (ec, temp_source, !is_statement, this is CompoundAssign); + if (embedded != null) { if (temp != null) temp.Release (ec); embedded.ReleaseEmbedded (ec); } } - + public override void Emit (EmitContext ec) { Emit (ec, false); @@ -482,23 +583,23 @@ namespace Mono.CSharp { } } - + // - // This class is used for compound assignments. + // This class is used for compound assignments. // class CompoundAssign : Assign { Binary.Operator op; public Expression original_source; - - public CompoundAssign (Binary.Operator op, Expression target, Expression source, Location l) - : base (target, source, l) + + public CompoundAssign (Binary.Operator op, Expression target, Expression source) + : base (target, source, target.Location) { original_source = source; this.op = op; } protected CompoundAssign (CompoundAssign embedded, Location l) - : this (embedded.op, embedded.target, embedded.source, l) + : this (embedded.op, embedded.target, embedded.source) { this.is_embedded = true; } @@ -508,11 +609,6 @@ namespace Mono.CSharp { return new CompoundAssign (this, loc); } - public Expression ResolveSource (EmitContext ec) - { - return original_source.Resolve (ec); - } - public override Expression DoResolve (EmitContext ec) { original_source = original_source.Resolve (ec); @@ -522,18 +618,14 @@ namespace Mono.CSharp { target = target.Resolve (ec); if (target == null) return null; - + // // Only now we can decouple the original source/target // into a tree, to guarantee that we do not have side // effects. // - source = new Binary (op, target, original_source, loc); + source = new Binary (op, target, original_source); return base.DoResolve (ec); } } } - - - -