--- a/trunk/src/Parser.d	Tue Jul 10 22:42:05 2007 +0000
+++ b/trunk/src/Parser.d	Wed Jul 11 12:56:02 2007 +0000
@@ -1637,6 +1637,112 @@
     return params;
   }
 
+  TemplateParameter[] parseTemplateParameters()
+  {
+    require(T.LParen);
+    if (token.type == T.RParen)
+      return null;
+
+    TemplateParameter[] tparams;
+    while (1)
+    {
+      TP tp;
+      string ident;
+      Type valueType;
+      Type specType, defType;
+      Expression specValue, defValue;
+
+      switch (token.type)
+      {
+      case T.Alias:
+        // TemplateAliasParameter:
+        //         alias Identifier
+        tp = TP.Alias;
+        nT(); // Skip alias keyword.
+        ident = requireIdentifier();
+        // : SpecializationType
+        if (token.type == T.Colon)
+        {
+          nT();
+          specType = parseType();
+        }
+        // = DefaultType
+        if (token.type == T.Assign)
+        {
+          nT();
+          defType = parseType();
+        }
+        break;
+      case T.Identifier:
+        ident = token.identifier;
+        Token peeked;
+        lx.peek(peeked);
+        switch (peeked.type)
+        {
+        case T.Ellipses:
+          // TemplateTupleParameter:
+          //         Identifier ...
+          tp = TP.Tuple;
+          nT(); // Skip Identifier.
+          nT(); // Skip Ellipses.
+          // if (token.type == T.Comma)
+          //  error(); // TODO: issue error msg for variadic param not being last.
+          break;
+        case T.Comma, T.RParen, T.Colon, T.Assign:
+          // TemplateTypeParameter:
+          //         Identifier
+          tp = TP.Type;
+          nT(); // Skip Identifier.
+          // : SpecializationType
+          if (token.type == T.Colon)
+          {
+            nT();
+            specType = parseType();
+          }
+          // = DefaultType
+          if (token.type == T.Assign)
+          {
+            nT();
+            defType = parseType();
+          }
+          break;
+        default:
+          // TemplateValueParameter:
+          //         Declarator
+          ident = null;
+          goto LTemplateValueParameter;
+        }
+        break;
+      default:
+      LTemplateValueParameter:
+        // TemplateValueParameter:
+        //         Declarator
+        tp = TP.Value;
+        valueType = parseDeclarator(ident);
+        // : SpecializationValue
+        if (token.type == T.Colon)
+        {
+          nT();
+          specValue = parseCondExpression();
+        }
+        // = DefaultValue
+        if (token.type == T.Assign)
+        {
+          nT();
+          defValue = parseCondExpression();
+        }
+      }
+
+      tparams ~= new TemplateParameter(tp, valueType, specType, defType, specValue, defValue);
+
+      if (token.type != T.Comma)
+        break;
+      nT();
+    }
+    require(T.RParen);
+    return tparams;
+  }
+
   void expected(TOK tok)
   {
     if (token.type != tok)

--- a/trunk/src/Types.d	Tue Jul 10 22:42:05 2007 +0000
+++ b/trunk/src/Types.d	Wed Jul 11 12:56:02 2007 +0000
@@ -71,6 +71,31 @@
   { return items.length; }
 }
 
+enum TP
+{
+  Type,
+  Value,
+  Alias,
+  Tuple
+}
+
+class TemplateParameter
+{
+  TP tp;
+  Type valueType;
+  Type specType, defType;
+  Expression specValue, defValue;
+  this(TP tp, Type valueType, Type specType, Type defType, Expression specValue, Expression defValue)
+  {
+    this.tp = tp;
+    this.valueType = valueType;
+    this.specType = specType;
+    this.defType = defType;
+    this.specValue = specValue;
+    this.defValue = defValue;
+  }
+}
+
 enum TID
 {
   Void    = TOK.Void,