--- a/trunk/src/Expressions.d	Sun Jul 15 19:40:04 2007 +0000
+++ b/trunk/src/Expressions.d	Sun Jul 15 21:35:05 2007 +0000
@@ -612,3 +612,30 @@
     this.funcTok = funcTok;
   }
 }
+
+class VoidInitializer : Expression
+{
+
+}
+
+class ArrayInitializer : Expression
+{
+  Expression[] keys;
+  Expression[] values;
+  this(Expression[] keys, Expression[] values)
+  {
+    this.keys = keys;
+    this.values = values;
+  }
+}
+
+class StructInitializer : Expression
+{
+  string[] idents;
+  Expression[] values;
+  this(string[] idents, Expression[] values)
+  {
+    this.idents = idents;
+    this.values = values;
+  }
+}

--- a/trunk/src/Parser.d	Sun Jul 15 19:40:04 2007 +0000
+++ b/trunk/src/Parser.d	Sun Jul 15 21:35:05 2007 +0000
@@ -281,7 +281,99 @@
 
   Expression parseInitializer()
   {
-    return null;
+    if (token.type == T.Void)
+    {
+      Token next;
+      lx.peek(next);
+      if (next.type == T.Comma || next.type == T.Semicolon)
+      {
+        nT();
+        return new VoidInitializer();
+      }
+    }
+    return parseNonVoidInitializer();
+  }
+
+  Expression parseNonVoidInitializer()
+  {
+    Expression init;
+    switch (token.type)
+    {
+    case T.LBracket:
+      // ArrayInitializer:
+      //         [ ]
+      //         [ ArrayMemberInitializations ]
+      Expression[] keys;
+      Expression[] values;
+      while (1)
+      {
+        auto e = parseNonVoidInitializer();
+        if (token.type == T.Colon)
+        {
+          nT();
+          keys ~= e;
+          values ~= parseNonVoidInitializer();
+        }
+        else
+        {
+          keys ~= null;
+          values ~= e;
+        }
+
+        if (token.type != T.Comma)
+          break;
+        nT();
+        if (token.type == T.RBracket)
+          break;
+      }
+      require(T.RBracket);
+      init = new ArrayInitializer(keys, values);
+      break;
+    case T.LBrace:
+      // StructInitializer:
+      //         {  }
+      //         { StructMemberInitializers }
+      Expression parseStructInitializer()
+      {
+        string[] idents;
+        Expression[] values;
+        while (1)
+        {
+          if (token.type == T.Identifier)
+          {
+            Token next;
+            lx.peek(next);
+            // Peek for colon to see if this is a member identifier.
+            if (next.type == T.Colon)
+            {
+              idents ~= token.identifier();
+              nT();
+              nT();
+            }
+          }
+          // NonVoidInitializer
+          values ~= parseNonVoidInitializer();
+
+          if (token.type != T.Comma)
+            break;
+          nT();
+          if (token.type == T.RBrace)
+            break;
+        }
+        require(T.RBrace);
+        return new StructInitializer(idents, values);
+      }
+      bool failed;
+      auto si = try_(parseStructInitializer(), failed);
+      if (!failed)
+        init = si;
+      //else
+        // TODO: issue error msg.
+      break;
+    default:
+      init = parseAssignExpression();
+    }
+    return init;
   }
 
   FunctionBody parseFunctionBody(FunctionBody func)