--- a/dmd/UnaExp.d	Sat Aug 28 16:14:07 2010 +0200
+++ b/dmd/UnaExp.d	Sat Aug 28 16:19:48 2010 +0200
@@ -1,76 +1,76 @@
-module dmd.UnaExp;
-
-import dmd.Expression;
-import dmd.InterState;
-import dmd.TY;
-import dmd.TypeClass;
-import dmd.TypeStruct;
-import dmd.Dsymbol;
-import dmd.AggregateDeclaration;
-import dmd.Type;
-import dmd.OutBuffer;
-import dmd.Loc;
-import dmd.TOK;
-import dmd.Scope;
-import dmd.InlineCostState;
-import dmd.InlineDoState;
-import dmd.HdrGenState;
-import dmd.InlineScanState;
-import dmd.DotIdExp;
-import dmd.ArrayExp;
-import dmd.CallExp;
-import dmd.PREC;
-import dmd.Token;
-import dmd.expression.Util;
-
+module dmd.UnaExp;
+
+import dmd.Expression;
+import dmd.InterState;
+import dmd.TY;
+import dmd.TypeClass;
+import dmd.TypeStruct;
+import dmd.Dsymbol;
+import dmd.AggregateDeclaration;
+import dmd.Type;
+import dmd.OutBuffer;
+import dmd.Loc;
+import dmd.TOK;
+import dmd.Scope;
+import dmd.InlineCostState;
+import dmd.InlineDoState;
+import dmd.HdrGenState;
+import dmd.InlineScanState;
+import dmd.DotIdExp;
+import dmd.ArrayExp;
+import dmd.CallExp;
+import dmd.PREC;
+import dmd.Token;
+import dmd.expression.Util;
+
 class UnaExp : Expression
 {
 	Expression e1;
 
 	this(Loc loc, TOK op, int size, Expression e1)
 	{
-		super(loc, op, size);
+		super(loc, op, size);
 		this.e1 = e1;
 	}
 
-	Expression syntaxCopy()
+	override Expression syntaxCopy()
 	{
-		UnaExp e = cast(UnaExp)copy();
-		e.type = null;
-		e.e1 = e.e1.syntaxCopy();
-
+		UnaExp e = cast(UnaExp)copy();
+		e.type = null;
+		e.e1 = e.e1.syntaxCopy();
+
 		return e;
 	}
 
-	Expression semantic(Scope sc)
+	override Expression semantic(Scope sc)
 	{
-version (LOGSEMANTIC) {
-		writef("UnaExp.semantic('%s')\n", toChars());
-}
-		e1 = e1.semantic(sc);
-	//    if (!e1.type)
-	//	error("%s has no value", e1.toChars());
+version (LOGSEMANTIC) {
+		writef("UnaExp.semantic('%s')\n", toChars());
+}
+		e1 = e1.semantic(sc);
+	//    if (!e1.type)
+	//	error("%s has no value", e1.toChars());
 		return this;
 	}
 
-	void toCBuffer(OutBuffer buf, HdrGenState* hgs)
+	override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
 	{
-		buf.writestring(Token.toChars(op));
+		buf.writestring(Token.toChars(op));
 		expToCBuffer(buf, hgs, e1, precedence[op]);
 	}
 
-	Expression optimize(int result)
+	override Expression optimize(int result)
 	{
-		e1 = e1.optimize(result);
+		e1 = e1.optimize(result);
 		return this;
 	}
 
-	void dump(int indent)
+	override void dump(int indent)
 	{
 		assert(false);
 	}
 
-	void scanForNestedRef(Scope sc)
+	override void scanForNestedRef(Scope sc)
 	{
 		e1.scanForNestedRef(sc);
 	}
@@ -80,89 +80,89 @@
 		assert(false);
 	}
 
-	bool canThrow()
+	override bool canThrow()
 	{
 		return e1.canThrow();
 	}
 
-	int inlineCost(InlineCostState* ics)
+	override int inlineCost(InlineCostState* ics)
 	{
 		return 1 + e1.inlineCost(ics);
 	}
 
-	Expression doInline(InlineDoState ids)
+	override Expression doInline(InlineDoState ids)
 	{
-		UnaExp ue = cast(UnaExp)copy();
-
-		ue.e1 = e1.doInline(ids);
+		UnaExp ue = cast(UnaExp)copy();
+
+		ue.e1 = e1.doInline(ids);
 		return ue;
 	}
 
-	Expression inlineScan(InlineScanState* iss)
+	override Expression inlineScan(InlineScanState* iss)
 	{
-		e1 = e1.inlineScan(iss);
+		e1 = e1.inlineScan(iss);
 		return this;
-	}
-	
-	/************************************
-	 * Operator overload.
-	 * Check for operator overload, if so, replace
-	 * with function call.
-	 * Return null if not an operator overload.
+	}
+	
+	/************************************
+	 * Operator overload.
+	 * Check for operator overload, if so, replace
+	 * with function call.
+	 * Return null if not an operator overload.
 	 */
 	Expression op_overload(Scope sc)
 	{
-		//printf("UnaExp.op_overload() (%s)\n", toChars());
-		AggregateDeclaration ad;
-		Dsymbol fd;
-		Type t1 = e1.type.toBasetype();
-
-		if (t1.ty == TY.Tclass)
-		{
-			ad = (cast(TypeClass)t1).sym;
-			goto L1;
-		}
-		else if (t1.ty == TY.Tstruct)
-		{
-			ad = (cast(TypeStruct)t1).sym;
-
-			L1:
-			fd = search_function(ad, opId());
-			if (fd)
-			{
-				if (op == TOK.TOKarray)
-				{
-					/* Rewrite op e1[arguments] as:
-					 *    e1.fd(arguments)
-					 */
-					Expression e = new DotIdExp(loc, e1, fd.ident);
-					ArrayExp ae = cast(ArrayExp)this;
-					e = new CallExp(loc, e, ae.arguments);
-					e = e.semantic(sc);
-					return e;
-				}
-				else
-				{
-					// Rewrite +e1 as e1.add()
-					return build_overload(loc, sc, e1, null, fd.ident);
-				}
-			}
-
-version (DMDV2) {
-			// Didn't find it. Forward to aliasthis
-			if (ad.aliasthis)
-			{
-				/* Rewrite op(e1) as:
-				 *	op(e1.aliasthis)
-				 */
-				Expression e1 = new DotIdExp(loc, this.e1, ad.aliasthis.ident);
-				Expression e = copy();
-				(cast(UnaExp)e).e1 = e1;
-				e = e.semantic(sc);
-				return e;
-			}
-}
-		}
+		//printf("UnaExp.op_overload() (%s)\n", toChars());
+		AggregateDeclaration ad;
+		Dsymbol fd;
+		Type t1 = e1.type.toBasetype();
+
+		if (t1.ty == TY.Tclass)
+		{
+			ad = (cast(TypeClass)t1).sym;
+			goto L1;
+		}
+		else if (t1.ty == TY.Tstruct)
+		{
+			ad = (cast(TypeStruct)t1).sym;
+
+			L1:
+			fd = search_function(ad, opId());
+			if (fd)
+			{
+				if (op == TOK.TOKarray)
+				{
+					/* Rewrite op e1[arguments] as:
+					 *    e1.fd(arguments)
+					 */
+					Expression e = new DotIdExp(loc, e1, fd.ident);
+					ArrayExp ae = cast(ArrayExp)this;
+					e = new CallExp(loc, e, ae.arguments);
+					e = e.semantic(sc);
+					return e;
+				}
+				else
+				{
+					// Rewrite +e1 as e1.add()
+					return build_overload(loc, sc, e1, null, fd.ident);
+				}
+			}
+
+version (DMDV2) {
+			// Didn't find it. Forward to aliasthis
+			if (ad.aliasthis)
+			{
+				/* Rewrite op(e1) as:
+				 *	op(e1.aliasthis)
+				 */
+				Expression e1 = new DotIdExp(loc, this.e1, ad.aliasthis.ident);
+				Expression e = copy();
+				(cast(UnaExp)e).e1 = e1;
+				e = e.semantic(sc);
+				return e;
+			}
+}
+		}
 		return null;
 	}
 }