# HG changeset patch
# User Trass3r
# Date 1283271511 -7200
# Node ID d8f19d85fadba3cb9941e742207aa82aca9fa536
# Parent  e6090d1aea7cbed51b6c9a526f2330e6d783674f
changes from interpret.c

diff -r e6090d1aea7c -r d8f19d85fadb dmd/FuncDeclaration.d
--- a/dmd/FuncDeclaration.d	Tue Aug 31 16:22:22 2010 +0200
+++ b/dmd/FuncDeclaration.d	Tue Aug 31 18:18:31 2010 +0200
@@ -2339,13 +2339,28 @@
 }
 		if (global.errors)
 			return null;
+version(DMDV1)
+{
 		if (ident == Id.aaLen)
 			return interpret_aaLen(istate, arguments);
 		else if (ident == Id.aaKeys)
 			return interpret_aaKeys(istate, arguments);
 		else if (ident == Id.aaValues)
 			return interpret_aaValues(istate, arguments);
-
+}
+else version(DMDV2)
+{
+		if (thisarg && (!arguments || arguments.dim == 0))
+		{
+			if (ident == Id.length)
+				return interpret_length(istate, thisarg);
+			else if (ident == Id.keys)
+				return interpret_keys(istate, thisarg, this);
+			else if (ident == Id.values)
+				return interpret_values(istate, thisarg, this);
+		}
+}
+	
 		if (cantInterpret || semanticRun == 3)
 			return null;
 
diff -r e6090d1aea7c -r d8f19d85fadb dmd/interpret/Util.d
--- a/dmd/interpret/Util.d	Tue Aug 31 16:22:22 2010 +0200
+++ b/dmd/interpret/Util.d	Tue Aug 31 18:18:31 2010 +0200
@@ -2,6 +2,7 @@
 
 import dmd.StructDeclaration;
 import dmd.Expression;
+import dmd.FuncDeclaration;
 import dmd.InterState;
 import dmd.ArrayTypes;
 import dmd.GlobalExpressions;
@@ -13,74 +14,130 @@
 import dmd.Loc;
 import dmd.ArrayLiteralExp;
 import dmd.TypeAArray;
+import dmd.TypeFunction;
 import dmd.TypeSArray;
+import dmd.TY;
 import dmd.STC;
 import dmd.SymbolDeclaration;
 import dmd.StructLiteralExp;
 import dmd.VarDeclaration;
 import dmd.Util;
 
+version(DMDV1)
+{
 Expression interpret_aaLen(InterState istate, Expressions arguments)
 {
-    if (!arguments || arguments.dim != 1)
+	if (!arguments || arguments.dim != 1)
 		return null;
-    auto earg = arguments[0];
-    earg = earg.interpret(istate);
-    if (earg is EXP_CANT_INTERPRET)
+	auto earg = arguments[0];
+	earg = earg.interpret(istate);
+	if (earg is EXP_CANT_INTERPRET)
 		return null;
-    if (earg.op != TOKassocarrayliteral)
+	if (earg.op != TOKassocarrayliteral)
 		return null;
-    auto aae = cast(AssocArrayLiteralExp)earg;
-    auto e = new IntegerExp(aae.loc, aae.keys.dim, Type.tsize_t);
-    return e;
+	auto aae = cast(AssocArrayLiteralExp)earg;
+	auto e = new IntegerExp(aae.loc, aae.keys.dim, Type.tsize_t);
+	return e;
 }
 
 Expression interpret_aaKeys(InterState istate, Expressions arguments)
 {
 version (LOG) {
-    printf("interpret_aaKeys()\n");
+	writef("interpret_aaKeys()\n");
 }
-    if (!arguments || arguments.dim != 2)
+	if (!arguments || arguments.dim != 2)
 		return null;
-    auto earg = arguments[0];
-    earg = earg.interpret(istate);
-    if (earg is EXP_CANT_INTERPRET)
+	auto earg = arguments[0];
+	earg = earg.interpret(istate);
+	if (earg is EXP_CANT_INTERPRET)
 		return null;
-    if (earg.op != TOKassocarrayliteral)
+	if (earg.op != TOKassocarrayliteral)
 		return null;
-    auto aae = cast(AssocArrayLiteralExp)earg;
-    auto e = new ArrayLiteralExp(aae.loc, aae.keys);
-    Type elemType = (cast(TypeAArray)aae.type).index;
-    e.type = new TypeSArray(elemType, new IntegerExp(arguments ? arguments.dim : 0));
-    return e;
+	auto aae = cast(AssocArrayLiteralExp)earg;
+	auto e = new ArrayLiteralExp(aae.loc, aae.keys);
+	Type elemType = (cast(TypeAArray)aae.type).index;
+	e.type = new TypeSArray(elemType, new IntegerExp(arguments ? arguments.dim : 0));
+	return e;
 }
 
 Expression interpret_aaValues(InterState istate, Expressions arguments)
 {
-    //printf("interpret_aaValues()\n");
-    if (!arguments || arguments.dim != 3)
+	//writef("interpret_aaValues()\n");
+	if (!arguments || arguments.dim != 3)
+		return null;
+	auto earg = arguments[0];
+	earg = earg.interpret(istate);
+	if (earg is EXP_CANT_INTERPRET)
+		return null;
+	if (earg.op != TOKassocarrayliteral)
 		return null;
-    auto earg = arguments[0];
-    earg = earg.interpret(istate);
-    if (earg is EXP_CANT_INTERPRET)
+	auto aae = cast(AssocArrayLiteralExp)earg;
+	auto e = new ArrayLiteralExp(aae.loc, aae.values);
+	Type elemType = (cast(TypeAArray)aae.type).next;
+	e.type = new TypeSArray(elemType, new IntegerExp(arguments ? arguments.dim : 0));
+	//writef("result is %s\n", e.toChars());
+	return e;
+}
+}
+else version(DMDV2)
+{
+Expression interpret_length(InterState istate, Expression earg)
+{
+//	writef("interpret_length()\n");
+	earg = earg.interpret(istate);
+	if (earg == EXP_CANT_INTERPRET)
+		return null;
+	if (earg.op != TOKassocarrayliteral)
 		return null;
-    if (earg.op != TOKassocarrayliteral)
+	AssocArrayLiteralExp aae = cast(AssocArrayLiteralExp)earg;
+	Expression e = new IntegerExp(aae.loc, aae.keys.dim, Type.tsize_t);
+	return e;
+}
+
+Expression interpret_keys(InterState istate, Expression earg, FuncDeclaration fd)
+{
+version(LOG)
+	writef("interpret_keys()\n");
+
+	earg = earg.interpret(istate);
+	if (earg == EXP_CANT_INTERPRET)
+	return null;
+	if (earg.op != TOKassocarrayliteral)
+	return null;
+	AssocArrayLiteralExp aae = cast(AssocArrayLiteralExp)earg;
+	Expression e = new ArrayLiteralExp(aae.loc, aae.keys);
+	assert(fd.type.ty == Tfunction);
+	assert(fd.type.nextOf().ty == Tarray);
+	Type elemType = (cast(TypeFunction)fd.type).nextOf().nextOf();
+	e.type = new TypeSArray(elemType, new IntegerExp(aae.keys.dim));
+	return e;
+}
+Expression interpret_values(InterState istate, Expression earg, FuncDeclaration fd)
+{
+	//writef("interpret_values()\n");
+	earg = earg.interpret(istate);
+	if (earg == EXP_CANT_INTERPRET)
 		return null;
-    auto aae = cast(AssocArrayLiteralExp)earg;
-    auto e = new ArrayLiteralExp(aae.loc, aae.values);
-    Type elemType = (cast(TypeAArray)aae.type).next;
-    e.type = new TypeSArray(elemType, new IntegerExp(arguments ? arguments.dim : 0));
-    //printf("result is %s\n", e.toChars());
-    return e;
+	if (earg.op != TOKassocarrayliteral)
+		return null;
+	AssocArrayLiteralExp aae = cast(AssocArrayLiteralExp)earg;
+	Expression e = new ArrayLiteralExp(aae.loc, aae.values);
+	assert(fd.type.ty == Tfunction);
+	assert(fd.type.nextOf().ty == Tarray);
+	Type elemType = (cast(TypeFunction)fd.type).nextOf().nextOf();
+	e.type = new TypeSArray(elemType, new IntegerExp(aae.values.dim));
+	//writef("result is %s\n", e.toChars());
+	return e;
+}
 }
 
 Expression getVarExp(Loc loc, InterState istate, Declaration d)
 {
-    Expression e = EXP_CANT_INTERPRET;
-    VarDeclaration v = d.isVarDeclaration();
-    SymbolDeclaration s = d.isSymbolDeclaration();
-    if (v)
-    {
+	Expression e = EXP_CANT_INTERPRET;
+	VarDeclaration v = d.isVarDeclaration();
+	SymbolDeclaration s = d.isSymbolDeclaration();
+	if (v)
+	{
 ///version (DMDV2) {
 		if ((v.isConst() || v.isInvariant() || v.storage_class & STCmanifest) && v.init && !v.value)
 ///} else {
@@ -106,17 +163,17 @@
 		}
 		if (!e)
 			e = EXP_CANT_INTERPRET;
-    }
-    else if (s)
-    {
+	}
+	else if (s)
+	{
 		if (s.dsym.toInitializer() == s.sym)
 		{   
 			Expressions exps = new Expressions();
 			e = new StructLiteralExp(Loc(0), s.dsym, exps);
 			e = e.semantic(null);
 		}
-    }
-    return e;
+	}
+	return e;
 }
 
 /* Helper functions for BinExp.interpretAssignCommon
@@ -127,16 +184,16 @@
  */
 Expressions changeOneElement(Expressions oldelems, size_t indexToChange, Expression newelem)
 {
-    auto expsx = new Expressions();
-    expsx.setDim(oldelems.dim);
-    for (size_t j = 0; j < expsx.dim; j++)
-    {
+	auto expsx = new Expressions();
+	expsx.setDim(oldelems.dim);
+	for (size_t j = 0; j < expsx.dim; j++)
+	{
 		if (j == indexToChange)
 			expsx[j] = newelem;
 		else
 			expsx[j] = oldelems[j];
-    }
-    return expsx;
+	}
+	return expsx;
 }
 
 /***************************************
@@ -144,16 +201,16 @@
  */
 Expressions spliceElements(Expressions oldelems, Expressions newelems, size_t insertpoint)
 {
-    auto expsx = new Expressions();
-    expsx.setDim(oldelems.dim);
-    for (size_t j = 0; j < expsx.dim; j++)
-    {
+	auto expsx = new Expressions();
+	expsx.setDim(oldelems.dim);
+	for (size_t j = 0; j < expsx.dim; j++)
+	{
 		if (j >= insertpoint && j < insertpoint + newelems.dim)
 			expsx[j] = newelems[j - insertpoint];
 		else
 			expsx[j] = oldelems[j];
-    }
-    return expsx;
+	}
+	return expsx;
 }
 
 /******************************
@@ -161,15 +218,15 @@
  */
 ArrayLiteralExp createBlockDuplicatedArrayLiteral(Type type, Expression elem, size_t dim)
 {
-    auto elements = new Expressions();
-    elements.setDim(dim);
-    for (size_t i = 0; i < dim; i++) {
+	auto elements = new Expressions();
+	elements.setDim(dim);
+	for (size_t i = 0; i < dim; i++) {
 		elements[i] = elem;
 	}
 	
-    auto ae = new ArrayLiteralExp(Loc(0), elements);
-    ae.type = type;
-    return ae;
+	auto ae = new ArrayLiteralExp(Loc(0), elements);
+	ae.type = type;
+	return ae;
 }
 
 
@@ -178,17 +235,17 @@
  */
 StructLiteralExp createDefaultInitStructLiteral(Loc loc, StructDeclaration sym)
 {
-    Expressions structelems = new Expressions();
-    structelems.setDim(sym.fields.dim);
-    for (size_t j = 0; j < structelems.dim; j++)
-    {
+	Expressions structelems = new Expressions();
+	structelems.setDim(sym.fields.dim);
+	for (size_t j = 0; j < structelems.dim; j++)
+	{
 		structelems[j] = sym.fields[j].type.defaultInit(Loc(0));
-    }
-    StructLiteralExp structinit = new StructLiteralExp(loc, sym, structelems);
-    // Why doesn't the StructLiteralExp constructor do this, when
-    // sym.type != null ?
-    structinit.type = sym.type;
-    return structinit;
+	}
+	StructLiteralExp structinit = new StructLiteralExp(loc, sym, structelems);
+	// Why doesn't the StructLiteralExp constructor do this, when
+	// sym.type != null ?
+	structinit.type = sym.type;
+	return structinit;
 }
 
 /********************************
@@ -196,18 +253,18 @@
  */
 void addVarToInterstate(InterState istate, VarDeclaration v)
 {
-    if (!v.isParameter())
-    {
+	if (!v.isParameter())
+	{
 		for (size_t i = 0; 1; i++)
 		{
 			if (i == istate.vars.dim)
 			{   
 				istate.vars.push(v);
-				//printf("\tadding %s to istate\n", v.toChars());
+				//writef("\tadding %s to istate\n", v.toChars());
 				break;
 			}
 			if (v == cast(VarDeclaration)istate.vars[i])
 				break;
 		}
-    }
+	}
 }
\ No newline at end of file