--- a/dmd/ArrayLiteralExp.d	Sat Aug 28 16:14:07 2010 +0200
+++ b/dmd/ArrayLiteralExp.d	Sat Aug 28 16:19:48 2010 +0200
@@ -1,21 +1,21 @@
-module dmd.ArrayLiteralExp;
-
-import dmd.Expression;
-import dmd.backend.elem;
-import dmd.InterState;
-import dmd.MATCH;
-import dmd.Type;
-import dmd.OutBuffer;
-import dmd.Loc;
+module dmd.ArrayLiteralExp;
+
+import dmd.Expression;
+import dmd.backend.elem;
+import dmd.InterState;
+import dmd.MATCH;
+import dmd.Type;
+import dmd.OutBuffer;
+import dmd.Loc;
 import dmd.WANT;
-import dmd.Scope;
-import dmd.InlineCostState;
-import dmd.IRState;
-import dmd.InlineDoState;
-import dmd.HdrGenState;
-import dmd.backend.dt_t;
-import dmd.InlineScanState;
-import dmd.ArrayTypes;
+import dmd.Scope;
+import dmd.InlineCostState;
+import dmd.IRState;
+import dmd.InlineDoState;
+import dmd.HdrGenState;
+import dmd.backend.dt_t;
+import dmd.InlineScanState;
+import dmd.ArrayTypes;
 import dmd.TOK;
 import dmd.IntegerExp;
 import dmd.TypeSArray;
@@ -25,18 +25,18 @@
 import dmd.expression.Util;
 import dmd.backend.Util;
 import dmd.backend.RTLSYM;
-import dmd.backend.OPER;
+import dmd.backend.OPER;
 import dmd.backend.Symbol;
 import dmd.backend.TYM;
-import dmd.backend.mTY;
-import dmd.codegen.Util;
-
+import dmd.backend.mTY;
+import dmd.codegen.Util;
+
 class ArrayLiteralExp : Expression
 {
 	Expressions elements;
 
 	this(Loc loc, Expressions elements)
-	{
+	{
 		super(loc, TOK.TOKarrayliteral, ArrayLiteralExp.sizeof);
 		this.elements = elements;
 	}
@@ -48,12 +48,12 @@
 		elements.push(cast(void*)e);
 	}
 
-	Expression syntaxCopy()
+	override Expression syntaxCopy()
 	{
 		return new ArrayLiteralExp(loc, arraySyntaxCopy(elements));
 	}
 
-	Expression semantic(Scope sc)
+	override Expression semantic(Scope sc)
 	{
 		Expression e;
 		Type t0 = null;
@@ -116,13 +116,13 @@
 		return this;
 	}
 
-	bool isBool(bool result)
+	override bool isBool(bool result)
 	{
 		size_t dim = elements ? elements.dim : 0;
 		return result ? (dim != 0) : (dim == 0);
 	}
 
-	elem* toElem(IRState* irs)
+	override elem* toElem(IRState* irs)
 	{
 		elem* e;
 		size_t dim;
@@ -188,7 +188,7 @@
 		return e;
 	}
 
-	bool checkSideEffect(int flag)
+	override bool checkSideEffect(int flag)
 	{
 		bool f = false;
 
@@ -203,14 +203,14 @@
 		return f;
 	}
 
-	void toCBuffer(OutBuffer buf, HdrGenState* hgs)
+	override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
 	{
 		buf.writeByte('[');
 		argsToCBuffer(buf, elements, hgs);
 		buf.writeByte(']');
 	}
 
-	void toMangleBuffer(OutBuffer buf)
+	override void toMangleBuffer(OutBuffer buf)
 	{
 		size_t dim = elements ? elements.dim : 0;
 		buf.printf("A%u", dim);
@@ -221,12 +221,12 @@
 		}
 	}
 
-	void scanForNestedRef(Scope sc)
+	override void scanForNestedRef(Scope sc)
 	{
 		assert(false);
 	}
 
-	Expression optimize(int result)
+	override Expression optimize(int result)
 	{
 		if (elements)
 		{
@@ -242,12 +242,12 @@
 		return this;
 	}
 
-	Expression interpret(InterState istate)
+	override Expression interpret(InterState istate)
 	{
 		assert(false);
 	}
 
-	MATCH implicitConvTo(Type t)
+	override MATCH implicitConvTo(Type t)
 	{
 		MATCH result = MATCHexact;
 
@@ -282,7 +282,7 @@
 			return Expression.implicitConvTo(t);
 	}
 
-	Expression castTo(Scope sc, Type t)
+	override Expression castTo(Scope sc, Type t)
 	{
 	static if (false) {
 		printf("ArrayLiteralExp.castTo(this=%s, type=%s, => %s)\n",
@@ -329,73 +329,73 @@
 		return e.Expression.castTo(sc, t);
 	}
 
-	dt_t** toDt(dt_t** pdt)
+	override dt_t** toDt(dt_t** pdt)
 	{
-		//printf("ArrayLiteralExp.toDt() '%s', type = %s\n", toChars(), type.toChars());
-
-		dt_t *d;
-		dt_t **pdtend;
-
-		d = null;
-		pdtend = &d;
-		for (int i = 0; i < elements.dim; i++)
-		{	
-			Expression e = cast(Expression)elements.data[i];
-
-			pdtend = e.toDt(pdtend);
-		}
-		Type t = type.toBasetype();
-
-		switch (t.ty)
-		{
-			case Tsarray:
-				pdt = dtcat(pdt, d);
-				break;
-
-			case Tpointer:
-			case Tarray:
-				if (t.ty == Tarray)
-					dtdword(pdt, elements.dim);
-				if (d)
-				{
-					// Create symbol, and then refer to it
-					Symbol* s;
-					s = static_sym();
-					s.Sdt = d;
-					outdata(s);
-
-					dtxoff(pdt, s, 0, TYnptr);
-				}
-				else
-					dtdword(pdt, 0);
-
-				break;
-
-			default:
-				assert(0);
-		}
+		//printf("ArrayLiteralExp.toDt() '%s', type = %s\n", toChars(), type.toChars());
+
+		dt_t *d;
+		dt_t **pdtend;
+
+		d = null;
+		pdtend = &d;
+		for (int i = 0; i < elements.dim; i++)
+		{	
+			Expression e = cast(Expression)elements.data[i];
+
+			pdtend = e.toDt(pdtend);
+		}
+		Type t = type.toBasetype();
+
+		switch (t.ty)
+		{
+			case Tsarray:
+				pdt = dtcat(pdt, d);
+				break;
+
+			case Tpointer:
+			case Tarray:
+				if (t.ty == Tarray)
+					dtdword(pdt, elements.dim);
+				if (d)
+				{
+					// Create symbol, and then refer to it
+					Symbol* s;
+					s = static_sym();
+					s.Sdt = d;
+					outdata(s);
+
+					dtxoff(pdt, s, 0, TYnptr);
+				}
+				else
+					dtdword(pdt, 0);
+
+				break;
+
+			default:
+				assert(0);
+		}
 		return pdt;
 	}
 
 version (DMDV2) {
-	bool canThrow()
+	override bool canThrow()
 	{
 		return 1;	// because it can fail allocating memory
 	}
 }
-	int inlineCost(InlineCostState* ics)
+	override int inlineCost(InlineCostState* ics)
 	{
 		return 1 + arrayInlineCost(ics, elements);
 	}
 
-	Expression doInline(InlineDoState ids)
+	override Expression doInline(InlineDoState ids)
 	{
 		ArrayLiteralExp ce = cast(ArrayLiteralExp)copy();
 		ce.elements = arrayExpressiondoInline(elements, ids);
 		return ce;
 	}
 
-	Expression inlineScan(InlineScanState* iss)
+	override Expression inlineScan(InlineScanState* iss)
 	{
 		Expression e = this;