X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fassign.cs;h=dabe1c75d39e01ae4589ed17ebf5baefcec49d9c;hb=c7fe6cd0226fa8063813d82218c10a9d5b052f34;hp=dae00366584056cbf497f1f09ac838a78a6414b8;hpb=d41bec356a9a7fd7312dd31b32569fe5f8a544f0;p=mono.git diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs old mode 100755 new mode 100644 index dae00366584..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. + */ } /// @@ -55,24 +162,32 @@ namespace Mono.CSharp { /// The local temporary is used to alter the normal flow of code generation /// basically it creates a local variable, and its emit instruction generates /// 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. + /// + /// 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 + /// to the origional value so that you can modify it in that location. This + /// Does not happen with a class because a class is a pointer -- so you always + /// get the indirection. + /// + /// The `is_address' stuff is really just a hack. We need to come up with a better + /// way to handle it. /// public class LocalTemporary : Expression, IMemoryLocation { LocalBuilder builder; - - 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 (t); + this.is_address = is_address; } - public void Release (EmitContext ec) - { - ec.FreeTemporaryLocal (builder, type); - builder = null; - } - public LocalTemporary (LocalBuilder b, Type t) { type = t; @@ -80,7 +195,13 @@ namespace Mono.CSharp { loc = Location.Null; builder = b; } - + + public void Release (EmitContext ec) + { + ec.FreeTemporaryLocal (builder, type); + builder = null; + } + public override Expression DoResolve (EmitContext ec) { return this; @@ -88,23 +209,51 @@ namespace Mono.CSharp { public override void Emit (EmitContext ec) { - ec.ig.Emit (OpCodes.Ldloc, builder); + ILGenerator ig = ec.ig; + + ig.Emit (OpCodes.Ldloc, builder); + // we need to copy from the pointer + if (is_address) + LoadFromPtr (ig, type); } + // NB: if you have `is_address' on the stack there must + // be a managed pointer. Otherwise, it is the type from + // the ctor. public void Store (EmitContext ec) { - ec.ig.Emit (OpCodes.Stloc, builder); + 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) { - ec.ig.Emit (OpCodes.Ldloca, builder); + 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 + ig.Emit (OpCodes.Ldloca, builder); + } + + public bool PointsToAddress { + get { + return is_address; + } } } /// /// 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; @@ -113,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; @@ -153,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 + "')"); } // @@ -168,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. @@ -183,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; @@ -200,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; @@ -220,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 @@ -234,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, @@ -260,50 +412,77 @@ 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 (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_type. + // the type of target // if (Convert.ImplicitStandardConversionExists (a.original_source, target_type)) return this; - Convert.Error_CannotImplicitConversion (loc, a.original_source.Type, target_type); + // + // In the spec 2.4 they added: or if type of the target is int + // and the operator is a shift operator... + // + if (source_type == TypeManager.int32_type && + (b.Oper == Binary.Operator.LeftShift || b.Oper == Binary.Operator.RightShift)) + return this; + + 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; @@ -315,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; } @@ -347,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; } @@ -370,21 +549,7 @@ 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); - use_temporaries = true; - } - - if (!is_statement) - use_temporaries = true; Expression temp_source; if (embedded != null) { @@ -398,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); @@ -437,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; } @@ -463,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); @@ -477,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); } } } - - - -